diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 6f03573372277..a658d35e7f0ef 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -103,7 +103,7 @@ jobs:
 
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: nightly
+          toolchain: nightly-2020-12-07
           components: rustfmt, clippy
           override: true
 
@@ -114,7 +114,7 @@ jobs:
         run: sudo apt-get update; sudo apt-get install --no-install-recommends libudev-dev
 
       - name: Check the format
-        run: cargo +nightly fmt --all -- --check
+        run: cargo +nightly-2020-12-07 fmt --all -- --check
 
       # type complexity must be ignored because we use huge templates for queries
       # -A clippy::manual-strip: strip_prefix support was added in 1.45. we want to support earlier rust versions
diff --git a/.gitignore b/.gitignore
index e690fffaad245..48bbc7e0e1c91 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,6 +3,7 @@ crates/*/target
 **/*.rs.bk
 Cargo.lock
 .cargo/config
+.cargo/config.toml
 /.idea
 /.vscode
-/benches/target
\ No newline at end of file
+/benches/target
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 39da8e5e61283..2b6ae7a4aa7c4 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,17 +4,217 @@ While we try to keep the `Unreleased` changes updated, it is often behind and do
 all merged pull requests. To see a list of all changes since the latest release, you may compare
 current changes on git with [previous release tags][git_tag_comparison].
 
-[git_tag_comparison]: https://github.com/bevyengine/bevy/compare/v0.3.0...master
+[git_tag_comparison]: https://github.com/bevyengine/bevy/compare/v0.4.0...master
 
 
-## Unreleased
+## Version 0.4.0 (2020-12-19)
 
 ### Added
+- [add bevymark benchmark example][273]
+- [gltf: support camera and fix hierarchy][772] 
+- [Add tracing spans to schedules, stages, systems][789]
+- [add example that represents contributors as bevy icons][801]
+- [Add received character][805]
+- [Add bevy_dylib to force dynamic linking of bevy][808] 
+- [Added RenderPass::set_scissor_rect][815]
+- [`bevy_log`][836]
+  - Adds logging functionality as a Plugin.
+  - Changes internal logging to work with the new implementation.
+- [cross-platform main function][847]
+- [Controllable ambient light color][852]
+  - Added a resource to change the current ambient light color for PBR.
+- [Added more basic color constants][859]
+- [Add box shape][883]
+- [Expose an EventId for events][894]
+- [System Inputs, Outputs, and Chaining][876]
+- [Expose an `EventId` for events][894]
+- [Added `set_cursor_position` to `Window`][917]
+- [Added new Bevy reflection system][926]
+  - Replaces the properties system
+- [Add support for Apple Silicon][928]
+- [Live reloading of shaders][937]
+- [ Store mouse cursor position in Window][940]
+- [Add removal_detection example][945]
+- [Additional vertex attribute value types][946]
+- [Added WindowFocused event][956]
+- [Tracing chrome span names][979]
+- [Allow windows to be maximized][1004]
+- [GLTF: load default material][1016]
+- [can spawn a scene from a ChildBuilder, or directly set its parent when spawning it][1026]
+- [add ability to load `.dds`, `.tga`, and `.jpeg` texture formats][1038]
+- [add ability to provide custom a `AssetIo` implementation][1037]
 
 ### Changed
 
+- [delegate layout reflection to RenderResourceContext][691] 
+- [Fall back to remove components one by one when failing to remove a bundle][719]
+- [Port hecs derive macro improvements][761] 
+- [Use glyph_brush_layout and add text alignment support][765]
+- [upgrade glam and hexasphere][791]
+- [Flexible ECS Params][798]
+- [Make Timer.tick return &Self][820]
+- [FileAssetIo includes full path on error][821]
+- [Removed ECS query APIs that could easily violate safety from the public interface][829]
+- [Changed Query filter API to be easier to understand][834]
+- [bevy_render: delegate buffer aligning to render_resource_context][842]
+- [wasm32: non-spirv shader specialization][843]
+- [Renamed XComponents to XBundle][863]
+- [Check for conflicting system resource parameters][864]
+- [Tweaks to TextureAtlasBuilder.finish()][887]
+- [do not spend time drawing text with is_visible = false][893]
+- [Extend the Texture asset type to support 3D data][903]
+- [Breaking changes to timer API][914]
+  - Created getters and setters rather than exposing struct members.
+- [Removed timer auto-ticking system][931]
+  - Added an example of how to tick timers manually.
+- [When a task scope produces <= 1 task to run, run it on the calling thread immediately][932]
+- [Breaking changes to Time API][934]
+  - Created getters to get `Time` state and made members private.
+  - Modifying `Time`'s values directly is no longer possible outside of bevy.
+- [Use `mailbox` instead of `fifo` for vsync on supported systems][920]
+- [switch winit size to logical to be dpi independent][947]
+- [Change bevy_input::Touch API to match similar APIs][952]
+- [Run parent-update and transform-propagation during the "post-startup" stage (instead of "startup")][955]
+- [Renderer Optimization Round 1][958]
+- [Change`TextureAtlasBuilder` into expected Builder conventions][969]
+- [Optimize Text rendering / SharedBuffers][972]
+- [hidpi swap chains][973]
+- [optimize asset gpu data transfer][987]
+- [naming coherence for cameras][995]
+- [Schedule v2][1021]
+- [Use shaderc for aarch64-apple-darwin][1027]
+- [update `Window`'s `width` & `height` methods to return `f32`][1033]
+- [Break out Visible component from Draw][1034]
+  - Users setting `Draw::is_visible` or `Draw::is_transparent` should now set `Visible::is_visible` and `Visible::is_transparent`
+- [`winit` upgraded from version 0.23 to version 0.24][1043]
+- [set is_transparent to true by default for UI bundles][1071]
+
 ### Fixed
 
+- [Fixed typos in KeyCode identifiers][857]
+- [Remove redundant texture copies in TextureCopyNode][871]
+- [Fix a deadlock that can occur when using scope() on ComputeTaskPool from within a system][892]
+- [Don't draw text that isn't visible][893]
+- [Use `instant::Instant` for WASM compatibility][895]
+- [Fix pixel format conversion in bevy_gltf][897]
+- [Fixed duplicated children when spawning a Scene][904]
+- [Corrected behaviour of the UI depth system][905]
+- [Allow despawning of hierarchies in threadlocal systems][908]
+- [Fix `RenderResources` index slicing][948]
+- [Run parent-update and transform-propagation during the "post-startup" stage][955]
+- [Fix collision detection by comparing abs() penetration depth][966]
+- [deal with rounding issue when creating the swap chain][997]
+- [only update components for entities in map][1023]
+- [Don't panic when attempting to set shader defs from an asset that hasn't loaded yet][1035]
+
+[273]: https://github.com/bevyengine/bevy/pull/273
+[691]: https://github.com/bevyengine/bevy/pull/691
+[719]: https://github.com/bevyengine/bevy/pull/719
+[761]: https://github.com/bevyengine/bevy/pull/761
+[761]: https://github.com/bevyengine/bevy/pull/761
+[765]: https://github.com/bevyengine/bevy/pull/765
+[772]: https://github.com/bevyengine/bevy/pull/772
+[772]: https://github.com/bevyengine/bevy/pull/772
+[789]: https://github.com/bevyengine/bevy/pull/789
+[791]: https://github.com/bevyengine/bevy/pull/791
+[798]: https://github.com/bevyengine/bevy/pull/798
+[801]: https://github.com/bevyengine/bevy/pull/801
+[801]: https://github.com/bevyengine/bevy/pull/801
+[805]: https://github.com/bevyengine/bevy/pull/805
+[808]: https://github.com/bevyengine/bevy/pull/808
+[815]: https://github.com/bevyengine/bevy/pull/815
+[820]: https://github.com/bevyengine/bevy/pull/820
+[821]: https://github.com/bevyengine/bevy/pull/821
+[821]: https://github.com/bevyengine/bevy/pull/821
+[829]: https://github.com/bevyengine/bevy/pull/829
+[829]: https://github.com/bevyengine/bevy/pull/829
+[834]: https://github.com/bevyengine/bevy/pull/834
+[834]: https://github.com/bevyengine/bevy/pull/834
+[836]: https://github.com/bevyengine/bevy/pull/836
+[836]: https://github.com/bevyengine/bevy/pull/836
+[842]: https://github.com/bevyengine/bevy/pull/842
+[843]: https://github.com/bevyengine/bevy/pull/843
+[847]: https://github.com/bevyengine/bevy/pull/847
+[852]: https://github.com/bevyengine/bevy/pull/852
+[852]: https://github.com/bevyengine/bevy/pull/852
+[857]: https://github.com/bevyengine/bevy/pull/857
+[857]: https://github.com/bevyengine/bevy/pull/857
+[859]: https://github.com/bevyengine/bevy/pull/859
+[859]: https://github.com/bevyengine/bevy/pull/859
+[863]: https://github.com/bevyengine/bevy/pull/863
+[864]: https://github.com/bevyengine/bevy/pull/864
+[871]: https://github.com/bevyengine/bevy/pull/871
+[876]: https://github.com/bevyengine/bevy/pull/876
+[876]: https://github.com/bevyengine/bevy/pull/876
+[883]: https://github.com/bevyengine/bevy/pull/883
+[887]: https://github.com/bevyengine/bevy/pull/887
+[892]: https://github.com/bevyengine/bevy/pull/892
+[893]: https://github.com/bevyengine/bevy/pull/893
+[893]: https://github.com/bevyengine/bevy/pull/893
+[893]: https://github.com/bevyengine/bevy/pull/893
+[894]: https://github.com/bevyengine/bevy/pull/894
+[894]: https://github.com/bevyengine/bevy/pull/894
+[894]: https://github.com/bevyengine/bevy/pull/894
+[895]: https://github.com/bevyengine/bevy/pull/895
+[895]: https://github.com/bevyengine/bevy/pull/895
+[897]: https://github.com/bevyengine/bevy/pull/897
+[903]: https://github.com/bevyengine/bevy/pull/903
+[904]: https://github.com/bevyengine/bevy/pull/904
+[904]: https://github.com/bevyengine/bevy/pull/904
+[905]: https://github.com/bevyengine/bevy/pull/905
+[905]: https://github.com/bevyengine/bevy/pull/905
+[908]: https://github.com/bevyengine/bevy/pull/908
+[914]: https://github.com/bevyengine/bevy/pull/914
+[914]: https://github.com/bevyengine/bevy/pull/914
+[917]: https://github.com/bevyengine/bevy/pull/917
+[917]: https://github.com/bevyengine/bevy/pull/917
+[920]: https://github.com/bevyengine/bevy/pull/920
+[920]: https://github.com/bevyengine/bevy/pull/920
+[926]: https://github.com/bevyengine/bevy/pull/926
+[926]: https://github.com/bevyengine/bevy/pull/926
+[928]: https://github.com/bevyengine/bevy/pull/928
+[928]: https://github.com/bevyengine/bevy/pull/928
+[931]: https://github.com/bevyengine/bevy/pull/931
+[931]: https://github.com/bevyengine/bevy/pull/931
+[932]: https://github.com/bevyengine/bevy/pull/932
+[934]: https://github.com/bevyengine/bevy/pull/934
+[934]: https://github.com/bevyengine/bevy/pull/934
+[937]: https://github.com/bevyengine/bevy/pull/937
+[940]: https://github.com/bevyengine/bevy/pull/940
+[945]: https://github.com/bevyengine/bevy/pull/945
+[945]: https://github.com/bevyengine/bevy/pull/945
+[946]: https://github.com/bevyengine/bevy/pull/946
+[947]: https://github.com/bevyengine/bevy/pull/947
+[948]: https://github.com/bevyengine/bevy/pull/948
+[952]: https://github.com/bevyengine/bevy/pull/952
+[955]: https://github.com/bevyengine/bevy/pull/955
+[955]: https://github.com/bevyengine/bevy/pull/955
+[955]: https://github.com/bevyengine/bevy/pull/955
+[956]: https://github.com/bevyengine/bevy/pull/956
+[958]: https://github.com/bevyengine/bevy/pull/958
+[966]: https://github.com/bevyengine/bevy/pull/966
+[969]: https://github.com/bevyengine/bevy/pull/969
+[972]: https://github.com/bevyengine/bevy/pull/972
+[973]: https://github.com/bevyengine/bevy/pull/973
+[979]: https://github.com/bevyengine/bevy/pull/979
+[987]: https://github.com/bevyengine/bevy/pull/987
+[995]: https://github.com/bevyengine/bevy/pull/995
+[997]: https://github.com/bevyengine/bevy/pull/997
+[1004]: https://github.com/bevyengine/bevy/pull/1004
+[1016]: https://github.com/bevyengine/bevy/pull/1016
+[1021]: https://github.com/bevyengine/bevy/pull/1021
+[1023]: https://github.com/bevyengine/bevy/pull/1023
+[1026]: https://github.com/bevyengine/bevy/pull/1026
+[1027]: https://github.com/bevyengine/bevy/pull/1027
+[1033]: https://github.com/bevyengine/bevy/pull/1033
+[1034]: https://github.com/bevyengine/bevy/pull/1034
+[1034]: https://github.com/bevyengine/bevy/pull/1034
+[1035]: https://github.com/bevyengine/bevy/pull/1035
+[1037]: https://github.com/bevyengine/bevy/pull/1037
+[1038]: https://github.com/bevyengine/bevy/pull/1038
+[1043]: https://github.com/bevyengine/bevy/pull/1043
+[1043]: https://github.com/bevyengine/bevy/pull/1043
+[1071]: https://github.com/bevyengine/bevy/pull/1071
 
 ## Version 0.3.0 (2020-11-03)
 
diff --git a/Cargo.toml b/Cargo.toml
index 0e43e7daba87a..207cd12341165 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy"
-version = "0.3.0"
+version = "0.4.0"
 edition = "2018"
 authors = [
   "Bevy Contributors <bevyengine@gmail.com>",
@@ -55,6 +55,9 @@ wgpu_trace = ["bevy_internal/wgpu_trace"]
 # Image format support for texture loading (PNG and HDR are enabled by default)
 hdr = ["bevy_internal/hdr"]
 png = ["bevy_internal/png"]
+dds = ["bevy_internal/dds"]
+tga = ["bevy_internal/tga"]
+jpeg = ["bevy_internal/jpeg"]
 
 # Audio format support (MP3 is enabled by default)
 flac = ["bevy_internal/flac"]
@@ -69,13 +72,13 @@ wayland = ["bevy_internal/wayland"]
 x11 = ["bevy_internal/x11"]
 
 [dependencies]
-bevy_dylib = {path = "crates/bevy_dylib", version = "0.3.0", default-features = false, optional = true}
-bevy_internal = {path = "crates/bevy_internal", version = "0.3.0", default-features = false}
+bevy_dylib = {path = "crates/bevy_dylib", version = "0.4.0", default-features = false, optional = true}
+bevy_internal = {path = "crates/bevy_internal", version = "0.4.0", default-features = false}
 
 [dev-dependencies]
 anyhow = "1.0"
 rand = "0.7.3"
-ron = "0.6"
+ron = "0.6.2"
 serde = {version = "1", features = ["derive"]}
 
 [[example]]
@@ -174,6 +177,10 @@ path = "examples/asset/asset_loading.rs"
 name = "custom_asset"
 path = "examples/asset/custom_asset.rs"
 
+[[example]]
+name = "custom_asset_io"
+path = "examples/asset/custom_asset_io.rs"
+
 [[example]]
 name = "audio"
 path = "examples/audio/audio.rs"
@@ -190,14 +197,26 @@ path = "examples/diagnostics/print_diagnostics.rs"
 name = "event"
 path = "examples/ecs/event.rs"
 
+[[example]]
+name = "fixed_timestep"
+path = "examples/ecs/fixed_timestep.rs"
+
 [[example]]
 name = "startup_system"
 path = "examples/ecs/startup_system.rs"
 
+[[example]]
+name = "state"
+path = "examples/ecs/state.rs"
+
 [[example]]
 name = "system_chaining"
 path = "examples/ecs/system_chaining.rs"
 
+[[example]]
+name = "timers"
+path = "examples/ecs/timers.rs"
+
 [[example]]
 name = "ecs_guide"
 path = "examples/ecs/ecs_guide.rs"
@@ -250,13 +269,29 @@ path = "examples/input/touch_input.rs"
 name = "touch_input_events"
 path = "examples/input/touch_input_events.rs"
 
+[[example]]
+name = "reflection"
+path = "examples/reflection/reflection.rs"
+
+[[example]]
+name = "reflection_types"
+path = "examples/reflection/reflection_types.rs"
+
+[[example]]
+name = "generic_reflection"
+path = "examples/reflection/generic_reflection.rs"
+
+[[example]]
+name = "trait_reflection"
+path = "examples/reflection/trait_reflection.rs"
+
 [[example]]
 name = "scene"
 path = "examples/scene/scene.rs"
 
 [[example]]
-name = "properties"
-path = "examples/scene/properties.rs"
+name = "hot_shader_reloading"
+path = "examples/shader/hot_shader_reloading.rs"
 
 [[example]]
 name = "mesh_custom_attribute"
@@ -266,6 +301,10 @@ path = "examples/shader/mesh_custom_attribute.rs"
 name = "shader_custom_material"
 path = "examples/shader/shader_custom_material.rs"
 
+[[example]]
+name = "array_texture"
+path = "examples/shader/array_texture.rs"
+
 [[example]]
 name = "shader_defs"
 path = "examples/shader/shader_defs.rs"
@@ -306,6 +345,10 @@ path = "examples/window/multiple_windows.rs"
 name = "window_settings"
 path = "examples/window/window_settings.rs"
 
+[[example]]
+name = "removal_detection"
+path = "examples/ecs/removal_detection.rs"
+
 [[example]]
 name = "hello_wasm"
 path = "examples/wasm/hello_wasm.rs"
diff --git a/assets/scenes/load_scene_example.scn b/assets/scenes/load_scene_example.scn
index a68262197272b..5b3672715b2f4 100644
--- a/assets/scenes/load_scene_example.scn
+++ b/assets/scenes/load_scene_example.scn
@@ -3,16 +3,42 @@
     entity: 0,
     components: [
       {
-        "type": "ComponentB",
-        "map": {
-          "value": "hello",
+        "type": "bevy_transform::components::transform::Transform",
+        "struct": {
+          "translation": {
+            "type": "glam::f32::vec3::Vec3",
+            "value": (0.0, 0.0, 0.0),
+          },
+          "rotation": {
+            "type": "glam::f32::quat::Quat",
+            "value": (0.0, 0.0, 0.0, 1.0),
+          },
+          "scale": {
+            "type": "glam::f32::vec3::Vec3",
+            "value": (1.0, 1.0, 1.0),
+          },
         },
       },
       {
-        "type": "ComponentA",
-        "map": {
-          "x": 1.0,
-          "y": 2.0,
+        "type": "scene::ComponentB",
+        "struct": {
+          "value": {
+            "type": "alloc::string::String",
+            "value": "hello",
+          },
+        },
+      },
+      {
+        "type": "scene::ComponentA",
+        "struct": {
+          "x": {
+            "type": "f32",
+            "value": 1.0,
+          },
+          "y": {
+            "type": "f32",
+            "value": 2.0,
+          },
         },
       },
     ],
@@ -21,10 +47,16 @@
     entity: 1,
     components: [
       {
-        "type": "ComponentA",
-        "map": {
-          "x": 3.0,
-          "y": 4.0,
+        "type": "scene::ComponentA",
+        "struct": {
+          "x": {
+            "type": "f32",
+            "value": 3.0,
+          },
+          "y": {
+            "type": "f32",
+            "value": 4.0,
+          },
         },
       },
     ],
diff --git a/assets/shaders/hot.frag b/assets/shaders/hot.frag
new file mode 100644
index 0000000000000..18c41c8cd5c04
--- /dev/null
+++ b/assets/shaders/hot.frag
@@ -0,0 +1,11 @@
+#version 450
+
+layout(location = 0) out vec4 o_Target;
+
+layout(set = 2, binding = 0) uniform MyMaterial_color {
+    vec4 color;
+};
+
+void main() {
+    o_Target = color * 0.5;
+}
diff --git a/assets/shaders/hot.vert b/assets/shaders/hot.vert
new file mode 100644
index 0000000000000..71a610e6e8463
--- /dev/null
+++ b/assets/shaders/hot.vert
@@ -0,0 +1,15 @@
+#version 450
+
+layout(location = 0) in vec3 Vertex_Position;
+
+layout(set = 0, binding = 0) uniform Camera {
+    mat4 ViewProj;
+};
+
+layout(set = 1, binding = 0) uniform Transform {
+    mat4 Model;
+};
+
+void main() {
+    gl_Position = ViewProj * Model * vec4(Vertex_Position, 1.0);
+}
diff --git a/assets/textures/array_texture.png b/assets/textures/array_texture.png
new file mode 100644
index 0000000000000..ab2c144e11247
Binary files /dev/null and b/assets/textures/array_texture.png differ
diff --git a/crates/bevy_app/Cargo.toml b/crates/bevy_app/Cargo.toml
index 47f4baf18144d..52a5b3030c1f0 100644
--- a/crates/bevy_app/Cargo.toml
+++ b/crates/bevy_app/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_app"
-version = "0.3.0"
+version = "0.4.0"
 edition = "2018"
 authors = [
     "Bevy Contributors <bevyengine@gmail.com>",
@@ -17,9 +17,9 @@ trace = []
 
 [dependencies]
 # bevy
-bevy_derive = { path = "../bevy_derive", version = "0.3.0" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.3.0" }
-bevy_utils = { path = "../bevy_utils", version = "0.3.0" }
+bevy_derive = { path = "../bevy_derive", version = "0.4.0" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.4.0" }
+bevy_utils = { path = "../bevy_utils", version = "0.4.0" }
 
 # other
 serde = { version = "1.0", features = ["derive"] }
diff --git a/crates/bevy_app/src/app.rs b/crates/bevy_app/src/app.rs
index 61d447fd286f2..adf2091ef2932 100644
--- a/crates/bevy_app/src/app.rs
+++ b/crates/bevy_app/src/app.rs
@@ -1,5 +1,5 @@
 use crate::app_builder::AppBuilder;
-use bevy_ecs::{ParallelExecutor, Resources, Schedule, World};
+use bevy_ecs::{Resources, Schedule, World};
 #[cfg(feature = "trace")]
 use bevy_utils::tracing::info_span;
 
@@ -30,9 +30,6 @@ pub struct App {
     pub resources: Resources,
     pub runner: Box<dyn Fn(App)>,
     pub schedule: Schedule,
-    pub executor: ParallelExecutor,
-    pub startup_schedule: Schedule,
-    pub startup_executor: ParallelExecutor,
 }
 
 impl Default for App {
@@ -41,16 +38,12 @@ impl Default for App {
             world: Default::default(),
             resources: Default::default(),
             schedule: Default::default(),
-            executor: Default::default(),
-            startup_schedule: Default::default(),
-            startup_executor: ParallelExecutor::without_tracker_clears(),
             runner: Box::new(run_once),
         }
     }
 }
 
 fn run_once(mut app: App) {
-    app.initialize();
     app.update();
 }
 
@@ -61,34 +54,15 @@ impl App {
 
     pub fn update(&mut self) {
         self.schedule
-            .initialize(&mut self.world, &mut self.resources);
-        self.executor
-            .run(&mut self.schedule, &mut self.world, &mut self.resources);
-    }
-
-    pub fn initialize(&mut self) {
-        #[cfg(feature = "trace")]
-        let startup_schedule_span = info_span!("startup_schedule");
-        #[cfg(feature = "trace")]
-        let _startup_schedule_guard = startup_schedule_span.enter();
-        self.startup_schedule
-            .initialize(&mut self.world, &mut self.resources);
-        self.startup_executor.initialize(&mut self.resources);
-        self.startup_executor.run(
-            &mut self.startup_schedule,
-            &mut self.world,
-            &mut self.resources,
-        );
+            .initialize_and_run(&mut self.world, &mut self.resources);
     }
 
     pub fn run(mut self) {
         #[cfg(feature = "trace")]
-        let bevy_app_run_span = info_span!("bevy_app_run");
+        let bevy_app_run_span = info_span!("bevy_app");
         #[cfg(feature = "trace")]
         let _bevy_app_run_guard = bevy_app_run_span.enter();
 
-        self.executor.initialize(&mut self.resources);
-
         let runner = std::mem::replace(&mut self.runner, Box::new(run_once));
         (runner)(self);
     }
diff --git a/crates/bevy_app/src/app_builder.rs b/crates/bevy_app/src/app_builder.rs
index 68e0063da74c7..fb69222b9b5ef 100644
--- a/crates/bevy_app/src/app_builder.rs
+++ b/crates/bevy_app/src/app_builder.rs
@@ -4,7 +4,10 @@ use crate::{
     plugin::Plugin,
     stage, startup_stage, PluginGroup, PluginGroupBuilder,
 };
-use bevy_ecs::{FromResources, IntoSystem, Resources, System, World};
+use bevy_ecs::{
+    clear_trackers_system, FromResources, IntoSystem, Resource, Resources, RunOnce, Schedule,
+    Stage, StateStage, System, SystemStage, World,
+};
 use bevy_utils::tracing::debug;
 
 /// Configure [App]s using the builder pattern
@@ -18,8 +21,10 @@ impl Default for AppBuilder {
             app: App::default(),
         };
 
-        app_builder.add_default_stages();
-        app_builder.add_event::<AppExit>();
+        app_builder
+            .add_default_stages()
+            .add_event::<AppExit>()
+            .add_system_to_stage(stage::LAST, clear_trackers_system.system());
         app_builder
     }
 }
@@ -49,124 +54,155 @@ impl AppBuilder {
         self
     }
 
-    pub fn add_stage(&mut self, stage_name: &'static str) -> &mut Self {
-        self.app.schedule.add_stage(stage_name);
+    pub fn add_stage<S: Stage>(&mut self, name: &'static str, stage: S) -> &mut Self {
+        self.app.schedule.add_stage(name, stage);
         self
     }
 
-    pub fn add_stage_after(&mut self, target: &'static str, stage_name: &'static str) -> &mut Self {
-        self.app.schedule.add_stage_after(target, stage_name);
+    pub fn add_stage_after<S: Stage>(
+        &mut self,
+        target: &'static str,
+        name: &'static str,
+        stage: S,
+    ) -> &mut Self {
+        self.app.schedule.add_stage_after(target, name, stage);
         self
     }
 
-    pub fn add_stage_before(
+    pub fn add_stage_before<S: Stage>(
         &mut self,
         target: &'static str,
-        stage_name: &'static str,
+        name: &'static str,
+        stage: S,
     ) -> &mut Self {
-        self.app.schedule.add_stage_before(target, stage_name);
+        self.app.schedule.add_stage_before(target, name, stage);
         self
     }
 
-    pub fn add_startup_stage(&mut self, stage_name: &'static str) -> &mut Self {
-        self.app.startup_schedule.add_stage(stage_name);
+    pub fn add_startup_stage<S: Stage>(&mut self, name: &'static str, stage: S) -> &mut Self {
+        self.app
+            .schedule
+            .stage(stage::STARTUP, |schedule: &mut Schedule| {
+                schedule.add_stage(name, stage)
+            });
         self
     }
 
-    pub fn add_startup_stage_after(
+    pub fn add_startup_stage_after<S: Stage>(
         &mut self,
         target: &'static str,
-        stage_name: &'static str,
+        name: &'static str,
+        stage: S,
     ) -> &mut Self {
         self.app
-            .startup_schedule
-            .add_stage_after(target, stage_name);
+            .schedule
+            .stage(stage::STARTUP, |schedule: &mut Schedule| {
+                schedule.add_stage_after(target, name, stage)
+            });
         self
     }
 
-    pub fn add_startup_stage_before(
+    pub fn add_startup_stage_before<S: Stage>(
         &mut self,
         target: &'static str,
-        stage_name: &'static str,
+        name: &'static str,
+        stage: S,
     ) -> &mut Self {
         self.app
-            .startup_schedule
-            .add_stage_before(target, stage_name);
+            .schedule
+            .stage(stage::STARTUP, |schedule: &mut Schedule| {
+                schedule.add_stage_before(target, name, stage)
+            });
         self
     }
 
-    pub fn add_system<S, Params, IntoS>(&mut self, system: IntoS) -> &mut Self
-    where
-        S: System<Input = (), Output = ()>,
-        IntoS: IntoSystem<Params, S>,
-    {
+    pub fn stage<T: Stage, F: FnOnce(&mut T) -> &mut T>(
+        &mut self,
+        name: &str,
+        func: F,
+    ) -> &mut Self {
+        self.app.schedule.stage(name, func);
+        self
+    }
+
+    pub fn add_system<S: System<In = (), Out = ()>>(&mut self, system: S) -> &mut Self {
         self.add_system_to_stage(stage::UPDATE, system)
     }
 
-    pub fn add_startup_system_to_stage<S, Params, IntoS>(
+    pub fn on_state_enter<T: Clone + Resource, S: System<In = (), Out = ()>>(
+        &mut self,
+        stage: &str,
+        state: T,
+        system: S,
+    ) -> &mut Self {
+        self.stage(stage, |stage: &mut StateStage<T>| {
+            stage.on_state_enter(state, system)
+        })
+    }
+
+    pub fn on_state_update<T: Clone + Resource, S: System<In = (), Out = ()>>(
+        &mut self,
+        stage: &str,
+        state: T,
+        system: S,
+    ) -> &mut Self {
+        self.stage(stage, |stage: &mut StateStage<T>| {
+            stage.on_state_update(state, system)
+        })
+    }
+
+    pub fn on_state_exit<T: Clone + Resource, S: System<In = (), Out = ()>>(
+        &mut self,
+        stage: &str,
+        state: T,
+        system: S,
+    ) -> &mut Self {
+        self.stage(stage, |stage: &mut StateStage<T>| {
+            stage.on_state_exit(state, system)
+        })
+    }
+
+    pub fn add_startup_system_to_stage<S: System<In = (), Out = ()>>(
         &mut self,
         stage_name: &'static str,
-        system: IntoS,
-    ) -> &mut Self
-    where
-        S: System<Input = (), Output = ()>,
-        IntoS: IntoSystem<Params, S>,
-    {
+        system: S,
+    ) -> &mut Self {
         self.app
-            .startup_schedule
-            .add_system_to_stage(stage_name, system);
+            .schedule
+            .stage(stage::STARTUP, |schedule: &mut Schedule| {
+                schedule.add_system_to_stage(stage_name, system)
+            });
         self
     }
 
-    pub fn add_startup_system<S, Params, IntoS>(&mut self, system: IntoS) -> &mut Self
-    where
-        S: System<Input = (), Output = ()>,
-        IntoS: IntoSystem<Params, S>,
-    {
-        self.app
-            .startup_schedule
-            .add_system_to_stage(startup_stage::STARTUP, system);
-        self
+    pub fn add_startup_system<S: System<In = (), Out = ()>>(&mut self, system: S) -> &mut Self {
+        self.add_startup_system_to_stage(startup_stage::STARTUP, system)
     }
 
     pub fn add_default_stages(&mut self) -> &mut Self {
-        self.add_startup_stage(startup_stage::PRE_STARTUP)
-            .add_startup_stage(startup_stage::STARTUP)
-            .add_startup_stage(startup_stage::POST_STARTUP)
-            .add_stage(stage::FIRST)
-            .add_stage(stage::PRE_EVENT)
-            .add_stage(stage::EVENT)
-            .add_stage(stage::PRE_UPDATE)
-            .add_stage(stage::UPDATE)
-            .add_stage(stage::POST_UPDATE)
-            .add_stage(stage::LAST)
-    }
-
-    pub fn add_system_to_stage<S, Params, IntoS>(
-        &mut self,
-        stage_name: &'static str,
-        system: IntoS,
-    ) -> &mut Self
-    where
-        S: System<Input = (), Output = ()>,
-        IntoS: IntoSystem<Params, S>,
-    {
-        self.app.schedule.add_system_to_stage(stage_name, system);
-        self
+        self.add_stage(
+            stage::STARTUP,
+            Schedule::default()
+                .with_run_criteria(RunOnce::default())
+                .with_stage(startup_stage::PRE_STARTUP, SystemStage::parallel())
+                .with_stage(startup_stage::STARTUP, SystemStage::parallel())
+                .with_stage(startup_stage::POST_STARTUP, SystemStage::parallel()),
+        )
+        .add_stage(stage::FIRST, SystemStage::parallel())
+        .add_stage(stage::PRE_EVENT, SystemStage::parallel())
+        .add_stage(stage::EVENT, SystemStage::parallel())
+        .add_stage(stage::PRE_UPDATE, SystemStage::parallel())
+        .add_stage(stage::UPDATE, SystemStage::parallel())
+        .add_stage(stage::POST_UPDATE, SystemStage::parallel())
+        .add_stage(stage::LAST, SystemStage::parallel())
     }
 
-    pub fn add_system_to_stage_front<S, Params, IntoS>(
+    pub fn add_system_to_stage<S: System<In = (), Out = ()>>(
         &mut self,
         stage_name: &'static str,
-        system: IntoS,
-    ) -> &mut Self
-    where
-        S: System<Input = (), Output = ()>,
-        IntoS: IntoSystem<Params, S>,
-    {
-        self.app
-            .schedule
-            .add_system_to_stage_front(stage_name, system.system());
+        system: S,
+    ) -> &mut Self {
+        self.app.schedule.add_system_to_stage(stage_name, system);
         self
     }
 
@@ -175,7 +211,7 @@ impl AppBuilder {
         T: Send + Sync + 'static,
     {
         self.add_resource(Events::<T>::default())
-            .add_system_to_stage(stage::EVENT, Events::<T>::update_system)
+            .add_system_to_stage(stage::EVENT, Events::<T>::update_system.system())
     }
 
     /// Adds a resource to the current [App] and overwrites any resource previously added of the same type.
diff --git a/crates/bevy_app/src/plugin_group.rs b/crates/bevy_app/src/plugin_group.rs
index 3fadf24c40fe3..074a2d3083cd2 100644
--- a/crates/bevy_app/src/plugin_group.rs
+++ b/crates/bevy_app/src/plugin_group.rs
@@ -38,7 +38,10 @@ impl PluginGroupBuilder {
             .find(|(_i, ty)| **ty == TypeId::of::<Target>())
             .map(|(i, _)| i)
             .unwrap_or_else(|| {
-                panic!("Plugin does not exist: {}", std::any::type_name::<Target>())
+                panic!(
+                    "Plugin does not exist: {}.",
+                    std::any::type_name::<Target>()
+                )
             });
         self.order.insert(target_index, TypeId::of::<T>());
         self.plugins.insert(
@@ -59,7 +62,10 @@ impl PluginGroupBuilder {
             .find(|(_i, ty)| **ty == TypeId::of::<Target>())
             .map(|(i, _)| i)
             .unwrap_or_else(|| {
-                panic!("Plugin does not exist: {}", std::any::type_name::<Target>())
+                panic!(
+                    "Plugin does not exist: {}.",
+                    std::any::type_name::<Target>()
+                )
             });
         self.order.insert(target_index + 1, TypeId::of::<T>());
         self.plugins.insert(
@@ -76,7 +82,7 @@ impl PluginGroupBuilder {
         let mut plugin_entry = self
             .plugins
             .get_mut(&TypeId::of::<T>())
-            .expect("Cannot enable a plugin that does not exist");
+            .expect("Cannot enable a plugin that does not exist.");
         plugin_entry.enabled = true;
         self
     }
@@ -85,7 +91,7 @@ impl PluginGroupBuilder {
         let mut plugin_entry = self
             .plugins
             .get_mut(&TypeId::of::<T>())
-            .expect("Cannot disable a plugin that does not exist");
+            .expect("Cannot disable a plugin that does not exist.");
         plugin_entry.enabled = false;
         self
     }
diff --git a/crates/bevy_app/src/schedule_runner.rs b/crates/bevy_app/src/schedule_runner.rs
index 3faeabf974383..c533720406001 100644
--- a/crates/bevy_app/src/schedule_runner.rs
+++ b/crates/bevy_app/src/schedule_runner.rs
@@ -56,8 +56,6 @@ impl Plugin for ScheduleRunnerPlugin {
             .get_or_insert_with(ScheduleRunnerSettings::default)
             .to_owned();
         app.set_runner(move |mut app: App| {
-            app.initialize();
-
             let mut app_exit_event_reader = EventReader::<AppExit>::default();
             match settings.run_mode {
                 RunMode::Once => {
@@ -113,7 +111,7 @@ impl Plugin for ScheduleRunnerPlugin {
                                     f.as_ref().unchecked_ref(),
                                     dur.as_millis() as i32,
                                 )
-                                .expect("should register `setTimeout`");
+                                .expect("Should register `setTimeout`.");
                         }
                         let asap = Duration::from_millis(1);
 
diff --git a/crates/bevy_app/src/stage.rs b/crates/bevy_app/src/stage.rs
index 1e4fa590528b7..fb8eb416307ee 100644
--- a/crates/bevy_app/src/stage.rs
+++ b/crates/bevy_app/src/stage.rs
@@ -1,11 +1,14 @@
+/// Name of the app stage that runs once at the beginning of the app
+pub const STARTUP: &str = "startup";
+
 /// Name of app stage that runs before all other app stages
 pub const FIRST: &str = "first";
 
 /// Name of app stage that runs before EVENT
-pub const PRE_EVENT: &str = "pre_events";
+pub const PRE_EVENT: &str = "pre_event";
 
 /// Name of app stage that updates events. Runs before UPDATE
-pub const EVENT: &str = "events";
+pub const EVENT: &str = "event";
 
 /// Name of app stage responsible for performing setup before an update. Runs before UPDATE.
 pub const PRE_UPDATE: &str = "pre_update";
diff --git a/crates/bevy_asset/Cargo.toml b/crates/bevy_asset/Cargo.toml
index d0ef595e9434d..e5644853e567b 100644
--- a/crates/bevy_asset/Cargo.toml
+++ b/crates/bevy_asset/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_asset"
-version = "0.3.0"
+version = "0.4.0"
 edition = "2018"
 authors = [
     "Bevy Contributors <bevyengine@gmail.com>",
@@ -18,15 +18,13 @@ filesystem_watcher = ["notify"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.3.0" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.3.0" }
-bevy_tasks = { path = "../bevy_tasks", version = "0.3.0" }
-bevy_type_registry = { path = "../bevy_type_registry", version = "0.3.0" }
-bevy_property = { path = "../bevy_property", version = "0.3.0" }
-bevy_utils = { path = "../bevy_utils", version = "0.3.0" }
+bevy_app = { path = "../bevy_app", version = "0.4.0" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.4.0" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.4.0", features = ["bevy"] }
+bevy_tasks = { path = "../bevy_tasks", version = "0.4.0" }
+bevy_utils = { path = "../bevy_utils", version = "0.4.0" }
 
 # other
-uuid = { version = "0.8", features = ["v4", "serde"] }
 serde = { version = "1", features = ["derive"] }
 ron = "0.6.2"
 crossbeam-channel = "0.4.4"
diff --git a/crates/bevy_asset/src/asset_server.rs b/crates/bevy_asset/src/asset_server.rs
index e40ca0b88a984..fafff56008346 100644
--- a/crates/bevy_asset/src/asset_server.rs
+++ b/crates/bevy_asset/src/asset_server.rs
@@ -7,25 +7,24 @@ use crate::{
 use anyhow::Result;
 use bevy_ecs::Res;
 use bevy_tasks::TaskPool;
-use bevy_utils::HashMap;
+use bevy_utils::{HashMap, Uuid};
 use crossbeam_channel::TryRecvError;
 use parking_lot::RwLock;
 use std::{collections::hash_map::Entry, path::Path, sync::Arc};
 use thiserror::Error;
-use uuid::Uuid;
 
 /// Errors that occur while loading assets with an AssetServer
 #[derive(Error, Debug)]
 pub enum AssetServerError {
-    #[error("Asset folder path is not a directory.")]
+    #[error("asset folder path is not a directory")]
     AssetFolderNotADirectory(String),
-    #[error("No AssetLoader found for the given extension.")]
+    #[error("no AssetLoader found for the given extension")]
     MissingAssetLoader(Option<String>),
-    #[error("The given type does not match the type of the loaded asset.")]
+    #[error("the given type does not match the type of the loaded asset")]
     IncorrectHandleType,
-    #[error("Encountered an error while loading an asset.")]
+    #[error("encountered an error while loading an asset")]
     AssetLoaderError(anyhow::Error),
-    #[error("PathLoader encountered an error")]
+    #[error("`PathLoader` encountered an error")]
     PathLoaderError(#[from] AssetIoError),
 }
 
@@ -61,6 +60,10 @@ impl Clone for AssetServer {
 
 impl AssetServer {
     pub fn new<T: AssetIo>(source_io: T, task_pool: TaskPool) -> Self {
+        Self::with_boxed_io(Box::new(source_io), task_pool)
+    }
+
+    pub fn with_boxed_io(asset_io: Box<dyn AssetIo>, task_pool: TaskPool) -> Self {
         AssetServer {
             server: Arc::new(AssetServerInternal {
                 loaders: Default::default(),
@@ -70,7 +73,7 @@ impl AssetServer {
                 handle_to_path: Default::default(),
                 asset_lifecycles: Default::default(),
                 task_pool,
-                asset_io: Box::new(source_io),
+                asset_io,
             }),
         }
     }
@@ -239,7 +242,7 @@ impl AssetServer {
         let mut asset_sources = self.server.asset_sources.write();
         let source_info = asset_sources
             .get_mut(&asset_path_id.source_path_id())
-            .expect("AssetSource should exist at this point");
+            .expect("`AssetSource` should exist at this point.");
         if version != source_info.version {
             return Ok(asset_path_id);
         }
@@ -318,7 +321,7 @@ impl AssetServer {
                     continue;
                 }
                 let handle =
-                    self.load_untyped(child_path.to_str().expect("Path should be a valid string"));
+                    self.load_untyped(child_path.to_str().expect("Path should be a valid string."));
                 handles.push(handle);
             }
         }
@@ -335,7 +338,7 @@ impl AssetServer {
             let ref_change = match receiver.try_recv() {
                 Ok(ref_change) => ref_change,
                 Err(TryRecvError::Empty) => break,
-                Err(TryRecvError::Disconnected) => panic!("RefChange channel disconnected"),
+                Err(TryRecvError::Disconnected) => panic!("RefChange channel disconnected."),
             };
             match ref_change {
                 RefChange::Increment(handle_id) => *ref_counts.entry(handle_id).or_insert(0) += 1,
@@ -378,7 +381,7 @@ impl AssetServer {
             let asset_value = asset
                 .value
                 .take()
-                .expect("Asset should exist at this point");
+                .expect("Asset should exist at this point.");
             if let Some(asset_lifecycle) = asset_lifecycles.get(&asset_value.type_uuid()) {
                 let asset_path =
                     AssetPath::new_ref(&load_context.path, label.as_ref().map(|l| l.as_str()));
@@ -392,7 +395,7 @@ impl AssetServer {
     pub(crate) fn update_asset_storage<T: Asset>(&self, assets: &mut Assets<T>) {
         let asset_lifecycles = self.server.asset_lifecycles.read();
         let asset_lifecycle = asset_lifecycles.get(&T::TYPE_UUID).unwrap();
-        let mut asset_sources = self.server.asset_sources.write();
+        let mut asset_sources_guard = None;
         let channel = asset_lifecycle
             .downcast_ref::<AssetLifecycleChannel<T>>()
             .unwrap();
@@ -402,6 +405,8 @@ impl AssetServer {
                 Ok(AssetLifecycleEvent::Create(result)) => {
                     // update SourceInfo if this asset was loaded from an AssetPath
                     if let HandleId::AssetPathId(id) = result.id {
+                        let asset_sources = asset_sources_guard
+                            .get_or_insert_with(|| self.server.asset_sources.write());
                         if let Some(source_info) = asset_sources.get_mut(&id.source_path_id()) {
                             if source_info.version == result.version {
                                 source_info.committed_assets.insert(id.label_id());
@@ -416,6 +421,8 @@ impl AssetServer {
                 }
                 Ok(AssetLifecycleEvent::Free(handle_id)) => {
                     if let HandleId::AssetPathId(id) = handle_id {
+                        let asset_sources = asset_sources_guard
+                            .get_or_insert_with(|| self.server.asset_sources.write());
                         if let Some(source_info) = asset_sources.get_mut(&id.source_path_id()) {
                             source_info.committed_assets.remove(&id.label_id());
                             if source_info.is_loaded() {
@@ -428,7 +435,7 @@ impl AssetServer {
                 Err(TryRecvError::Empty) => {
                     break;
                 }
-                Err(TryRecvError::Disconnected) => panic!("AssetChannel disconnected"),
+                Err(TryRecvError::Disconnected) => panic!("AssetChannel disconnected."),
             }
         }
     }
diff --git a/crates/bevy_asset/src/assets.rs b/crates/bevy_asset/src/assets.rs
index e3fd86c20a478..1ae9ab5f48cae 100644
--- a/crates/bevy_asset/src/assets.rs
+++ b/crates/bevy_asset/src/assets.rs
@@ -2,8 +2,8 @@ use crate::{
     update_asset_storage_system, Asset, AssetLoader, AssetServer, Handle, HandleId, RefChange,
 };
 use bevy_app::{prelude::Events, AppBuilder};
-use bevy_ecs::{FromResources, ResMut};
-use bevy_type_registry::RegisterType;
+use bevy_ecs::{FromResources, IntoSystem, ResMut};
+use bevy_reflect::RegisterTypeBuilder;
 use bevy_utils::HashMap;
 use crossbeam_channel::Sender;
 use std::fmt::Debug;
@@ -218,9 +218,15 @@ impl AddAsset for AppBuilder {
         };
 
         self.add_resource(assets)
-            .register_component::<Handle<T>>()
-            .add_system_to_stage(super::stage::ASSET_EVENTS, Assets::<T>::asset_event_system)
-            .add_system_to_stage(crate::stage::LOAD_ASSETS, update_asset_storage_system::<T>)
+            .add_system_to_stage(
+                super::stage::ASSET_EVENTS,
+                Assets::<T>::asset_event_system.system(),
+            )
+            .add_system_to_stage(
+                crate::stage::LOAD_ASSETS,
+                update_asset_storage_system::<T>.system(),
+            )
+            .register_type::<Handle<T>>()
             .add_event::<AssetEvent<T>>()
     }
 
diff --git a/crates/bevy_asset/src/filesystem_watcher.rs b/crates/bevy_asset/src/filesystem_watcher.rs
index 2b05cf85e31d7..00a3487e593f7 100644
--- a/crates/bevy_asset/src/filesystem_watcher.rs
+++ b/crates/bevy_asset/src/filesystem_watcher.rs
@@ -12,9 +12,9 @@ impl Default for FilesystemWatcher {
     fn default() -> Self {
         let (sender, receiver) = crossbeam_channel::unbounded();
         let watcher: RecommendedWatcher = Watcher::new_immediate(move |res| {
-            sender.send(res).expect("Watch event send failure");
+            sender.send(res).expect("Watch event send failure.");
         })
-        .expect("Failed to create filesystem watcher");
+        .expect("Failed to create filesystem watcher.");
         FilesystemWatcher { watcher, receiver }
     }
 }
diff --git a/crates/bevy_asset/src/handle.rs b/crates/bevy_asset/src/handle.rs
index f028309197d37..ad39e3438a69b 100644
--- a/crates/bevy_asset/src/handle.rs
+++ b/crates/bevy_asset/src/handle.rs
@@ -5,20 +5,20 @@ use std::{
     marker::PhantomData,
 };
 
-use bevy_property::{Properties, Property};
-use crossbeam_channel::{Receiver, Sender};
-use serde::{Deserialize, Serialize};
-use uuid::Uuid;
-
 use crate::{
     path::{AssetPath, AssetPathId},
     Asset, Assets,
 };
+use bevy_reflect::{Reflect, ReflectComponent, ReflectDeserialize};
+use bevy_utils::Uuid;
+use crossbeam_channel::{Receiver, Sender};
+use serde::{Deserialize, Serialize};
 
 /// A unique, stable asset id
 #[derive(
-    Debug, Clone, Copy, Eq, PartialEq, Hash, Ord, PartialOrd, Serialize, Deserialize, Property,
+    Debug, Clone, Copy, Eq, PartialEq, Hash, Ord, PartialOrd, Serialize, Deserialize, Reflect,
 )]
+#[reflect_value(Serialize, Deserialize, PartialEq, Hash)]
 pub enum HandleId {
     Id(Uuid, u64),
     AssetPathId(AssetPathId),
@@ -56,15 +56,16 @@ impl HandleId {
 /// A handle into a specific Asset of type `T`
 ///
 /// Handles contain a unique id that corresponds to a specific asset in the [Assets](crate::Assets) collection.
-#[derive(Properties)]
+#[derive(Reflect)]
+#[reflect(Component)]
 pub struct Handle<T>
 where
-    T: 'static,
+    T: Asset,
 {
     pub id: HandleId,
-    #[property(ignore)]
+    #[reflect(ignore)]
     handle_type: HandleType,
-    #[property(ignore)]
+    #[reflect(ignore)]
     marker: PhantomData<T>,
 }
 
@@ -82,17 +83,6 @@ impl Debug for HandleType {
     }
 }
 
-impl<T> Handle<T> {
-    // TODO: remove "uuid" parameter whenever rust support type constraints in const fns
-    pub const fn weak_from_u64(uuid: Uuid, id: u64) -> Self {
-        Self {
-            id: HandleId::new(uuid, id),
-            handle_type: HandleType::Weak,
-            marker: PhantomData,
-        }
-    }
-}
-
 impl<T: Asset> Handle<T> {
     pub(crate) fn strong(id: HandleId, ref_change_sender: Sender<RefChange>) -> Self {
         ref_change_sender.send(RefChange::Increment(id)).unwrap();
@@ -111,7 +101,7 @@ impl<T: Asset> Handle<T> {
         }
     }
 
-    pub fn as_weak<U>(&self) -> Handle<U> {
+    pub fn as_weak<U: Asset>(&self) -> Handle<U> {
         Handle {
             id: self.id,
             handle_type: HandleType::Weak,
@@ -152,7 +142,7 @@ impl<T: Asset> Handle<T> {
     }
 }
 
-impl<T> Drop for Handle<T> {
+impl<T: Asset> Drop for Handle<T> {
     fn drop(&mut self) {
         match self.handle_type {
             HandleType::Strong(ref sender) => {
@@ -164,45 +154,51 @@ impl<T> Drop for Handle<T> {
     }
 }
 
-impl<T> From<Handle<T>> for HandleId {
+impl<T: Asset> From<Handle<T>> for HandleId {
     fn from(value: Handle<T>) -> Self {
         value.id
     }
 }
 
+impl From<HandleUntyped> for HandleId {
+    fn from(value: HandleUntyped) -> Self {
+        value.id
+    }
+}
+
 impl From<&str> for HandleId {
     fn from(value: &str) -> Self {
         AssetPathId::from(value).into()
     }
 }
 
-impl<T> From<&Handle<T>> for HandleId {
+impl<T: Asset> From<&Handle<T>> for HandleId {
     fn from(value: &Handle<T>) -> Self {
         value.id
     }
 }
 
-impl<T> Hash for Handle<T> {
+impl<T: Asset> Hash for Handle<T> {
     fn hash<H: Hasher>(&self, state: &mut H) {
-        self.id.hash(state);
+        Hash::hash(&self.id, state);
     }
 }
 
-impl<T> PartialEq for Handle<T> {
+impl<T: Asset> PartialEq for Handle<T> {
     fn eq(&self, other: &Self) -> bool {
         self.id == other.id
     }
 }
 
-impl<T> Eq for Handle<T> {}
+impl<T: Asset> Eq for Handle<T> {}
 
-impl<T> PartialOrd for Handle<T> {
+impl<T: Asset> PartialOrd for Handle<T> {
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
         Some(self.id.cmp(&other.id))
     }
 }
 
-impl<T> Ord for Handle<T> {
+impl<T: Asset> Ord for Handle<T> {
     fn cmp(&self, other: &Self) -> Ordering {
         self.id.cmp(&other.id)
     }
@@ -214,7 +210,7 @@ impl<T: Asset> Default for Handle<T> {
     }
 }
 
-impl<T> Debug for Handle<T> {
+impl<T: Asset> Debug for Handle<T> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
         let name = std::any::type_name::<T>().split("::").last().unwrap();
         write!(f, "{:?}Handle<{}>({:?})", self.handle_type, name, self.id)
@@ -231,8 +227,8 @@ impl<T: Asset> Clone for Handle<T> {
 }
 
 // SAFE: T is phantom data and Handle::id is an integer
-unsafe impl<T> Send for Handle<T> {}
-unsafe impl<T> Sync for Handle<T> {}
+unsafe impl<T: Asset> Send for Handle<T> {}
+unsafe impl<T: Asset> Sync for Handle<T> {}
 
 /// A non-generic version of [Handle]
 ///
@@ -244,6 +240,13 @@ pub struct HandleUntyped {
 }
 
 impl HandleUntyped {
+    pub const fn weak_from_u64(uuid: Uuid, id: u64) -> Self {
+        Self {
+            id: HandleId::new(uuid, id),
+            handle_type: HandleType::Weak,
+        }
+    }
+
     pub(crate) fn strong(id: HandleId, ref_change_sender: Sender<RefChange>) -> Self {
         ref_change_sender.send(RefChange::Increment(id)).unwrap();
         Self {
@@ -274,7 +277,7 @@ impl HandleUntyped {
     pub fn typed<T: Asset>(mut self) -> Handle<T> {
         if let HandleId::Id(type_uuid, _) = self.id {
             if T::TYPE_UUID != type_uuid {
-                panic!("attempted to convert handle to invalid type");
+                panic!("Attempted to convert handle to invalid type.");
             }
         }
         let handle_type = match &self.handle_type {
@@ -311,7 +314,7 @@ impl From<&HandleUntyped> for HandleId {
 
 impl Hash for HandleUntyped {
     fn hash<H: Hasher>(&self, state: &mut H) {
-        self.id.hash(state);
+        Hash::hash(&self.id, state);
     }
 }
 
diff --git a/crates/bevy_asset/src/info.rs b/crates/bevy_asset/src/info.rs
index 506f09dbfe4f1..f781fa0eea66a 100644
--- a/crates/bevy_asset/src/info.rs
+++ b/crates/bevy_asset/src/info.rs
@@ -1,8 +1,7 @@
 use crate::{path::AssetPath, LabelId};
-use bevy_utils::{HashMap, HashSet};
+use bevy_utils::{HashMap, HashSet, Uuid};
 use serde::{Deserialize, Serialize};
 use std::path::PathBuf;
-use uuid::Uuid;
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct SourceMeta {
diff --git a/crates/bevy_asset/src/io/file_asset_io.rs b/crates/bevy_asset/src/io/file_asset_io.rs
index 5f2ede7ba988f..0a06d66888e2d 100644
--- a/crates/bevy_asset/src/io/file_asset_io.rs
+++ b/crates/bevy_asset/src/io/file_asset_io.rs
@@ -122,7 +122,7 @@ pub fn filesystem_watcher_system(asset_server: Res<AssetServer>) {
             let event = match watcher.receiver.try_recv() {
                 Ok(result) => result.unwrap(),
                 Err(TryRecvError::Empty) => break,
-                Err(TryRecvError::Disconnected) => panic!("FilesystemWatcher disconnected"),
+                Err(TryRecvError::Disconnected) => panic!("FilesystemWatcher disconnected."),
             };
             if let notify::event::Event {
                 kind: notify::event::EventKind::Modify(_),
diff --git a/crates/bevy_asset/src/io/mod.rs b/crates/bevy_asset/src/io/mod.rs
index 58ac8fa8febdb..927c315b39388 100644
--- a/crates/bevy_asset/src/io/mod.rs
+++ b/crates/bevy_asset/src/io/mod.rs
@@ -24,11 +24,11 @@ use thiserror::Error;
 /// Errors that occur while loading assets
 #[derive(Error, Debug)]
 pub enum AssetIoError {
-    #[error("Path not found")]
+    #[error("path not found")]
     NotFound(PathBuf),
-    #[error("Encountered an io error while loading asset.")]
+    #[error("encountered an io error while loading asset")]
     Io(#[from] io::Error),
-    #[error("Failed to watch path")]
+    #[error("failed to watch path")]
     PathWatchError(PathBuf),
 }
 
diff --git a/crates/bevy_asset/src/lib.rs b/crates/bevy_asset/src/lib.rs
index f97abe5e1826e..5c9b4133b9d81 100644
--- a/crates/bevy_asset/src/lib.rs
+++ b/crates/bevy_asset/src/lib.rs
@@ -13,6 +13,8 @@ mod path;
 
 pub use asset_server::*;
 pub use assets::*;
+use bevy_ecs::{IntoSystem, SystemStage};
+use bevy_reflect::RegisterTypeBuilder;
 use bevy_tasks::IoTaskPool;
 pub use handle::*;
 pub use info::*;
@@ -31,7 +33,6 @@ pub mod prelude {
 }
 
 use bevy_app::{prelude::Plugin, AppBuilder};
-use bevy_type_registry::RegisterType;
 
 /// Adds support for Assets to an App. Assets are typed collections with change tracking, which are added as App Resources.
 /// Examples of assets: textures, sounds, 3d models, maps, scenes
@@ -50,42 +51,62 @@ impl Default for AssetServerSettings {
     }
 }
 
+/// Create an instance of the platform default `AssetIo`
+///
+/// This is useful when providing a custom `AssetIo` instance that needs to
+/// 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);
+
+    #[cfg(all(not(target_arch = "wasm32"), not(target_os = "android")))]
+    let source = FileAssetIo::new(&settings.asset_folder);
+    #[cfg(target_arch = "wasm32")]
+    let source = WasmAssetIo::new(&settings.asset_folder);
+    #[cfg(target_os = "android")]
+    let source = AndroidAssetIo::new(&settings.asset_folder);
+
+    Box::new(source)
+}
+
 impl Plugin for AssetPlugin {
     fn build(&self, app: &mut AppBuilder) {
-        let task_pool = app
-            .resources()
-            .get::<IoTaskPool>()
-            .expect("IoTaskPool resource not found")
-            .0
-            .clone();
-
-        let asset_server = {
-            let settings = app
-                .resources_mut()
-                .get_or_insert_with(AssetServerSettings::default);
-
-            #[cfg(all(not(target_arch = "wasm32"), not(target_os = "android")))]
-            let source = FileAssetIo::new(&settings.asset_folder);
-            #[cfg(target_arch = "wasm32")]
-            let source = WasmAssetIo::new(&settings.asset_folder);
-            #[cfg(target_os = "android")]
-            let source = AndroidAssetIo::new(&settings.asset_folder);
-            AssetServer::new(source, task_pool)
-        };
-
-        app.add_stage_before(bevy_app::stage::PRE_UPDATE, stage::LOAD_ASSETS)
-            .add_stage_after(bevy_app::stage::POST_UPDATE, stage::ASSET_EVENTS)
-            .add_resource(asset_server)
-            .register_property::<HandleId>()
-            .add_system_to_stage(
-                bevy_app::stage::PRE_UPDATE,
-                asset_server::free_unused_assets_system,
-            );
+        if app.resources().get::<AssetServer>().is_none() {
+            let task_pool = app
+                .resources()
+                .get::<IoTaskPool>()
+                .expect("`IoTaskPool` resource not found.")
+                .0
+                .clone();
+
+            let source = create_platform_default_asset_io(app);
+
+            let asset_server = AssetServer::with_boxed_io(source, task_pool);
+
+            app.add_resource(asset_server);
+        }
+
+        app.add_stage_before(
+            bevy_app::stage::PRE_UPDATE,
+            stage::LOAD_ASSETS,
+            SystemStage::parallel(),
+        )
+        .add_stage_after(
+            bevy_app::stage::POST_UPDATE,
+            stage::ASSET_EVENTS,
+            SystemStage::parallel(),
+        )
+        .register_type::<HandleId>()
+        .add_system_to_stage(
+            bevy_app::stage::PRE_UPDATE,
+            asset_server::free_unused_assets_system.system(),
+        );
 
         #[cfg(all(
             feature = "filesystem_watcher",
             all(not(target_arch = "wasm32"), not(target_os = "android"))
         ))]
-        app.add_system_to_stage(stage::LOAD_ASSETS, io::filesystem_watcher_system);
+        app.add_system_to_stage(stage::LOAD_ASSETS, io::filesystem_watcher_system.system());
     }
 }
diff --git a/crates/bevy_asset/src/loader.rs b/crates/bevy_asset/src/loader.rs
index 903f5efca9ec5..bd87b177d5eff 100644
--- a/crates/bevy_asset/src/loader.rs
+++ b/crates/bevy_asset/src/loader.rs
@@ -4,7 +4,7 @@ use crate::{
 };
 use anyhow::Result;
 use bevy_ecs::{Res, ResMut, Resource};
-use bevy_type_registry::{TypeUuid, TypeUuidDynamic};
+use bevy_reflect::{TypeUuid, TypeUuidDynamic};
 use bevy_utils::{BoxedFuture, HashMap};
 use crossbeam_channel::{Receiver, Sender};
 use downcast_rs::{impl_downcast, Downcast};
@@ -152,7 +152,10 @@ impl<T: AssetDynamic> AssetLifecycle for AssetLifecycleChannel<T> {
                 }))
                 .unwrap()
         } else {
-            panic!("failed to downcast asset to {}", std::any::type_name::<T>());
+            panic!(
+                "Failed to downcast asset to {}.",
+                std::any::type_name::<T>()
+            );
         }
     }
 
diff --git a/crates/bevy_asset/src/path.rs b/crates/bevy_asset/src/path.rs
index 89abed1547a6d..22f4c2f79cfdf 100644
--- a/crates/bevy_asset/src/path.rs
+++ b/crates/bevy_asset/src/path.rs
@@ -1,4 +1,4 @@
-use bevy_property::Property;
+use bevy_reflect::{Reflect, ReflectDeserialize};
 use bevy_utils::AHasher;
 use serde::{Deserialize, Serialize};
 use std::{
@@ -58,18 +58,21 @@ impl<'a> AssetPath<'a> {
 }
 
 #[derive(
-    Debug, Clone, Copy, Eq, PartialEq, Hash, Ord, PartialOrd, Serialize, Deserialize, Property,
+    Debug, Clone, Copy, Eq, PartialEq, Hash, Ord, PartialOrd, Serialize, Deserialize, Reflect,
 )]
+#[reflect_value(PartialEq, Hash, Serialize, Deserialize)]
 pub struct AssetPathId(SourcePathId, LabelId);
 
 #[derive(
-    Debug, Clone, Copy, Eq, PartialEq, Hash, Ord, PartialOrd, Serialize, Deserialize, Property,
+    Debug, Clone, Copy, Eq, PartialEq, Hash, Ord, PartialOrd, Serialize, Deserialize, Reflect,
 )]
+#[reflect_value(PartialEq, Hash, Serialize, Deserialize)]
 pub struct SourcePathId(u64);
 
 #[derive(
-    Debug, Clone, Copy, Eq, PartialEq, Hash, Ord, PartialOrd, Serialize, Deserialize, Property,
+    Debug, Clone, Copy, Eq, PartialEq, Hash, Ord, PartialOrd, Serialize, Deserialize, Reflect,
 )]
+#[reflect_value(PartialEq, Hash, Serialize, Deserialize)]
 pub struct LabelId(u64);
 
 impl<'a> From<&'a Path> for SourcePathId {
@@ -140,7 +143,7 @@ impl<'a, 'b> From<&'a AssetPath<'b>> for AssetPathId {
 impl<'a> From<&'a str> for AssetPath<'a> {
     fn from(asset_path: &'a str) -> Self {
         let mut parts = asset_path.split('#');
-        let path = Path::new(parts.next().expect("path must be set"));
+        let path = Path::new(parts.next().expect("Path must be set."));
         let label = parts.next();
         AssetPath {
             path: Cow::Borrowed(path),
diff --git a/crates/bevy_audio/Cargo.toml b/crates/bevy_audio/Cargo.toml
index 5dac2083c43b5..ca56db3a80805 100644
--- a/crates/bevy_audio/Cargo.toml
+++ b/crates/bevy_audio/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_audio"
-version = "0.3.0"
+version = "0.4.0"
 edition = "2018"
 authors = [
     "Bevy Contributors <bevyengine@gmail.com>",
@@ -14,11 +14,11 @@ keywords = ["bevy"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.3.0" }
-bevy_asset = { path = "../bevy_asset", version = "0.3.0" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.3.0" }
-bevy_type_registry = { path = "../bevy_type_registry", version = "0.3.0" }
-bevy_utils = { path = "../bevy_utils", version = "0.3.0" }
+bevy_app = { path = "../bevy_app", version = "0.4.0" }
+bevy_asset = { path = "../bevy_asset", version = "0.4.0" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.4.0" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.4.0", features = ["bevy"] }
+bevy_utils = { path = "../bevy_utils", version = "0.4.0" }
 
 # other
 anyhow = "1.0"
diff --git a/crates/bevy_audio/src/audio.rs b/crates/bevy_audio/src/audio.rs
index 0c6d0ef80e6be..7a7fe12b3f99f 100644
--- a/crates/bevy_audio/src/audio.rs
+++ b/crates/bevy_audio/src/audio.rs
@@ -1,17 +1,17 @@
 use crate::{AudioSource, Decodable};
-use bevy_asset::Handle;
+use bevy_asset::{Asset, Handle};
 use parking_lot::RwLock;
 use std::{collections::VecDeque, fmt};
 
 /// The external struct used to play audio
 pub struct Audio<P = AudioSource>
 where
-    P: Decodable,
+    P: Asset + Decodable,
 {
     pub queue: RwLock<VecDeque<Handle<P>>>,
 }
 
-impl<P> fmt::Debug for Audio<P>
+impl<P: Asset> fmt::Debug for Audio<P>
 where
     P: Decodable,
 {
@@ -22,7 +22,7 @@ where
 
 impl<P> Default for Audio<P>
 where
-    P: Decodable,
+    P: Asset + Decodable,
 {
     fn default() -> Self {
         Self {
@@ -33,7 +33,7 @@ where
 
 impl<P> Audio<P>
 where
-    P: Decodable,
+    P: Asset + Decodable,
     <P as Decodable>::Decoder: rodio::Source + Send + Sync,
     <<P as Decodable>::Decoder as Iterator>::Item: rodio::Sample + Send + Sync,
 {
diff --git a/crates/bevy_audio/src/audio_source.rs b/crates/bevy_audio/src/audio_source.rs
index 7f36276a0001b..087640afc4543 100644
--- a/crates/bevy_audio/src/audio_source.rs
+++ b/crates/bevy_audio/src/audio_source.rs
@@ -1,6 +1,6 @@
 use anyhow::Result;
 use bevy_asset::{AssetLoader, LoadContext, LoadedAsset};
-use bevy_type_registry::TypeUuid;
+use bevy_reflect::TypeUuid;
 use bevy_utils::BoxedFuture;
 use std::{io::Cursor, sync::Arc};
 
diff --git a/crates/bevy_audio/src/lib.rs b/crates/bevy_audio/src/lib.rs
index e2d6e4ef412d4..52b7a56dea06e 100644
--- a/crates/bevy_audio/src/lib.rs
+++ b/crates/bevy_audio/src/lib.rs
@@ -12,6 +12,7 @@ pub mod prelude {
 
 use bevy_app::prelude::*;
 use bevy_asset::AddAsset;
+use bevy_ecs::IntoSystem;
 
 /// Adds support for audio playback to an App
 #[derive(Default)]
@@ -23,6 +24,9 @@ impl Plugin for AudioPlugin {
             .add_asset::<AudioSource>()
             .init_asset_loader::<Mp3Loader>()
             .init_resource::<Audio<AudioSource>>()
-            .add_system_to_stage(stage::POST_UPDATE, play_queued_audio_system::<AudioSource>);
+            .add_system_to_stage(
+                stage::POST_UPDATE,
+                play_queued_audio_system::<AudioSource>.system(),
+            );
     }
 }
diff --git a/crates/bevy_core/Cargo.toml b/crates/bevy_core/Cargo.toml
index 57d677473a418..7986e54f4ba55 100644
--- a/crates/bevy_core/Cargo.toml
+++ b/crates/bevy_core/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_core"
-version = "0.3.0"
+version = "0.4.0"
 edition = "2018"
 authors = [
     "Bevy Contributors <bevyengine@gmail.com>",
@@ -14,11 +14,10 @@ keywords = ["bevy"]
 
 
 [dependencies]
-bevy_app = { path = "../bevy_app", version = "0.3.0" }
-bevy_derive = { path = "../bevy_derive", version = "0.3.0" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.3.0" }
-bevy_property = { path = "../bevy_property", version = "0.3.0" }
-bevy_type_registry = { path = "../bevy_type_registry", version = "0.3.0" }
-bevy_math = { path = "../bevy_math", version = "0.3.0" }
-bevy_utils = { path = "../bevy_utils", version = "0.3.0" }
-bevy_tasks = { path = "../bevy_tasks", version = "0.3.0" }
+bevy_app = { path = "../bevy_app", version = "0.4.0" }
+bevy_derive = { path = "../bevy_derive", version = "0.4.0" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.4.0" }
+bevy_math = { path = "../bevy_math", version = "0.4.0" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.4.0", features = ["bevy"] }
+bevy_tasks = { path = "../bevy_tasks", version = "0.4.0" }
+bevy_utils = { path = "../bevy_utils", version = "0.4.0" }
diff --git a/crates/bevy_core/src/label.rs b/crates/bevy_core/src/label.rs
index e01aa170a536d..26309477e7843 100644
--- a/crates/bevy_core/src/label.rs
+++ b/crates/bevy_core/src/label.rs
@@ -1,5 +1,5 @@
 use bevy_ecs::prelude::*;
-use bevy_property::Properties;
+use bevy_reflect::{Reflect, ReflectComponent};
 use bevy_utils::{HashMap, HashSet};
 use std::{
     borrow::Cow,
@@ -8,7 +8,8 @@ use std::{
 };
 
 /// A collection of labels
-#[derive(Default, Properties)]
+#[derive(Default, Reflect)]
+#[reflect(Component)]
 pub struct Labels {
     labels: HashSet<Cow<'static, str>>,
 }
diff --git a/crates/bevy_core/src/lib.rs b/crates/bevy_core/src/lib.rs
index 3a5cb4f3c2429..468879e2363dc 100644
--- a/crates/bevy_core/src/lib.rs
+++ b/crates/bevy_core/src/lib.rs
@@ -4,6 +4,10 @@ mod label;
 mod task_pool_options;
 mod time;
 
+use std::ops::Range;
+
+use bevy_ecs::IntoSystem;
+use bevy_reflect::RegisterTypeBuilder;
 pub use bytes::*;
 pub use float_ord::*;
 pub use label::*;
@@ -15,8 +19,6 @@ pub mod prelude {
 }
 
 use bevy_app::prelude::*;
-use bevy_math::{Mat3, Mat4, Quat, Vec2, Vec3};
-use bevy_type_registry::RegisterType;
 
 /// Adds core functionality to Apps.
 #[derive(Default)]
@@ -32,15 +34,11 @@ impl Plugin for CorePlugin {
 
         app.init_resource::<Time>()
             .init_resource::<EntityLabels>()
-            .register_component::<Timer>()
-            .register_property::<Vec2>()
-            .register_property::<Vec3>()
-            .register_property::<Mat3>()
-            .register_property::<Mat4>()
-            .register_property::<Quat>()
-            .register_property::<Option<String>>()
-            .add_system_to_stage(stage::FIRST, time_system)
-            .add_system_to_stage(stage::FIRST, timer_system)
-            .add_system_to_stage(stage::PRE_UPDATE, entity_labels_system);
+            .init_resource::<FixedTimesteps>()
+            .register_type::<Option<String>>()
+            .register_type::<Range<f32>>()
+            .register_type::<Timer>()
+            .add_system_to_stage(stage::FIRST, time_system.system())
+            .add_system_to_stage(stage::PRE_UPDATE, entity_labels_system.system());
     }
 }
diff --git a/crates/bevy_core/src/time/fixed_timestep.rs b/crates/bevy_core/src/time/fixed_timestep.rs
new file mode 100644
index 0000000000000..e8ddea5303726
--- /dev/null
+++ b/crates/bevy_core/src/time/fixed_timestep.rs
@@ -0,0 +1,168 @@
+use crate::Time;
+use bevy_ecs::{ArchetypeComponent, ShouldRun, System, SystemId, ThreadLocalExecution, TypeAccess};
+use bevy_utils::HashMap;
+use std::{any::TypeId, borrow::Cow};
+
+pub struct FixedTimestepState {
+    pub step: f64,
+    pub accumulator: f64,
+}
+
+impl FixedTimestepState {
+    /// The amount of time each step takes
+    pub fn step(&self) -> f64 {
+        self.step
+    }
+
+    /// The number of steps made in a second
+    pub fn steps_per_second(&self) -> f64 {
+        1.0 / self.step
+    }
+
+    /// The amount of time (in seconds) left over from the last step
+    pub fn accumulator(&self) -> f64 {
+        self.accumulator
+    }
+
+    /// The percentage of "step" stored inside the accumulator. Calculated as accumulator / step
+    pub fn overstep_percentage(&self) -> f64 {
+        self.accumulator / self.step
+    }
+}
+
+#[derive(Default)]
+pub struct FixedTimesteps {
+    fixed_timesteps: HashMap<String, FixedTimestepState>,
+}
+
+impl FixedTimesteps {
+    pub fn get(&self, name: &str) -> Option<&FixedTimestepState> {
+        self.fixed_timesteps.get(name)
+    }
+}
+
+pub struct FixedTimestep {
+    step: f64,
+    accumulator: f64,
+    looping: bool,
+    system_id: SystemId,
+    label: Option<String>, // TODO: consider making this a TypedLabel
+    resource_access: TypeAccess<TypeId>,
+    archetype_access: TypeAccess<ArchetypeComponent>,
+}
+
+impl Default for FixedTimestep {
+    fn default() -> Self {
+        Self {
+            system_id: SystemId::new(),
+            step: 1.0 / 60.0,
+            accumulator: 0.0,
+            looping: false,
+            label: None,
+            resource_access: Default::default(),
+            archetype_access: Default::default(),
+        }
+    }
+}
+
+impl FixedTimestep {
+    pub fn step(step: f64) -> Self {
+        Self {
+            step,
+            ..Default::default()
+        }
+    }
+
+    pub fn steps_per_second(rate: f64) -> Self {
+        Self {
+            step: 1.0 / rate,
+            ..Default::default()
+        }
+    }
+
+    pub fn with_label(mut self, label: &str) -> Self {
+        self.label = Some(label.to_string());
+        self
+    }
+
+    pub fn update(&mut self, time: &Time) -> ShouldRun {
+        if !self.looping {
+            self.accumulator += time.delta_seconds_f64();
+        }
+
+        if self.accumulator >= self.step {
+            self.accumulator -= self.step;
+            self.looping = true;
+            ShouldRun::YesAndLoop
+        } else {
+            self.looping = false;
+            ShouldRun::No
+        }
+    }
+}
+
+impl System for FixedTimestep {
+    type In = ();
+    type Out = ShouldRun;
+
+    fn name(&self) -> Cow<'static, str> {
+        Cow::Borrowed(std::any::type_name::<FixedTimestep>())
+    }
+
+    fn id(&self) -> SystemId {
+        self.system_id
+    }
+
+    fn update(&mut self, _world: &bevy_ecs::World) {}
+
+    fn archetype_component_access(&self) -> &TypeAccess<ArchetypeComponent> {
+        &self.archetype_access
+    }
+
+    fn resource_access(&self) -> &TypeAccess<TypeId> {
+        &self.resource_access
+    }
+
+    fn thread_local_execution(&self) -> ThreadLocalExecution {
+        ThreadLocalExecution::Immediate
+    }
+
+    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)
+    }
+
+    fn run_thread_local(
+        &mut self,
+        _world: &mut bevy_ecs::World,
+        _resources: &mut bevy_ecs::Resources,
+    ) {
+    }
+
+    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();
+            fixed_timesteps.fixed_timesteps.insert(
+                label.clone(),
+                FixedTimestepState {
+                    accumulator: 0.0,
+                    step: self.step,
+                },
+            );
+        }
+    }
+}
diff --git a/crates/bevy_core/src/time/mod.rs b/crates/bevy_core/src/time/mod.rs
index ce3863df4062f..8be564301c013 100644
--- a/crates/bevy_core/src/time/mod.rs
+++ b/crates/bevy_core/src/time/mod.rs
@@ -1,6 +1,8 @@
+mod fixed_timestep;
 #[allow(clippy::module_inception)]
 mod time;
 mod timer;
 
+pub use fixed_timestep::*;
 pub use time::*;
 pub use timer::*;
diff --git a/crates/bevy_core/src/time/time.rs b/crates/bevy_core/src/time/time.rs
index 0baee828e2bf0..d2f32411bceef 100644
--- a/crates/bevy_core/src/time/time.rs
+++ b/crates/bevy_core/src/time/time.rs
@@ -4,19 +4,19 @@ use bevy_utils::{Duration, Instant};
 /// Tracks elapsed time since the last update and since the App has started
 #[derive(Debug)]
 pub struct Time {
-    pub delta: Duration,
-    pub instant: Option<Instant>,
-    pub delta_seconds_f64: f64,
-    pub delta_seconds: f32,
-    pub seconds_since_startup: f64,
-    pub startup: Instant,
+    delta: Duration,
+    last_update: Option<Instant>,
+    delta_seconds_f64: f64,
+    delta_seconds: f32,
+    seconds_since_startup: f64,
+    startup: Instant,
 }
 
 impl Default for Time {
     fn default() -> Time {
         Time {
             delta: Duration::from_secs(0),
-            instant: None,
+            last_update: None,
             startup: Instant::now(),
             delta_seconds_f64: 0.0,
             seconds_since_startup: 0.0,
@@ -28,15 +28,55 @@ impl Default for Time {
 impl Time {
     pub fn update(&mut self) {
         let now = Instant::now();
-        if let Some(instant) = self.instant {
-            self.delta = now - instant;
+        self.update_with_instant(now);
+    }
+
+    pub(crate) fn update_with_instant(&mut self, instant: Instant) {
+        if let Some(last_update) = self.last_update {
+            self.delta = instant - last_update;
             self.delta_seconds_f64 = self.delta.as_secs_f64();
             self.delta_seconds = self.delta.as_secs_f32();
         }
 
-        let duration_since_startup = now - self.startup;
+        let duration_since_startup = instant - self.startup;
         self.seconds_since_startup = duration_since_startup.as_secs_f64();
-        self.instant = Some(now);
+        self.last_update = Some(instant);
+    }
+
+    /// The delta between the current tick and last tick as a [`Duration`]
+    #[inline]
+    pub fn delta(&self) -> Duration {
+        self.delta
+    }
+
+    /// The delta between the current and last tick as [`f32`] seconds
+    #[inline]
+    pub fn delta_seconds(&self) -> f32 {
+        self.delta_seconds
+    }
+
+    /// The delta between the current and last tick as [`f64`] seconds
+    #[inline]
+    pub fn delta_seconds_f64(&self) -> f64 {
+        self.delta_seconds_f64
+    }
+
+    /// The time since startup in seconds
+    #[inline]
+    pub fn seconds_since_startup(&self) -> f64 {
+        self.seconds_since_startup
+    }
+
+    /// The [`Instant`] the app was started
+    #[inline]
+    pub fn startup(&self) -> Instant {
+        self.startup
+    }
+
+    /// The ['Instant'] when [`Time::update`] was last called, if it exists
+    #[inline]
+    pub fn last_update(&self) -> Option<Instant> {
+        self.last_update
     }
 
     pub fn time_since_startup(&self) -> Duration {
@@ -47,3 +87,60 @@ impl Time {
 pub(crate) fn time_system(mut time: ResMut<Time>) {
     time.update();
 }
+
+#[cfg(test)]
+mod tests {
+    use super::Time;
+    use bevy_utils::{Duration, Instant};
+
+    #[test]
+    fn update_test() {
+        let start_instant = Instant::now();
+
+        // Create a `Time` for testing
+        let mut time = Time {
+            startup: start_instant,
+            ..Default::default()
+        };
+
+        // Ensure `time` was constructed correctly
+        assert_eq!(time.delta(), Duration::from_secs(0));
+        assert_eq!(time.last_update(), None);
+        assert_eq!(time.startup(), start_instant);
+        assert_eq!(time.delta_seconds_f64(), 0.0);
+        assert_eq!(time.seconds_since_startup(), 0.0);
+        assert_eq!(time.delta_seconds(), 0.0);
+
+        // Update `time` and check results
+        let first_update_instant = Instant::now();
+
+        time.update_with_instant(first_update_instant);
+
+        assert_eq!(time.delta(), Duration::from_secs(0));
+        assert_eq!(time.last_update(), Some(first_update_instant));
+        assert_eq!(time.startup(), start_instant);
+        assert_eq!(time.delta_seconds_f64(), 0.0);
+        assert_eq!(
+            time.seconds_since_startup(),
+            (first_update_instant - start_instant).as_secs_f64()
+        );
+        assert_eq!(time.delta_seconds, 0.0);
+
+        // Update `time` again and check results
+        let second_update_instant = Instant::now();
+
+        time.update_with_instant(second_update_instant);
+
+        assert_eq!(time.delta(), second_update_instant - first_update_instant);
+        assert_eq!(time.last_update(), Some(second_update_instant));
+        assert_eq!(time.startup(), start_instant);
+        // At this point its safe to use time.delta as a valid value
+        // because it's been previously verified to be correct
+        assert_eq!(time.delta_seconds_f64(), time.delta().as_secs_f64());
+        assert_eq!(
+            time.seconds_since_startup(),
+            (second_update_instant - start_instant).as_secs_f64()
+        );
+        assert_eq!(time.delta_seconds(), time.delta().as_secs_f32());
+    }
+}
diff --git a/crates/bevy_core/src/time/timer.rs b/crates/bevy_core/src/time/timer.rs
index 33ec613336e66..318531b286247 100644
--- a/crates/bevy_core/src/time/timer.rs
+++ b/crates/bevy_core/src/time/timer.rs
@@ -1,20 +1,22 @@
-use crate::time::Time;
-use bevy_ecs::prelude::*;
-use bevy_property::Properties;
+use bevy_reflect::{Reflect, ReflectComponent};
 use bevy_utils::Duration;
 
 /// Tracks elapsed time. Enters the finished state once `duration` is reached.
 ///
 /// Non repeating timers will stop tracking and stay in the finished state until reset.
 /// Repeating timers will only be in the finished state on each tick `duration` is reached or exceeded, and can still be reset at any given point.
-#[derive(Clone, Debug, Default, Properties)]
+///
+/// Paused timers will not have elapsed time increased.
+#[derive(Clone, Debug, Default, Reflect)]
+#[reflect(Component)]
 pub struct Timer {
-    pub elapsed: f32,
-    pub duration: f32,
-    pub finished: bool,
+    elapsed: f32,
+    duration: f32,
+    finished: bool,
     /// Will only be true on the tick `duration` is reached or exceeded.
-    pub just_finished: bool,
-    pub repeating: bool,
+    just_finished: bool,
+    paused: bool,
+    repeating: bool,
 }
 
 impl Timer {
@@ -34,31 +36,176 @@ impl Timer {
         }
     }
 
+    #[inline]
+    pub fn pause(&mut self) {
+        self.paused = true
+    }
+
+    #[inline]
+    pub fn unpause(&mut self) {
+        self.paused = false
+    }
+
+    #[inline]
+    pub fn paused(&self) -> bool {
+        self.paused
+    }
+
+    /// Returns the time elapsed on the timer. Guaranteed to be between 0.0 and `duration`, inclusive.
+    #[inline]
+    pub fn elapsed(&self) -> f32 {
+        self.elapsed
+    }
+
+    #[inline]
+    pub fn set_elapsed(&mut self, elapsed: f32) {
+        self.elapsed = elapsed
+    }
+
+    #[inline]
+    pub fn duration(&self) -> f32 {
+        self.duration
+    }
+
+    #[inline]
+    pub fn set_duration(&mut self, duration: f32) {
+        self.duration = duration
+    }
+
+    /// Returns the finished state of the timer.
+    ///
+    /// Non repeating timers will stop tracking and stay in the finished state until reset.
+    /// Repeating timers will only be in the finished state on each tick `duration` is reached or exceeded, and can still be reset at any given point.
+    #[inline]
+    pub fn finished(&self) -> bool {
+        self.finished
+    }
+
+    /// Will only be true on the tick the timer's duration is reached or exceeded.
+    #[inline]
+    pub fn just_finished(&self) -> bool {
+        self.just_finished
+    }
+
+    #[inline]
+    pub fn repeating(&self) -> bool {
+        self.repeating
+    }
+
+    #[inline]
+    pub fn set_repeating(&mut self, repeating: bool) {
+        self.repeating = repeating
+    }
+
     /// Advances the timer by `delta` seconds.
     pub fn tick(&mut self, delta: f32) -> &Self {
-        let prev_finished = self.elapsed >= self.duration;
-        if !prev_finished {
-            self.elapsed += delta;
+        if self.paused {
+            return self;
         }
+        let prev_finished = self.finished;
+        self.elapsed += delta;
 
         self.finished = self.elapsed >= self.duration;
         self.just_finished = !prev_finished && self.finished;
 
-        if self.repeating && self.finished {
-            self.elapsed %= self.duration;
+        if self.finished {
+            if self.repeating {
+                // Repeating timers wrap around
+                self.elapsed %= self.duration;
+            } else {
+                // Non-repeating timers clamp to duration
+                self.elapsed = self.duration;
+            }
         }
         self
     }
 
+    #[inline]
     pub fn reset(&mut self) {
         self.finished = false;
         self.just_finished = false;
         self.elapsed = 0.0;
     }
+
+    /// Percent timer has elapsed (goes from 0.0 to 1.0)
+    pub fn percent(&self) -> f32 {
+        self.elapsed / self.duration
+    }
+
+    /// Percent left on timer (goes from 1.0 to 0.0)
+    pub fn percent_left(&self) -> f32 {
+        (self.duration - self.elapsed) / self.duration
+    }
 }
 
-pub(crate) fn timer_system(time: Res<Time>, mut query: Query<&mut Timer>) {
-    for mut timer in query.iter_mut() {
-        timer.tick(time.delta_seconds);
+#[cfg(test)]
+mod tests {
+    use super::Timer;
+
+    #[test]
+    fn test_non_repeating() {
+        let mut t = Timer::from_seconds(10.0, false);
+        // Tick once, check all attributes
+        t.tick(0.25);
+        assert_eq!(t.elapsed(), 0.25);
+        assert_eq!(t.duration(), 10.0);
+        assert_eq!(t.finished(), false);
+        assert_eq!(t.just_finished(), false);
+        assert_eq!(t.repeating(), false);
+        assert_eq!(t.percent(), 0.025);
+        assert_eq!(t.percent_left(), 0.975);
+        // Ticking while paused changes nothing
+        t.pause();
+        t.tick(500.0);
+        assert_eq!(t.elapsed(), 0.25);
+        assert_eq!(t.duration(), 10.0);
+        assert_eq!(t.finished(), false);
+        assert_eq!(t.just_finished(), false);
+        assert_eq!(t.repeating(), false);
+        assert_eq!(t.percent(), 0.025);
+        assert_eq!(t.percent_left(), 0.975);
+        // Tick past the end and make sure elapsed doesn't go past 0.0 and other things update
+        t.unpause();
+        t.tick(500.0);
+        assert_eq!(t.elapsed(), 10.0);
+        assert_eq!(t.finished(), true);
+        assert_eq!(t.just_finished(), true);
+        assert_eq!(t.percent(), 1.0);
+        assert_eq!(t.percent_left(), 0.0);
+        // Continuing to tick when finished should only change just_finished
+        t.tick(1.0);
+        assert_eq!(t.elapsed(), 10.0);
+        assert_eq!(t.finished(), true);
+        assert_eq!(t.just_finished(), false);
+        assert_eq!(t.percent(), 1.0);
+        assert_eq!(t.percent_left(), 0.0);
+    }
+
+    #[test]
+    fn test_repeating() {
+        let mut t = Timer::from_seconds(2.0, true);
+        // Tick once, check all attributes
+        t.tick(0.75);
+        assert_eq!(t.elapsed(), 0.75);
+        assert_eq!(t.duration(), 2.0);
+        assert_eq!(t.finished(), false);
+        assert_eq!(t.just_finished(), false);
+        assert_eq!(t.repeating(), true);
+        assert_eq!(t.percent(), 0.375);
+        assert_eq!(t.percent_left(), 0.625);
+        // Tick past the end and make sure elapsed wraps
+        t.tick(1.5);
+        assert_eq!(t.elapsed(), 0.25);
+        assert_eq!(t.finished(), true);
+        assert_eq!(t.just_finished(), true);
+        assert_eq!(t.percent(), 0.125);
+        assert_eq!(t.percent_left(), 0.875);
+        // Continuing to tick should turn off both finished & just_finished for repeating timers
+        t.tick(1.0);
+        assert_eq!(t.elapsed(), 1.25);
+        assert_eq!(t.finished(), false);
+        assert_eq!(t.just_finished(), false);
+        assert_eq!(t.percent(), 0.625);
+        assert_eq!(t.percent_left(), 0.375);
     }
 }
diff --git a/crates/bevy_derive/Cargo.toml b/crates/bevy_derive/Cargo.toml
index 70410888aab81..c64ecb4b709dd 100644
--- a/crates/bevy_derive/Cargo.toml
+++ b/crates/bevy_derive/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_derive"
-version = "0.3.0"
+version = "0.4.0"
 edition = "2018"
 authors = [
     "Bevy Contributors <bevyengine@gmail.com>",
@@ -21,4 +21,3 @@ find-crate = "0.6"
 proc-macro2 = "1.0"
 quote = "1.0"
 syn = "1.0"
-uuid = { version = "0.8", features = ["v4", "serde"] }
diff --git a/crates/bevy_derive/src/bevy_main.rs b/crates/bevy_derive/src/bevy_main.rs
index bbc8bb2fe3651..00a50b634fd5c 100644
--- a/crates/bevy_derive/src/bevy_main.rs
+++ b/crates/bevy_derive/src/bevy_main.rs
@@ -5,7 +5,7 @@ use syn::{parse_macro_input, ItemFn};
 pub fn bevy_main(_attr: TokenStream, item: TokenStream) -> TokenStream {
     let input = parse_macro_input!(item as ItemFn);
     if input.sig.ident != "main" {
-        panic!("bevy_main can only be used on a function called 'main'")
+        panic!("`bevy_main` can only be used on a function called 'main'.")
     }
 
     TokenStream::from(quote! {
diff --git a/crates/bevy_derive/src/bytes.rs b/crates/bevy_derive/src/bytes.rs
index d2391279dedd0..a1e1afb0bbecd 100644
--- a/crates/bevy_derive/src/bytes.rs
+++ b/crates/bevy_derive/src/bytes.rs
@@ -10,7 +10,7 @@ pub fn derive_bytes(input: TokenStream) -> TokenStream {
             fields: Fields::Named(fields),
             ..
         }) => &fields.named,
-        _ => panic!("expected a struct with named fields"),
+        _ => panic!("Expected a struct with named fields."),
     };
 
     let modules = get_modules(&ast.attrs);
diff --git a/crates/bevy_derive/src/lib.rs b/crates/bevy_derive/src/lib.rs
index 76c0bdf76f4e6..a7b3d01cf720a 100644
--- a/crates/bevy_derive/src/lib.rs
+++ b/crates/bevy_derive/src/lib.rs
@@ -8,7 +8,6 @@ mod render_resource;
 mod render_resources;
 mod resource;
 mod shader_defs;
-mod type_uuid;
 
 use proc_macro::TokenStream;
 
@@ -51,17 +50,6 @@ pub fn derive_dynamic_plugin(input: TokenStream) -> TokenStream {
     app_plugin::derive_dynamic_plugin(input)
 }
 
-// From https://github.com/randomPoison/type-uuid
-#[proc_macro_derive(TypeUuid, attributes(uuid))]
-pub fn type_uuid_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
-    type_uuid::type_uuid_derive(input)
-}
-
-#[proc_macro]
-pub fn external_type_uuid(tokens: proc_macro::TokenStream) -> proc_macro::TokenStream {
-    type_uuid::external_type_uuid(tokens)
-}
-
 #[proc_macro_attribute]
 pub fn bevy_main(attr: TokenStream, item: TokenStream) -> TokenStream {
     bevy_main::bevy_main(attr, item)
diff --git a/crates/bevy_derive/src/modules.rs b/crates/bevy_derive/src/modules.rs
index c343be3e6e53c..19cd16c7aaa6d 100644
--- a/crates/bevy_derive/src/modules.rs
+++ b/crates/bevy_derive/src/modules.rs
@@ -8,7 +8,6 @@ pub struct Modules {
     pub bevy_asset: String,
     pub bevy_core: String,
     pub bevy_app: String,
-    pub bevy_type_registry: String,
 }
 
 impl Modules {
@@ -18,7 +17,6 @@ impl Modules {
             bevy_render: format!("{}::render", name),
             bevy_core: format!("{}::core", name),
             bevy_app: format!("{}::app", name),
-            bevy_type_registry: format!("{}::type_registry", name),
         }
     }
 
@@ -28,7 +26,6 @@ impl Modules {
             bevy_render: "bevy_render".to_string(),
             bevy_core: "bevy_core".to_string(),
             bevy_app: "bevy_app".to_string(),
-            bevy_type_registry: "bevy_type_registry".to_string(),
         }
     }
 }
diff --git a/crates/bevy_derive/src/render_resources.rs b/crates/bevy_derive/src/render_resources.rs
index 2621522e4388d..8ef74da15e20c 100644
--- a/crates/bevy_derive/src/render_resources.rs
+++ b/crates/bevy_derive/src/render_resources.rs
@@ -36,7 +36,7 @@ pub fn derive_render_resources(input: TokenStream) -> TokenStream {
                 }
                 Ok(())
             })
-            .expect("invalid 'render_resources' attribute format");
+            .expect("Invalid 'render_resources' attribute format.");
 
             attributes
         });
@@ -77,7 +77,7 @@ pub fn derive_render_resources(input: TokenStream) -> TokenStream {
                 fields: Fields::Named(fields),
                 ..
             }) => &fields.named,
-            _ => panic!("expected a struct with named fields"),
+            _ => panic!("Expected a struct with named fields."),
         };
         let field_attributes = fields
             .iter()
@@ -102,7 +102,7 @@ pub fn derive_render_resources(input: TokenStream) -> TokenStream {
                                 }
                                 Ok(())
                             })
-                            .expect("invalid 'render_resources' attribute format");
+                            .expect("Invalid 'render_resources' attribute format.");
 
                             attributes
                         }),
@@ -160,11 +160,11 @@ pub fn derive_render_resources(input: TokenStream) -> TokenStream {
                 }
 
                 fn get_render_resource_name(&self, index: usize) -> Option<&str> {
-                    Some(#render_resource_names_ident[index])
+                    #render_resource_names_ident.get(index).copied()
                 }
 
                 fn get_render_resource_hints(&self, index: usize) -> Option<#bevy_render_path::renderer::RenderResourceHints> {
-                    #render_resource_hints_ident[index].clone()
+                    #render_resource_hints_ident.get(index).and_then(|o| *o)
                 }
 
                 fn iter(&self) -> #bevy_render_path::renderer::RenderResourceIterator {
diff --git a/crates/bevy_derive/src/resource.rs b/crates/bevy_derive/src/resource.rs
index 2403c9b700d19..22c2543e7d3f7 100644
--- a/crates/bevy_derive/src/resource.rs
+++ b/crates/bevy_derive/src/resource.rs
@@ -10,7 +10,7 @@ pub fn derive_from_resources(input: TokenStream) -> TokenStream {
             fields: Fields::Named(fields),
             ..
         }) => &fields.named,
-        _ => panic!("expected a struct with named fields"),
+        _ => panic!("Expected a struct with named fields."),
     };
 
     let modules = get_modules(&ast.attrs);
diff --git a/crates/bevy_derive/src/shader_defs.rs b/crates/bevy_derive/src/shader_defs.rs
index 055b76cf80b7a..0e5820e7c3420 100644
--- a/crates/bevy_derive/src/shader_defs.rs
+++ b/crates/bevy_derive/src/shader_defs.rs
@@ -17,7 +17,7 @@ pub fn derive_shader_defs(input: TokenStream) -> TokenStream {
             fields: Fields::Named(fields),
             ..
         }) => &fields.named,
-        _ => panic!("expected a struct with named fields"),
+        _ => panic!("Expected a struct with named fields."),
     };
 
     let shader_def_idents = fields
diff --git a/crates/bevy_diagnostic/Cargo.toml b/crates/bevy_diagnostic/Cargo.toml
index 93b6c7e0e57d4..2b39528e295ef 100644
--- a/crates/bevy_diagnostic/Cargo.toml
+++ b/crates/bevy_diagnostic/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_diagnostic"
-version = "0.3.0"
+version = "0.4.0"
 edition = "2018"
 authors = [
     "Bevy Contributors <bevyengine@gmail.com>",
@@ -15,11 +15,10 @@ keywords = ["bevy"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.3.0" }
-bevy_core = { path = "../bevy_core", version = "0.3.0" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.3.0" }
-bevy_utils = { path = "../bevy_utils", version = "0.3.0" }
+bevy_app = { path = "../bevy_app", version = "0.4.0" }
+bevy_core = { path = "../bevy_core", version = "0.4.0" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.4.0" }
+bevy_utils = { path = "../bevy_utils", version = "0.4.0" }
 
 # other
-uuid = { version = "0.8", features = ["v4", "serde"] }
 parking_lot = "0.11.0"
diff --git a/crates/bevy_diagnostic/src/diagnostic.rs b/crates/bevy_diagnostic/src/diagnostic.rs
index 91d675f3dc00d..20d7edcf93e3e 100644
--- a/crates/bevy_diagnostic/src/diagnostic.rs
+++ b/crates/bevy_diagnostic/src/diagnostic.rs
@@ -1,6 +1,5 @@
-use bevy_utils::{Duration, HashMap, Instant};
+use bevy_utils::{Duration, HashMap, Instant, Uuid};
 use std::collections::VecDeque;
-use uuid::Uuid;
 
 /// Unique identifier for a [Diagnostic]
 #[derive(Debug, Copy, Clone, Hash, Eq, PartialEq)]
diff --git a/crates/bevy_diagnostic/src/frame_time_diagnostics_plugin.rs b/crates/bevy_diagnostic/src/frame_time_diagnostics_plugin.rs
index aaabf1b6ac700..9a6481b2dbd8e 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::{Res, ResMut};
+use bevy_ecs::{IntoSystem, Res, ResMut};
 
 /// Adds "frame time" diagnostic to an App, specifically "frame time", "fps" and "frame count"
 #[derive(Default)]
@@ -13,9 +13,9 @@ pub struct FrameTimeDiagnosticsState {
 
 impl Plugin for FrameTimeDiagnosticsPlugin {
     fn build(&self, app: &mut bevy_app::AppBuilder) {
-        app.add_startup_system(Self::setup_system)
+        app.add_startup_system(Self::setup_system.system())
             .add_resource(FrameTimeDiagnosticsState { frame_count: 0.0 })
-            .add_system(Self::diagnostic_system);
+            .add_system(Self::diagnostic_system.system());
     }
 }
 
@@ -40,11 +40,11 @@ impl FrameTimeDiagnosticsPlugin {
         state.frame_count += 1.0;
         diagnostics.add_measurement(Self::FRAME_COUNT, state.frame_count);
 
-        if time.delta_seconds_f64 == 0.0 {
+        if time.delta_seconds_f64() == 0.0 {
             return;
         }
 
-        diagnostics.add_measurement(Self::FRAME_TIME, time.delta_seconds_f64);
+        diagnostics.add_measurement(Self::FRAME_TIME, time.delta_seconds_f64());
         if let Some(fps) = diagnostics
             .get(Self::FRAME_TIME)
             .and_then(|frame_time_diagnostic| {
diff --git a/crates/bevy_diagnostic/src/print_diagnostics_plugin.rs b/crates/bevy_diagnostic/src/print_diagnostics_plugin.rs
index 73e814fb332c5..e71f4b9066634 100644
--- a/crates/bevy_diagnostic/src/print_diagnostics_plugin.rs
+++ b/crates/bevy_diagnostic/src/print_diagnostics_plugin.rs
@@ -1,7 +1,7 @@
 use super::{Diagnostic, DiagnosticId, Diagnostics};
 use bevy_app::prelude::*;
 use bevy_core::{Time, Timer};
-use bevy_ecs::{Res, ResMut};
+use bevy_ecs::{IntoSystem, Res, ResMut};
 use bevy_utils::Duration;
 
 /// An App Plugin that prints diagnostics to the console
@@ -35,9 +35,12 @@ impl Plugin for PrintDiagnosticsPlugin {
         });
 
         if self.debug {
-            app.add_system_to_stage(stage::POST_UPDATE, Self::print_diagnostics_debug_system);
+            app.add_system_to_stage(
+                stage::POST_UPDATE,
+                Self::print_diagnostics_debug_system.system(),
+            );
         } else {
-            app.add_system_to_stage(stage::POST_UPDATE, Self::print_diagnostics_system);
+            app.add_system_to_stage(stage::POST_UPDATE, Self::print_diagnostics_system.system());
         }
     }
 }
@@ -66,7 +69,7 @@ impl PrintDiagnosticsPlugin {
         time: Res<Time>,
         diagnostics: Res<Diagnostics>,
     ) {
-        if state.timer.tick(time.delta_seconds).finished {
+        if state.timer.tick(time.delta_seconds()).finished() {
             println!("Diagnostics:");
             println!("{}", "-".repeat(93));
             if let Some(ref filter) = state.filter {
@@ -86,7 +89,7 @@ impl PrintDiagnosticsPlugin {
         time: Res<Time>,
         diagnostics: Res<Diagnostics>,
     ) {
-        if state.timer.tick(time.delta_seconds).finished {
+        if state.timer.tick(time.delta_seconds()).finished() {
             println!("Diagnostics (Debug):");
             println!("{}", "-".repeat(93));
             if let Some(ref filter) = state.filter {
diff --git a/crates/bevy_dylib/Cargo.toml b/crates/bevy_dylib/Cargo.toml
index cd2d3de5e7c2b..caa404bb22b30 100644
--- a/crates/bevy_dylib/Cargo.toml
+++ b/crates/bevy_dylib/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_dylib"
-version = "0.3.0"
+version = "0.4.0"
 edition = "2018"
 authors = [
     "Bevy Contributors <bevyengine@gmail.com>",
@@ -16,4 +16,4 @@ keywords = ["bevy"]
 crate-type = ["dylib"]
 
 [dependencies]
-bevy_internal = { path = "../bevy_internal", version = "0.3.0", default-features = false }
+bevy_internal = { path = "../bevy_internal", version = "0.4.0", default-features = false }
diff --git a/crates/bevy_dynamic_plugin/Cargo.toml b/crates/bevy_dynamic_plugin/Cargo.toml
index 8a955022e5249..c367fe1aa71a0 100644
--- a/crates/bevy_dynamic_plugin/Cargo.toml
+++ b/crates/bevy_dynamic_plugin/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_dynamic_plugin"
-version = "0.3.0"
+version = "0.4.0"
 authors = [
     "Bevy Contributors <bevyengine@gmail.com>",
     "Carter Anderson <mcanders1@gmail.com>",
@@ -16,7 +16,7 @@ keywords = ["bevy"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.3.0" }
+bevy_app = { path = "../bevy_app", version = "0.4.0" }
 
 # other
 libloading = { version = "0.6" }
diff --git a/crates/bevy_ecs/Cargo.toml b/crates/bevy_ecs/Cargo.toml
index 44faa1178c2f1..e1355f3ca94ac 100644
--- a/crates/bevy_ecs/Cargo.toml
+++ b/crates/bevy_ecs/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_ecs"
-version = "0.3.0"
+version = "0.4.0"
 edition = "2018"
 authors = [
     "Bevy Contributors <bevyengine@gmail.com>",
@@ -17,9 +17,9 @@ categories = ["game-engines", "data-structures"]
 trace = []
 
 [dependencies]
-bevy_tasks = { path = "../bevy_tasks", version = "0.3.0" }
-bevy_utils = { path = "../bevy_utils", version = "0.3.0" }
-bevy_ecs_macros = { path = "macros", version = "0.3.0" }
+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" }
 rand = "0.7.3"
 serde = "1.0"
 thiserror = "1.0"
diff --git a/crates/bevy_ecs/macros/Cargo.toml b/crates/bevy_ecs/macros/Cargo.toml
index 6e5c8d9f4adf7..007751d323151 100644
--- a/crates/bevy_ecs/macros/Cargo.toml
+++ b/crates/bevy_ecs/macros/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_ecs_macros"
-version = "0.3.0"
+version = "0.4.0"
 description = "Bevy ECS Macros"
 authors = ["Benjamin Saunders <ben.e.saunders@gmail.com>"]
 edition = "2018"
@@ -13,4 +13,4 @@ proc-macro = true
 syn = "1.0"
 quote = "1.0"
 proc-macro2 = "1.0"
-find-crate = "0.5"
\ No newline at end of file
+find-crate = "0.6"
\ No newline at end of file
diff --git a/crates/bevy_ecs/macros/src/lib.rs b/crates/bevy_ecs/macros/src/lib.rs
index ded3e92a80197..f860219745d87 100644
--- a/crates/bevy_ecs/macros/src/lib.rs
+++ b/crates/bevy_ecs/macros/src/lib.rs
@@ -357,7 +357,7 @@ pub fn derive_system_param(input: TokenStream) -> TokenStream {
             fields: Fields::Named(fields),
             ..
         }) => &fields.named,
-        _ => panic!("expected a struct with named fields"),
+        _ => panic!("Expected a struct with named fields."),
     };
 
     let manifest = Manifest::new().unwrap();
@@ -386,7 +386,7 @@ pub fn derive_system_param(input: TokenStream) -> TokenStream {
                             }
                             Ok(())
                         })
-                        .expect("invalid 'render_resources' attribute format");
+                        .expect("Invalid 'render_resources' attribute format.");
 
                         attributes
                     }),
@@ -411,21 +411,27 @@ pub fn derive_system_param(input: TokenStream) -> TokenStream {
     let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
 
     let struct_name = &ast.ident;
+    let fetch_struct_name = Ident::new(&format!("Fetch{}", struct_name), Span::call_site());
 
     TokenStream::from(quote! {
-        impl #impl_generics #path::SystemParam<()> for #struct_name#ty_generics #where_clause {
+        pub struct #fetch_struct_name;
+        impl #impl_generics #path::SystemParam for #struct_name#ty_generics #where_clause {
+            type Fetch = #fetch_struct_name;
+        }
+
+        impl #impl_generics #path::FetchSystemParam<'a> for #fetch_struct_name {
+            type Item = #struct_name#ty_generics;
             fn init(system_state: &mut #path::SystemState, world: &#path::World, resources: &mut #path::Resources) {
-                #(<#field_types as SystemParam<()>>::init(system_state, world, resources);)*
+                #(<<#field_types as SystemParam>::Fetch as #path::FetchSystemParam>::init(system_state, world, resources);)*
             }
 
             unsafe fn get_param(
-                input: &mut Option<()>,
-                system_state: &mut #path::SystemState,
-                world: &#path::World,
-                resources: &#path::Resources,
-            ) -> Option<Self> {
+                system_state: &'a #path::SystemState,
+                world: &'a #path::World,
+                resources: &'a #path::Resources,
+            ) -> Option<Self::Item> {
                 Some(#struct_name {
-                    #(#fields: <#field_types as SystemParam<()>>::get_param(input, system_state, world, resources)?,)*
+                    #(#fields: <<#field_types as SystemParam>::Fetch as #path::FetchSystemParam>::get_param(system_state, world, resources)?,)*
                     #(#ignored_fields: <#ignored_field_types>::default(),)*
                 })
             }
diff --git a/crates/bevy_ecs/src/core/archetype.rs b/crates/bevy_ecs/src/core/archetype.rs
index 4ff348f601ed0..bd3763ad6e269 100644
--- a/crates/bevy_ecs/src/core/archetype.rs
+++ b/crates/bevy_ecs/src/core/archetype.rs
@@ -59,7 +59,7 @@ impl Archetype {
                 "attempted to allocate entity with duplicate components; \
                  each type must occur at most once!"
             ),
-            core::cmp::Ordering::Greater => panic!("type info is unsorted"),
+            core::cmp::Ordering::Greater => panic!("Type info is unsorted."),
         });
     }
 
@@ -160,7 +160,7 @@ impl Archetype {
             .get(&TypeId::of::<T>())
             .map_or(false, |x| !x.borrow.borrow())
         {
-            panic!("{} already borrowed uniquely", type_name::<T>());
+            panic!("{} already borrowed uniquely.", type_name::<T>());
         }
     }
 
@@ -172,7 +172,7 @@ impl Archetype {
             .get(&TypeId::of::<T>())
             .map_or(false, |x| !x.borrow.borrow_mut())
         {
-            panic!("{} already borrowed", type_name::<T>());
+            panic!("{} already borrowed.", type_name::<T>());
         }
     }
 
@@ -272,9 +272,9 @@ impl Archetype {
     fn grow(&mut self, increment: usize) {
         unsafe {
             let old_count = self.len;
-            let count = old_count + increment;
+            let new_capacity = self.capacity() + increment;
             self.entities.resize(
-                self.entities.len() + increment,
+                new_capacity,
                 Entity {
                     id: u32::MAX,
                     generation: u32::MAX,
@@ -284,7 +284,7 @@ impl Archetype {
             for type_state in self.state.values_mut() {
                 type_state
                     .component_flags
-                    .resize_with(count, ComponentFlags::empty);
+                    .resize_with(new_capacity, ComponentFlags::empty);
             }
 
             let old_data_size = mem::replace(&mut self.data_size, 0);
@@ -294,7 +294,7 @@ impl Archetype {
                 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() * count;
+                self.data_size += ty.layout.size() * new_capacity;
             }
             let new_data = if self.data_size == 0 {
                 NonNull::dangling()
@@ -484,7 +484,6 @@ pub struct TypeInfo {
     id: TypeId,
     layout: Layout,
     drop: unsafe fn(*mut u8),
-    #[cfg(debug_assertions)]
     type_name: &'static str,
 }
 
@@ -499,7 +498,6 @@ impl TypeInfo {
             id: TypeId::of::<T>(),
             layout: Layout::new::<T>(),
             drop: drop_ptr::<T>,
-            #[cfg(debug_assertions)]
             type_name: core::any::type_name::<T>(),
         }
     }
@@ -519,6 +517,12 @@ impl TypeInfo {
     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 {
diff --git a/crates/bevy_ecs/src/core/bundle.rs b/crates/bevy_ecs/src/core/bundle.rs
index e69eecb14a4ff..7ca93433d2e74 100644
--- a/crates/bevy_ecs/src/core/bundle.rs
+++ b/crates/bevy_ecs/src/core/bundle.rs
@@ -22,6 +22,8 @@ use std::{
 };
 
 /// 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)]
@@ -38,6 +40,8 @@ pub trait DynamicBundle {
 }
 
 /// 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;
diff --git a/crates/bevy_ecs/src/core/entities.rs b/crates/bevy_ecs/src/core/entities.rs
index 2a5cc637481bb..146856f4ea4fb 100644
--- a/crates/bevy_ecs/src/core/entities.rs
+++ b/crates/bevy_ecs/src/core/entities.rs
@@ -90,7 +90,7 @@ impl Entities {
                         id: u32::try_from(self.meta.len())
                             .ok()
                             .and_then(|x| x.checked_add(n))
-                            .expect("too many entities"),
+                            .expect("Too many entities."),
                     }
                 }
                 // The freelist has entities in it, so move the last entry to the reserved list, to
diff --git a/crates/bevy_ecs/src/core/entity_map.rs b/crates/bevy_ecs/src/core/entity_map.rs
index 6834dd8bfafd4..cf8c45431e44e 100644
--- a/crates/bevy_ecs/src/core/entity_map.rs
+++ b/crates/bevy_ecs/src/core/entity_map.rs
@@ -5,7 +5,7 @@ use thiserror::Error;
 
 #[derive(Error, Debug)]
 pub enum MapEntitiesError {
-    #[error("The given entity does not exist in the map.")]
+    #[error("the given entity does not exist in the map")]
     EntityNotFound(Entity),
 }
 
diff --git a/crates/bevy_ecs/src/core/serde.rs b/crates/bevy_ecs/src/core/serde.rs
index 680215d8f92f2..71bcc653a93b6 100644
--- a/crates/bevy_ecs/src/core/serde.rs
+++ b/crates/bevy_ecs/src/core/serde.rs
@@ -1,7 +1,7 @@
 // modified by Bevy contributors
 
 use crate::Entity;
-use serde::{Serialize, Serializer};
+use serde::{de::Visitor, Deserialize, Serialize, Serializer};
 
 impl Serialize for Entity {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -11,3 +11,29 @@ impl Serialize for Entity {
         serializer.serialize_u32(self.id())
     }
 }
+
+impl<'de> Deserialize<'de> for Entity {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        Ok(deserializer.deserialize_u32(EntityVisitor)?)
+    }
+}
+
+struct EntityVisitor;
+
+impl<'de> Visitor<'de> for EntityVisitor {
+    type Value = Entity;
+
+    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+        formatter.write_str("expected Entity")
+    }
+
+    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
+    where
+        E: serde::de::Error,
+    {
+        Ok(Entity::new(v))
+    }
+}
diff --git a/crates/bevy_ecs/src/core/world.rs b/crates/bevy_ecs/src/core/world.rs
index 2a80f9ff0350f..ca0c2938f0976 100644
--- a/crates/bevy_ecs/src/core/world.rs
+++ b/crates/bevy_ecs/src/core/world.rs
@@ -76,16 +76,16 @@ impl World {
     /// let a = world.spawn((123, "abc"));
     /// let b = world.spawn((456, true));
     /// ```
-    pub fn spawn(&mut self, components: impl DynamicBundle) -> Entity {
+    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 = components.with_ids(|ids| {
+        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(components.type_info()));
+                self.archetypes.push(Archetype::new(bundle.type_info()));
                 self.index.insert(ids.to_vec(), x);
                 self.archetype_generation += 1;
                 x
@@ -95,7 +95,7 @@ impl World {
         let archetype = &mut self.archetypes[archetype_id as usize];
         unsafe {
             let index = archetype.allocate(entity);
-            components.put(|ptr, ty, size| {
+            bundle.put(|ptr, ty, size| {
                 archetype.put_dynamic(ptr, ty, size, index, ComponentFlags::ADDED);
                 true
             });
@@ -566,7 +566,7 @@ impl World {
     pub fn insert(
         &mut self,
         entity: Entity,
-        components: impl DynamicBundle,
+        bundle: impl DynamicBundle,
     ) -> Result<(), NoSuchEntity> {
         use std::collections::hash_map::Entry;
 
@@ -576,7 +576,7 @@ impl World {
             // 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 components.type_info() {
+            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 {
@@ -601,7 +601,7 @@ impl World {
             if target == loc.archetype {
                 // Update components in the current archetype
                 let arch = &mut self.archetypes[loc.archetype as usize];
-                components.put(|ptr, ty, size| {
+                bundle.put(|ptr, ty, size| {
                     arch.put_dynamic(ptr, ty, size, loc.index, ComponentFlags::MUTATED);
                     true
                 });
@@ -625,7 +625,7 @@ impl World {
                 self.entities.get_mut(moved).unwrap().index = old_index;
             }
 
-            components.put(|ptr, ty, size| {
+            bundle.put(|ptr, ty, size| {
                 let had_component = source_arch.has_dynamic(ty);
                 let flags = if had_component {
                     ComponentFlags::MUTATED
diff --git a/crates/bevy_ecs/src/core/world_builder.rs b/crates/bevy_ecs/src/core/world_builder.rs
index 18c450583160c..18590683a25c1 100644
--- a/crates/bevy_ecs/src/core/world_builder.rs
+++ b/crates/bevy_ecs/src/core/world_builder.rs
@@ -62,4 +62,17 @@ impl<'a> WorldBuilder<'a> {
         self.current_entity = Some(self.world.spawn(components));
         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/lib.rs b/crates/bevy_ecs/src/lib.rs
index a8ead603feed2..0931d9f64d387 100644
--- a/crates/bevy_ecs/src/lib.rs
+++ b/crates/bevy_ecs/src/lib.rs
@@ -14,6 +14,7 @@ pub mod prelude {
     pub use crate::{
         core::WorldBuilderSource,
         resource::{ChangedRes, FromResources, Local, Res, ResMut, Resource, Resources},
+        schedule::{Schedule, State, StateStage, SystemStage},
         system::{Commands, IntoSystem, Query, System},
         Added, Bundle, Changed, Component, Entity, In, IntoChainSystem, Mut, Mutated, Or, QuerySet,
         Ref, RefMut, With, Without, World,
diff --git a/crates/bevy_ecs/src/resource/resources.rs b/crates/bevy_ecs/src/resource/resources.rs
index d3cc87d9ce4d8..8550eaa4b0493 100644
--- a/crates/bevy_ecs/src/resource/resources.rs
+++ b/crates/bevy_ecs/src/resource/resources.rs
@@ -233,7 +233,7 @@ impl Resources {
             Ordering::Equal => {
                 storage.push(resource);
             }
-            Ordering::Greater => panic!("attempted to access index beyond 'current_capacity + 1'"),
+            Ordering::Greater => panic!("Attempted to access index beyond 'current_capacity + 1'."),
             Ordering::Less => {
                 *storage.get_mut(index).unwrap() = resource;
             }
@@ -279,7 +279,7 @@ impl Resources {
                     .unwrap();
                 resources.get_unsafe_ref(index)
             })
-            .unwrap_or_else(|| panic!("Resource does not exist {}", std::any::type_name::<T>()))
+            .unwrap_or_else(|| panic!("Resource does not exist {}.", std::any::type_name::<T>()))
     }
 
     #[inline]
@@ -301,7 +301,7 @@ impl Resources {
                     NonNull::new_unchecked(resources.stored[index].mutated.get()),
                 )
             })
-            .unwrap_or_else(|| panic!("Resource does not exist {}", std::any::type_name::<T>()))
+            .unwrap_or_else(|| panic!("Resource does not exist {}.", std::any::type_name::<T>()))
     }
 
     #[inline]
@@ -372,7 +372,7 @@ impl<'a, T: 'static> ResourceRef<'a, T> {
             }
         } else {
             panic!(
-                "Failed to acquire shared lock on resource: {}",
+                "Failed to acquire shared lock on resource: {}.",
                 std::any::type_name::<T>()
             );
         }
@@ -432,7 +432,7 @@ impl<'a, T: 'static> ResourceRefMut<'a, T> {
             }
         } else {
             panic!(
-                "Failed to acquire exclusive lock on resource: {}",
+                "Failed to acquire exclusive lock on resource: {}.",
                 std::any::type_name::<T>()
             );
         }
diff --git a/crates/bevy_ecs/src/schedule/mod.rs b/crates/bevy_ecs/src/schedule/mod.rs
index be45138cb8e8e..9f70eda52e6e6 100644
--- a/crates/bevy_ecs/src/schedule/mod.rs
+++ b/crates/bevy_ecs/src/schedule/mod.rs
@@ -1,6 +1,521 @@
-mod parallel_executor;
-#[allow(clippy::module_inception)]
-mod schedule;
+mod stage;
+mod stage_executor;
+mod state;
 
-pub use parallel_executor::*;
-pub use schedule::*;
+pub use stage::*;
+pub use stage_executor::*;
+pub use state::*;
+
+use crate::{IntoSystem, Resources, System, World};
+use bevy_utils::HashMap;
+
+#[derive(Default)]
+pub struct Schedule {
+    stages: HashMap<String, Box<dyn Stage>>,
+    stage_order: Vec<String>,
+    run_criteria: Option<Box<dyn System<In = (), Out = ShouldRun>>>,
+    run_criteria_initialized: bool,
+}
+
+impl Schedule {
+    pub fn with_stage<S: Stage>(mut self, name: &str, stage: S) -> Self {
+        self.add_stage(name, stage);
+        self
+    }
+
+    pub fn with_stage_after<S: Stage>(mut self, target: &str, name: &str, stage: S) -> Self {
+        self.add_stage_after(target, name, stage);
+        self
+    }
+
+    pub fn with_stage_before<S: Stage>(mut self, target: &str, name: &str, stage: S) -> Self {
+        self.add_stage_before(target, name, stage);
+        self
+    }
+
+    pub fn with_run_criteria<S: System<In = (), Out = ShouldRun>>(mut self, system: S) -> Self {
+        self.set_run_criteria(system);
+        self
+    }
+
+    pub fn with_system_in_stage<S: System<In = (), Out = ()>>(
+        mut self,
+        stage_name: &'static str,
+        system: S,
+    ) -> Self {
+        self.add_system_to_stage(stage_name, system);
+        self
+    }
+
+    pub fn set_run_criteria<S: System<In = (), Out = ShouldRun>>(
+        &mut self,
+        system: S,
+    ) -> &mut Self {
+        self.run_criteria = Some(Box::new(system.system()));
+        self.run_criteria_initialized = false;
+        self
+    }
+
+    pub fn add_stage<S: Stage>(&mut self, name: &str, stage: S) -> &mut Self {
+        self.stage_order.push(name.to_string());
+        self.stages.insert(name.to_string(), Box::new(stage));
+        self
+    }
+
+    pub fn add_stage_after<S: Stage>(&mut self, target: &str, name: &str, stage: S) -> &mut Self {
+        if self.stages.get(name).is_some() {
+            panic!("Stage already exists: {}.", name);
+        }
+
+        let target_index = self
+            .stage_order
+            .iter()
+            .enumerate()
+            .find(|(_i, stage_name)| *stage_name == target)
+            .map(|(i, _)| i)
+            .unwrap_or_else(|| panic!("Target stage does not exist: {}.", target));
+
+        self.stages.insert(name.to_string(), Box::new(stage));
+        self.stage_order.insert(target_index + 1, name.to_string());
+        self
+    }
+
+    pub fn add_stage_before<S: Stage>(&mut self, target: &str, name: &str, stage: S) -> &mut Self {
+        if self.stages.get(name).is_some() {
+            panic!("Stage already exists: {}.", name);
+        }
+
+        let target_index = self
+            .stage_order
+            .iter()
+            .enumerate()
+            .find(|(_i, stage_name)| *stage_name == target)
+            .map(|(i, _)| i)
+            .unwrap_or_else(|| panic!("Target stage does not exist: {}.", target));
+
+        self.stages.insert(name.to_string(), Box::new(stage));
+        self.stage_order.insert(target_index, name.to_string());
+        self
+    }
+
+    pub fn add_system_to_stage<S: System<In = (), Out = ()>>(
+        &mut self,
+        stage_name: &'static str,
+        system: S,
+    ) -> &mut Self {
+        let stage = self
+            .get_stage_mut::<SystemStage>(stage_name)
+            .unwrap_or_else(|| {
+                panic!(
+                    "Stage '{}' does not exist or is not a SystemStage",
+                    stage_name
+                )
+            });
+        stage.add_system(system.system());
+        self
+    }
+
+    pub fn stage<T: Stage, F: FnOnce(&mut T) -> &mut T>(
+        &mut self,
+        name: &str,
+        func: F,
+    ) -> &mut Self {
+        let stage = self
+            .get_stage_mut::<T>(name)
+            .unwrap_or_else(|| panic!("stage '{}' does not exist or is the wrong type", name));
+        func(stage);
+        self
+    }
+
+    pub fn get_stage<T: Stage>(&self, name: &str) -> Option<&T> {
+        self.stages
+            .get(name)
+            .and_then(|stage| stage.downcast_ref::<T>())
+    }
+
+    pub fn get_stage_mut<T: Stage>(&mut self, name: &str) -> Option<&mut T> {
+        self.stages
+            .get_mut(name)
+            .and_then(|stage| stage.downcast_mut::<T>())
+    }
+
+    pub fn run_once(&mut self, world: &mut World, resources: &mut Resources) {
+        for name in self.stage_order.iter() {
+            #[cfg(feature = "trace")]
+            let stage_span = bevy_utils::tracing::info_span!("stage", name = name.as_str());
+            #[cfg(feature = "trace")]
+            let _stage_guard = stage_span.enter();
+            let stage = self.stages.get_mut(name).unwrap();
+            stage.run(world, resources);
+        }
+    }
+
+    /// Shorthand for [Schedule::initialize] and [Schedule::run]
+    pub fn initialize_and_run(&mut self, world: &mut World, resources: &mut Resources) {
+        self.initialize(world, resources);
+        self.run(world, resources);
+    }
+}
+
+impl Stage for Schedule {
+    fn initialize(&mut self, world: &mut World, resources: &mut Resources) {
+        if let Some(ref mut run_criteria) = self.run_criteria {
+            if !self.run_criteria_initialized {
+                run_criteria.initialize(world, resources);
+                self.run_criteria_initialized = true;
+            }
+        }
+
+        for name in self.stage_order.iter() {
+            let stage = self.stages.get_mut(name).unwrap();
+            stage.initialize(world, resources);
+        }
+    }
+
+    fn run(&mut self, world: &mut World, resources: &mut Resources) {
+        loop {
+            let should_run = if let Some(ref mut run_criteria) = self.run_criteria {
+                let should_run = run_criteria.run((), world, resources);
+                run_criteria.run_thread_local(world, resources);
+                // don't run when no result is returned or false is returned
+                should_run.unwrap_or(ShouldRun::No)
+            } else {
+                ShouldRun::Yes
+            };
+
+            match should_run {
+                ShouldRun::No => return,
+                ShouldRun::Yes => {
+                    self.run_once(world, resources);
+                    return;
+                }
+                ShouldRun::YesAndLoop => {
+                    self.run_once(world, resources);
+                }
+            }
+        }
+    }
+}
+
+pub fn clear_trackers_system(world: &mut World, resources: &mut Resources) {
+    world.clear_trackers();
+    resources.clear_trackers();
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{
+        resource::{Res, ResMut, Resources},
+        schedule::{ParallelSystemStageExecutor, Schedule, SystemStage},
+        system::Query,
+        Commands, Entity, IntoSystem, World,
+    };
+    use bevy_tasks::{ComputeTaskPool, TaskPool};
+    use fixedbitset::FixedBitSet;
+    use parking_lot::Mutex;
+    use std::{collections::HashSet, sync::Arc};
+
+    #[derive(Default)]
+    struct CompletedSystems {
+        completed_systems: Arc<Mutex<HashSet<&'static str>>>,
+    }
+
+    #[test]
+    fn cross_stage_archetype_change_prepare() {
+        let mut world = World::new();
+        let mut resources = Resources::default();
+        resources.insert(ComputeTaskPool(TaskPool::default()));
+
+        fn insert(commands: &mut Commands) {
+            commands.spawn((1u32,));
+        }
+
+        fn read(query: Query<&u32>, entities: Query<Entity>) {
+            for entity in &mut entities.iter() {
+                // query.get() does a "system permission check" that will fail if the entity is from a
+                // new archetype which hasnt been "prepared yet"
+                query.get_component::<u32>(entity).unwrap();
+            }
+
+            assert_eq!(1, entities.iter().count());
+        }
+
+        let mut schedule = Schedule::default();
+        let mut pre_archetype_change = SystemStage::parallel();
+        pre_archetype_change.add_system(insert.system());
+        schedule.add_stage("PreArchetypeChange", pre_archetype_change);
+        let mut post_archetype_change = SystemStage::parallel();
+        post_archetype_change.add_system(read.system());
+        schedule.add_stage("PostArchetypeChange", post_archetype_change);
+
+        schedule.initialize_and_run(&mut world, &mut resources);
+    }
+
+    #[test]
+    fn intra_stage_archetype_change_prepare() {
+        let mut world = World::new();
+        let mut resources = Resources::default();
+        resources.insert(ComputeTaskPool(TaskPool::default()));
+
+        fn insert(world: &mut World, _resources: &mut Resources) {
+            world.spawn((1u32,));
+        }
+
+        fn read(query: Query<&u32>, entities: Query<Entity>) {
+            for entity in &mut entities.iter() {
+                // query.get() does a "system permission check" that will fail if the entity is from a
+                // new archetype which hasnt been "prepared yet"
+                query.get_component::<u32>(entity).unwrap();
+            }
+
+            assert_eq!(1, entities.iter().count());
+        }
+
+        let mut update = SystemStage::parallel();
+        update.add_system(insert.system());
+        update.add_system(read.system());
+
+        let mut schedule = Schedule::default();
+        schedule.add_stage("update", update);
+
+        schedule.initialize_and_run(&mut world, &mut resources);
+    }
+
+    #[test]
+    fn schedule() {
+        let mut world = World::new();
+        let mut resources = Resources::default();
+        resources.insert(ComputeTaskPool(TaskPool::default()));
+        resources.insert(CompletedSystems::default());
+        resources.insert(1.0f64);
+        resources.insert(2isize);
+
+        world.spawn((1.0f32,));
+        world.spawn((1u32, 1u64));
+        world.spawn((2u32,));
+
+        let mut stage_a = SystemStage::parallel(); // component queries
+        let mut stage_b = SystemStage::parallel(); // thread local
+        let mut stage_c = SystemStage::parallel(); // resources
+
+        // A system names
+        const READ_U32_SYSTEM_NAME: &str = "read_u32";
+        const WRITE_FLOAT_SYSTEM_NAME: &str = "write_float";
+        const READ_U32_WRITE_U64_SYSTEM_NAME: &str = "read_u32_write_u64";
+        const READ_U64_SYSTEM_NAME: &str = "read_u64";
+
+        // B system names
+        const WRITE_U64_SYSTEM_NAME: &str = "write_u64";
+        const THREAD_LOCAL_SYSTEM_SYSTEM_NAME: &str = "thread_local_system";
+        const WRITE_F32_SYSTEM_NAME: &str = "write_f32";
+
+        // C system names
+        const READ_F64_RES_SYSTEM_NAME: &str = "read_f64_res";
+        const READ_ISIZE_RES_SYSTEM_NAME: &str = "read_isize_res";
+        const READ_ISIZE_WRITE_F64_RES_SYSTEM_NAME: &str = "read_isize_write_f64_res";
+        const WRITE_F64_RES_SYSTEM_NAME: &str = "write_f64_res";
+
+        // A systems
+
+        fn read_u32(completed_systems: Res<CompletedSystems>, _query: Query<&u32>) {
+            let mut completed_systems = completed_systems.completed_systems.lock();
+            completed_systems.insert(READ_U32_SYSTEM_NAME);
+        }
+
+        fn write_float(completed_systems: Res<CompletedSystems>, _query: Query<&f32>) {
+            let mut completed_systems = completed_systems.completed_systems.lock();
+            completed_systems.insert(WRITE_FLOAT_SYSTEM_NAME);
+        }
+
+        fn read_u32_write_u64(
+            completed_systems: Res<CompletedSystems>,
+            _query: Query<(&u32, &mut u64)>,
+        ) {
+            let mut completed_systems = completed_systems.completed_systems.lock();
+            assert!(!completed_systems.contains(READ_U64_SYSTEM_NAME));
+            completed_systems.insert(READ_U32_WRITE_U64_SYSTEM_NAME);
+        }
+
+        fn read_u64(completed_systems: Res<CompletedSystems>, _query: Query<&u64>) {
+            let mut completed_systems = completed_systems.completed_systems.lock();
+            assert!(completed_systems.contains(READ_U32_WRITE_U64_SYSTEM_NAME));
+            assert!(!completed_systems.contains(WRITE_U64_SYSTEM_NAME));
+            completed_systems.insert(READ_U64_SYSTEM_NAME);
+        }
+
+        stage_a.add_system(read_u32.system());
+        stage_a.add_system(write_float.system());
+        stage_a.add_system(read_u32_write_u64.system());
+        stage_a.add_system(read_u64.system());
+
+        // B systems
+
+        fn write_u64(completed_systems: Res<CompletedSystems>, _query: Query<&mut u64>) {
+            let mut completed_systems = completed_systems.completed_systems.lock();
+            assert!(completed_systems.contains(READ_U64_SYSTEM_NAME));
+            assert!(!completed_systems.contains(THREAD_LOCAL_SYSTEM_SYSTEM_NAME));
+            assert!(!completed_systems.contains(WRITE_F32_SYSTEM_NAME));
+            completed_systems.insert(WRITE_U64_SYSTEM_NAME);
+        }
+
+        fn thread_local_system(_world: &mut World, resources: &mut Resources) {
+            let completed_systems = resources.get::<CompletedSystems>().unwrap();
+            let mut completed_systems = completed_systems.completed_systems.lock();
+            assert!(completed_systems.contains(WRITE_U64_SYSTEM_NAME));
+            assert!(!completed_systems.contains(WRITE_F32_SYSTEM_NAME));
+            completed_systems.insert(THREAD_LOCAL_SYSTEM_SYSTEM_NAME);
+        }
+
+        fn write_f32(completed_systems: Res<CompletedSystems>, _query: Query<&mut f32>) {
+            let mut completed_systems = completed_systems.completed_systems.lock();
+            assert!(completed_systems.contains(WRITE_U64_SYSTEM_NAME));
+            assert!(completed_systems.contains(THREAD_LOCAL_SYSTEM_SYSTEM_NAME));
+            assert!(!completed_systems.contains(READ_F64_RES_SYSTEM_NAME));
+            completed_systems.insert(WRITE_F32_SYSTEM_NAME);
+        }
+
+        stage_b.add_system(write_u64.system());
+        stage_b.add_system(thread_local_system.system());
+        stage_b.add_system(write_f32.system());
+
+        // C systems
+
+        fn read_f64_res(completed_systems: Res<CompletedSystems>, _f64_res: Res<f64>) {
+            let mut completed_systems = completed_systems.completed_systems.lock();
+            assert!(completed_systems.contains(WRITE_F32_SYSTEM_NAME));
+            assert!(!completed_systems.contains(READ_ISIZE_WRITE_F64_RES_SYSTEM_NAME));
+            assert!(!completed_systems.contains(WRITE_F64_RES_SYSTEM_NAME));
+            completed_systems.insert(READ_F64_RES_SYSTEM_NAME);
+        }
+
+        fn read_isize_res(completed_systems: Res<CompletedSystems>, _isize_res: Res<isize>) {
+            let mut completed_systems = completed_systems.completed_systems.lock();
+            completed_systems.insert(READ_ISIZE_RES_SYSTEM_NAME);
+        }
+
+        fn read_isize_write_f64_res(
+            completed_systems: Res<CompletedSystems>,
+            _isize_res: Res<isize>,
+            _f64_res: ResMut<f64>,
+        ) {
+            let mut completed_systems = completed_systems.completed_systems.lock();
+            assert!(completed_systems.contains(READ_F64_RES_SYSTEM_NAME));
+            assert!(!completed_systems.contains(WRITE_F64_RES_SYSTEM_NAME));
+            completed_systems.insert(READ_ISIZE_WRITE_F64_RES_SYSTEM_NAME);
+        }
+
+        fn write_f64_res(completed_systems: Res<CompletedSystems>, _f64_res: ResMut<f64>) {
+            let mut completed_systems = completed_systems.completed_systems.lock();
+            assert!(completed_systems.contains(READ_F64_RES_SYSTEM_NAME));
+            assert!(completed_systems.contains(READ_ISIZE_WRITE_F64_RES_SYSTEM_NAME));
+            completed_systems.insert(WRITE_F64_RES_SYSTEM_NAME);
+        }
+
+        stage_c.add_system(read_f64_res.system());
+        stage_c.add_system(read_isize_res.system());
+        stage_c.add_system(read_isize_write_f64_res.system());
+        stage_c.add_system(write_f64_res.system());
+
+        fn run_and_validate(schedule: &mut Schedule, world: &mut World, resources: &mut Resources) {
+            schedule.initialize_and_run(world, resources);
+
+            let stage_a = schedule.get_stage::<SystemStage>("a").unwrap();
+            let stage_b = schedule.get_stage::<SystemStage>("b").unwrap();
+            let stage_c = schedule.get_stage::<SystemStage>("c").unwrap();
+
+            let a_executor = stage_a
+                .get_executor::<ParallelSystemStageExecutor>()
+                .unwrap();
+            let b_executor = stage_b
+                .get_executor::<ParallelSystemStageExecutor>()
+                .unwrap();
+            let c_executor = stage_c
+                .get_executor::<ParallelSystemStageExecutor>()
+                .unwrap();
+
+            assert_eq!(
+                a_executor.system_dependents(),
+                vec![vec![], vec![], vec![3], vec![]]
+            );
+            assert_eq!(
+                b_executor.system_dependents(),
+                vec![vec![1], vec![2], vec![]]
+            );
+            assert_eq!(
+                c_executor.system_dependents(),
+                vec![vec![2, 3], vec![], vec![3], vec![]]
+            );
+
+            let stage_a_len = a_executor.system_dependencies().len();
+            let mut read_u64_deps = FixedBitSet::with_capacity(stage_a_len);
+            read_u64_deps.insert(2);
+
+            assert_eq!(
+                a_executor.system_dependencies(),
+                vec![
+                    FixedBitSet::with_capacity(stage_a_len),
+                    FixedBitSet::with_capacity(stage_a_len),
+                    FixedBitSet::with_capacity(stage_a_len),
+                    read_u64_deps,
+                ]
+            );
+
+            let stage_b_len = b_executor.system_dependencies().len();
+            let mut thread_local_deps = FixedBitSet::with_capacity(stage_b_len);
+            thread_local_deps.insert(0);
+            let mut write_f64_deps = FixedBitSet::with_capacity(stage_b_len);
+            write_f64_deps.insert(1);
+            assert_eq!(
+                b_executor.system_dependencies(),
+                vec![
+                    FixedBitSet::with_capacity(stage_b_len),
+                    thread_local_deps,
+                    write_f64_deps
+                ]
+            );
+
+            let stage_c_len = c_executor.system_dependencies().len();
+            let mut read_isize_write_f64_res_deps = FixedBitSet::with_capacity(stage_c_len);
+            read_isize_write_f64_res_deps.insert(0);
+            let mut write_f64_res_deps = FixedBitSet::with_capacity(stage_c_len);
+            write_f64_res_deps.insert(0);
+            write_f64_res_deps.insert(2);
+            assert_eq!(
+                c_executor.system_dependencies(),
+                vec![
+                    FixedBitSet::with_capacity(stage_c_len),
+                    FixedBitSet::with_capacity(stage_c_len),
+                    read_isize_write_f64_res_deps,
+                    write_f64_res_deps
+                ]
+            );
+
+            let completed_systems = resources.get::<CompletedSystems>().unwrap();
+            assert_eq!(
+                completed_systems.completed_systems.lock().len(),
+                11,
+                "completed_systems should have been incremented once for each system"
+            );
+        }
+
+        let mut schedule = Schedule::default();
+        schedule.add_stage("a", stage_a);
+        schedule.add_stage("b", stage_b);
+        schedule.add_stage("c", stage_c);
+
+        // Test the "clean start" case
+        run_and_validate(&mut schedule, &mut world, &mut resources);
+
+        // Stress test the "continue running" case
+        for _ in 0..1000 {
+            // run again (with completed_systems reset) to ensure executor works correctly across runs
+            resources
+                .get::<CompletedSystems>()
+                .unwrap()
+                .completed_systems
+                .lock()
+                .clear();
+            run_and_validate(&mut schedule, &mut world, &mut resources);
+        }
+    }
+}
diff --git a/crates/bevy_ecs/src/schedule/schedule.rs b/crates/bevy_ecs/src/schedule/schedule.rs
deleted file mode 100644
index 4a6f4d20e29c7..0000000000000
--- a/crates/bevy_ecs/src/schedule/schedule.rs
+++ /dev/null
@@ -1,242 +0,0 @@
-use crate::{
-    resource::Resources,
-    system::{System, SystemId, ThreadLocalExecution},
-    IntoSystem, World,
-};
-use bevy_utils::{HashMap, HashSet};
-use std::{borrow::Cow, fmt};
-
-/// An ordered collection of stages, which each contain an ordered list of [System]s.
-/// Schedules are essentially the "execution plan" for an App's systems.
-/// They are run on a given [World] and [Resources] reference.
-#[derive(Default)]
-pub struct Schedule {
-    pub(crate) stages: HashMap<Cow<'static, str>, Vec<Box<dyn System<Input = (), Output = ()>>>>,
-    pub(crate) stage_order: Vec<Cow<'static, str>>,
-    pub(crate) system_ids: HashSet<SystemId>,
-    generation: usize,
-    last_initialize_generation: usize,
-}
-
-impl fmt::Debug for Schedule {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        writeln!(f, "Schedule {{")?;
-
-        let stages = self
-            .stage_order
-            .iter()
-            .map(|s| (s, self.stages[s].iter().map(|s| (s.name(), s.id()))));
-
-        for (stage, syss) in stages {
-            writeln!(f, "    Stage \"{}\"", stage)?;
-
-            for (name, id) in syss {
-                writeln!(f, "        System {{ name: \"{}\", id: {:?} }}", name, id)?;
-            }
-        }
-
-        writeln!(f, "}}")
-    }
-}
-
-impl Schedule {
-    pub fn add_stage(&mut self, stage: impl Into<Cow<'static, str>>) {
-        let stage: Cow<str> = stage.into();
-        if self.stages.get(&stage).is_some() {
-            panic!("Stage already exists: {}", stage);
-        } else {
-            self.stages.insert(stage.clone(), Vec::new());
-            self.stage_order.push(stage);
-        }
-    }
-
-    pub fn add_stage_after(
-        &mut self,
-        target: impl Into<Cow<'static, str>>,
-        stage: impl Into<Cow<'static, str>>,
-    ) {
-        let target: Cow<str> = target.into();
-        let stage: Cow<str> = stage.into();
-        if self.stages.get(&stage).is_some() {
-            panic!("Stage already exists: {}", stage);
-        }
-
-        let target_index = self
-            .stage_order
-            .iter()
-            .enumerate()
-            .find(|(_i, stage)| **stage == target)
-            .map(|(i, _)| i)
-            .unwrap_or_else(|| panic!("Target stage does not exist: {}", target));
-
-        self.stages.insert(stage.clone(), Vec::new());
-        self.stage_order.insert(target_index + 1, stage);
-    }
-
-    pub fn add_stage_before(
-        &mut self,
-        target: impl Into<Cow<'static, str>>,
-        stage: impl Into<Cow<'static, str>>,
-    ) {
-        let target: Cow<str> = target.into();
-        let stage: Cow<str> = stage.into();
-        if self.stages.get(&stage).is_some() {
-            panic!("Stage already exists: {}", stage);
-        }
-
-        let target_index = self
-            .stage_order
-            .iter()
-            .enumerate()
-            .find(|(_i, stage)| **stage == target)
-            .map(|(i, _)| i)
-            .unwrap_or_else(|| panic!("Target stage does not exist: {}", target));
-
-        self.stages.insert(stage.clone(), Vec::new());
-        self.stage_order.insert(target_index, stage);
-    }
-
-    pub fn add_system_to_stage<S, Params, IntoS>(
-        &mut self,
-        stage_name: impl Into<Cow<'static, str>>,
-        system: IntoS,
-    ) -> &mut Self
-    where
-        S: System<Input = (), Output = ()>,
-        IntoS: IntoSystem<Params, S>,
-    {
-        self.add_system_to_stage_internal(stage_name.into(), Box::new(system.system()));
-        self
-    }
-
-    pub fn add_boxed_system_to_stage(
-        &mut self,
-        stage_name: impl Into<Cow<'static, str>>,
-        system: Box<dyn System<Input = (), Output = ()>>,
-    ) {
-        self.add_system_to_stage_internal(stage_name.into(), system);
-    }
-
-    fn add_system_to_stage_internal(
-        &mut self,
-        stage_name: Cow<'static, str>,
-        system: Box<dyn System<Input = (), Output = ()>>,
-    ) {
-        let systems = self
-            .stages
-            .get_mut(&stage_name)
-            .unwrap_or_else(|| panic!("Stage does not exist: {}", stage_name));
-        if self.system_ids.contains(&system.id()) {
-            panic!(
-                "System with id {:?} ({}) already exists",
-                system.id(),
-                system.name()
-            );
-        }
-        self.system_ids.insert(system.id());
-        systems.push(system);
-
-        self.generation += 1;
-    }
-
-    pub fn add_system_to_stage_front<S, Params, IntoS>(
-        &mut self,
-        stage_name: impl Into<Cow<'static, str>>,
-        system: IntoS,
-    ) -> &mut Self
-    where
-        S: System<Input = (), Output = ()>,
-        IntoS: IntoSystem<Params, S>,
-    {
-        self.add_system_to_stage_front_internal(stage_name.into(), Box::new(system.system()));
-        self
-    }
-
-    fn add_system_to_stage_front_internal(
-        &mut self,
-        stage_name: Cow<'static, str>,
-        system: Box<dyn System<Input = (), Output = ()>>,
-    ) {
-        let systems = self
-            .stages
-            .get_mut(&stage_name)
-            .unwrap_or_else(|| panic!("Stage does not exist: {}", stage_name));
-        if self.system_ids.contains(&system.id()) {
-            panic!(
-                "System with id {:?} ({}) already exists",
-                system.id(),
-                system.name()
-            );
-        }
-        self.system_ids.insert(system.id());
-        systems.insert(0, system);
-
-        self.generation += 1;
-    }
-
-    pub fn run(&mut self, world: &mut World, resources: &mut Resources) {
-        for stage_name in self.stage_order.iter() {
-            if let Some(stage_systems) = self.stages.get_mut(stage_name) {
-                for system in stage_systems.iter_mut() {
-                    system.update(world);
-                    match system.thread_local_execution() {
-                        ThreadLocalExecution::NextFlush => {
-                            system.run((), world, resources);
-                        }
-                        ThreadLocalExecution::Immediate => {
-                            system.run((), world, resources);
-                            // NOTE: when this is made parallel a full sync is required here
-                            system.run_thread_local(world, resources);
-                        }
-                    }
-                }
-
-                // "flush"
-                // NOTE: when this is made parallel a full sync is required here
-                for system in stage_systems.iter_mut() {
-                    match system.thread_local_execution() {
-                        ThreadLocalExecution::NextFlush => {
-                            system.run_thread_local(world, resources)
-                        }
-                        ThreadLocalExecution::Immediate => { /* already ran immediate */ }
-                    }
-                }
-            }
-        }
-
-        world.clear_trackers();
-        resources.clear_trackers();
-    }
-
-    // TODO: move this code to ParallelExecutor
-    pub fn initialize(&mut self, world: &mut World, resources: &mut Resources) {
-        if self.last_initialize_generation == self.generation {
-            return;
-        }
-
-        for stage in self.stages.values_mut() {
-            for system in stage.iter_mut() {
-                system.initialize(world, resources);
-            }
-        }
-
-        self.last_initialize_generation = self.generation;
-    }
-
-    pub fn generation(&self) -> usize {
-        self.generation
-    }
-
-    pub fn run_on_systems(
-        &mut self,
-        mut func: impl FnMut(&mut dyn System<Input = (), Output = ()>),
-    ) {
-        for stage_name in self.stage_order.iter() {
-            if let Some(stage_systems) = self.stages.get_mut(stage_name) {
-                for system in stage_systems.iter_mut() {
-                    func(&mut **system);
-                }
-            }
-        }
-    }
-}
diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
new file mode 100644
index 0000000000000..57e1eab31310b
--- /dev/null
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -0,0 +1,223 @@
+use std::{any::TypeId, borrow::Cow};
+
+use crate::{
+    ArchetypeComponent, Resources, System, SystemId, ThreadLocalExecution, TypeAccess, World,
+};
+use bevy_utils::HashSet;
+use downcast_rs::{impl_downcast, Downcast};
+
+use super::{ParallelSystemStageExecutor, SerialSystemStageExecutor, SystemStageExecutor};
+
+pub enum StageError {
+    SystemAlreadyExists(SystemId),
+}
+
+pub trait Stage: Downcast + Send + Sync {
+    /// Stages can perform setup here. Initialize should be called for every stage before calling [Stage::run]. Initialize will
+    /// be called once per update, so internally this should avoid re-doing work where possible.
+    fn initialize(&mut self, world: &mut World, resources: &mut Resources);
+
+    /// Runs the stage. This happens once per update (after [Stage::initialize] is called).
+    fn run(&mut self, world: &mut World, resources: &mut Resources);
+}
+
+impl_downcast!(Stage);
+
+pub struct SystemStage {
+    systems: Vec<Box<dyn System<In = (), Out = ()>>>,
+    system_ids: HashSet<SystemId>,
+    executor: Box<dyn SystemStageExecutor>,
+    run_criteria: Option<Box<dyn System<In = (), Out = ShouldRun>>>,
+    run_criteria_initialized: bool,
+    uninitialized_systems: Vec<usize>,
+    unexecuted_systems: Vec<usize>,
+}
+
+impl SystemStage {
+    pub fn new(executor: Box<dyn SystemStageExecutor>) -> Self {
+        SystemStage {
+            executor,
+            run_criteria: None,
+            run_criteria_initialized: false,
+            systems: Default::default(),
+            system_ids: Default::default(),
+            uninitialized_systems: Default::default(),
+            unexecuted_systems: Default::default(),
+        }
+    }
+
+    pub fn single<S: System<In = (), Out = ()>>(system: S) -> Self {
+        Self::serial().with_system(system)
+    }
+
+    pub fn serial() -> Self {
+        Self::new(Box::new(SerialSystemStageExecutor::default()))
+    }
+
+    pub fn parallel() -> Self {
+        Self::new(Box::new(ParallelSystemStageExecutor::default()))
+    }
+
+    pub fn with_system<S: System<In = (), Out = ()>>(mut self, system: S) -> Self {
+        self.add_system_boxed(Box::new(system));
+        self
+    }
+
+    pub fn with_run_criteria<S: System<In = (), Out = ShouldRun>>(mut self, system: S) -> Self {
+        self.run_criteria = Some(Box::new(system));
+        self.run_criteria_initialized = false;
+        self
+    }
+
+    pub fn add_system<S: System<In = (), Out = ()>>(&mut self, system: S) -> &mut Self {
+        self.add_system_boxed(Box::new(system));
+        self
+    }
+
+    pub fn add_system_boxed(&mut self, system: Box<dyn System<In = (), Out = ()>>) -> &mut Self {
+        if self.system_ids.contains(&system.id()) {
+            panic!(
+                "System with id {:?} ({}) already exists",
+                system.id(),
+                system.name()
+            );
+        }
+        self.system_ids.insert(system.id());
+        self.unexecuted_systems.push(self.systems.len());
+        self.uninitialized_systems.push(self.systems.len());
+        self.systems.push(system);
+        self
+    }
+
+    pub fn get_executor<T: SystemStageExecutor>(&self) -> Option<&T> {
+        self.executor.downcast_ref()
+    }
+
+    pub fn get_executor_mut<T: SystemStageExecutor>(&mut self) -> Option<&mut T> {
+        self.executor.downcast_mut()
+    }
+
+    pub fn run_once(&mut self, world: &mut World, resources: &mut Resources) {
+        let unexecuted_systems = std::mem::take(&mut self.unexecuted_systems);
+        self.executor
+            .execute_stage(&mut self.systems, &unexecuted_systems, world, resources);
+    }
+}
+
+impl Stage for SystemStage {
+    fn initialize(&mut self, world: &mut World, resources: &mut Resources) {
+        if let Some(ref mut run_criteria) = self.run_criteria {
+            if !self.run_criteria_initialized {
+                run_criteria.initialize(world, resources);
+                self.run_criteria_initialized = true;
+            }
+        }
+
+        let uninitialized_systems = std::mem::take(&mut self.uninitialized_systems);
+        for system_index in uninitialized_systems.iter() {
+            self.systems[*system_index].initialize(world, resources);
+        }
+    }
+
+    fn run(&mut self, world: &mut World, resources: &mut Resources) {
+        loop {
+            let should_run = if let Some(ref mut run_criteria) = self.run_criteria {
+                let should_run = run_criteria.run((), world, resources);
+                run_criteria.run_thread_local(world, resources);
+                // don't run when no result is returned or false is returned
+                should_run.unwrap_or(ShouldRun::No)
+            } else {
+                ShouldRun::Yes
+            };
+
+            match should_run {
+                ShouldRun::No => return,
+                ShouldRun::Yes => {
+                    self.run_once(world, resources);
+                    return;
+                }
+                ShouldRun::YesAndLoop => {
+                    self.run_once(world, resources);
+                }
+            }
+        }
+    }
+}
+
+pub enum ShouldRun {
+    /// No, the system should not run
+    No,
+    /// Yes, the system should run
+    Yes,
+    /// Yes, the system should run and after running, the criteria should be checked again.
+    YesAndLoop,
+}
+
+impl<S: System<In = (), Out = ()>> From<S> for SystemStage {
+    fn from(system: S) -> Self {
+        SystemStage::single(system)
+    }
+}
+
+pub struct RunOnce {
+    ran: bool,
+    system_id: SystemId,
+    resource_access: TypeAccess<TypeId>,
+    archetype_access: TypeAccess<ArchetypeComponent>,
+}
+
+impl Default for RunOnce {
+    fn default() -> Self {
+        Self {
+            ran: false,
+            system_id: SystemId::new(),
+            resource_access: Default::default(),
+            archetype_access: Default::default(),
+        }
+    }
+}
+
+impl System for RunOnce {
+    type In = ();
+    type Out = ShouldRun;
+
+    fn name(&self) -> Cow<'static, str> {
+        Cow::Borrowed(std::any::type_name::<RunOnce>())
+    }
+
+    fn id(&self) -> SystemId {
+        self.system_id
+    }
+
+    fn update(&mut self, _world: &World) {}
+
+    fn archetype_component_access(&self) -> &TypeAccess<ArchetypeComponent> {
+        &self.archetype_access
+    }
+
+    fn resource_access(&self) -> &TypeAccess<TypeId> {
+        &self.resource_access
+    }
+
+    fn thread_local_execution(&self) -> ThreadLocalExecution {
+        ThreadLocalExecution::Immediate
+    }
+
+    unsafe fn run_unsafe(
+        &mut self,
+        _input: Self::In,
+        _world: &World,
+        _resources: &Resources,
+    ) -> Option<Self::Out> {
+        Some(if self.ran {
+            ShouldRun::No
+        } else {
+            self.ran = true;
+            ShouldRun::Yes
+        })
+    }
+
+    fn run_thread_local(&mut self, _world: &mut World, _resources: &mut Resources) {}
+
+    fn initialize(&mut self, _world: &mut World, _resources: &mut Resources) {}
+}
diff --git a/crates/bevy_ecs/src/schedule/parallel_executor.rs b/crates/bevy_ecs/src/schedule/stage_executor.rs
similarity index 54%
rename from crates/bevy_ecs/src/schedule/parallel_executor.rs
rename to crates/bevy_ecs/src/schedule/stage_executor.rs
index 94a10e872beeb..b59a58aa457dc 100644
--- a/crates/bevy_ecs/src/schedule/parallel_executor.rs
+++ b/crates/bevy_ecs/src/schedule/stage_executor.rs
@@ -1,112 +1,66 @@
-use super::Schedule;
-use crate::{
-    resource::Resources,
-    system::{System, ThreadLocalExecution},
-    ArchetypesGeneration, TypeAccess, World,
-};
+use std::ops::Range;
+
 use bevy_tasks::{ComputeTaskPool, CountdownEvent, TaskPool};
-#[cfg(feature = "trace")]
-use bevy_utils::tracing::info_span;
 use bevy_utils::tracing::trace;
+use downcast_rs::{impl_downcast, Downcast};
 use fixedbitset::FixedBitSet;
-use std::ops::Range;
-
-/// Executes each schedule stage in parallel by analyzing system dependencies.
-/// System execution order is undefined except under the following conditions:
-/// * systems in earlier stages run before systems in later stages
-/// * in a given stage, systems that mutate [archetype+component] X cannot run before systems registered before them that read/write [archetype+component] X
-/// * in a given stage, systems the read [archetype+component] X cannot run before systems registered before them that write [archetype+component] X
-/// * in a given stage, systems that mutate resource Y cannot run before systems registered before them that read/write resource Y
-/// * in a given stage, systems the read resource Y cannot run before systems registered before them that write resource Y
 
-#[derive(Debug)]
-pub struct ParallelExecutor {
-    stages: Vec<ExecutorStage>,
-    last_schedule_generation: usize,
-    clear_trackers: bool,
-}
+use crate::{ArchetypesGeneration, Resources, System, ThreadLocalExecution, TypeAccess, World};
 
-impl Default for ParallelExecutor {
-    fn default() -> Self {
-        Self {
-            stages: Default::default(),
-            last_schedule_generation: usize::MAX, // MAX forces prepare to run the first time
-            clear_trackers: true,
-        }
-    }
+pub trait SystemStageExecutor: Downcast + Send + Sync {
+    fn execute_stage(
+        &mut self,
+        systems: &mut [Box<dyn System<In = (), Out = ()>>],
+        changed_systems: &[usize],
+        world: &mut World,
+        resources: &mut Resources,
+    );
 }
 
-impl ParallelExecutor {
-    pub fn without_tracker_clears() -> Self {
-        Self {
-            clear_trackers: false,
-            ..Default::default()
-        }
-    }
+impl_downcast!(SystemStageExecutor);
 
-    pub fn initialize(&mut self, resources: &mut Resources) {
-        if resources.get::<ComputeTaskPool>().is_none() {
-            resources.insert(ComputeTaskPool(TaskPool::default()));
-        }
-    }
+#[derive(Default)]
+pub struct SerialSystemStageExecutor;
 
-    pub fn run(&mut self, schedule: &mut Schedule, world: &mut World, resources: &mut Resources) {
-        #[cfg(feature = "trace")]
-        let schedule_span = info_span!("schedule");
-        #[cfg(feature = "trace")]
-        let _schedule_guard = schedule_span.enter();
-
-        let schedule_generation = schedule.generation();
-        let schedule_changed = schedule.generation() != self.last_schedule_generation;
-        if schedule_changed {
-            self.stages.clear();
-            self.stages
-                .resize_with(schedule.stage_order.len(), ExecutorStage::default);
-        }
-        for (stage_name, executor_stage) in schedule.stage_order.iter().zip(self.stages.iter_mut())
-        {
-            #[cfg(feature = "trace")]
-            let stage_span = info_span!("stage", name = stage_name.as_ref());
-            #[cfg(feature = "trace")]
-            let _stage_guard = stage_span.enter();
-            if let Some(stage_systems) = schedule.stages.get_mut(stage_name) {
-                executor_stage.run(world, resources, stage_systems, schedule_changed);
+impl SystemStageExecutor for SerialSystemStageExecutor {
+    fn execute_stage(
+        &mut self,
+        systems: &mut [Box<dyn System<In = (), Out = ()>>],
+        _changed_systems: &[usize],
+        world: &mut World,
+        resources: &mut Resources,
+    ) {
+        for system in systems.iter_mut() {
+            system.update(world);
+            match system.thread_local_execution() {
+                ThreadLocalExecution::NextFlush => {
+                    system.run((), world, resources);
+                }
+                ThreadLocalExecution::Immediate => {
+                    system.run((), world, resources);
+                    system.run_thread_local(world, resources);
+                }
             }
         }
 
-        if self.clear_trackers {
-            world.clear_trackers();
-            resources.clear_trackers();
-        }
-
-        self.last_schedule_generation = schedule_generation;
-    }
-
-    pub fn print_order(&self, schedule: &Schedule) {
-        println!("----------------------------");
-        for (stage_name, executor_stage) in schedule.stage_order.iter().zip(self.stages.iter()) {
-            println!("stage {:?}", stage_name);
-            if let Some(stage_systems) = schedule.stages.get(stage_name) {
-                for (i, system) in stage_systems.iter().enumerate() {
-                    println!("  {}-{}", i, system.name());
-                    println!(
-                        "      dependencies({:?})",
-                        executor_stage.system_dependencies[i]
-                            .ones()
-                            .collect::<Vec<usize>>()
-                    );
-                    println!(
-                        "      dependants({:?})",
-                        executor_stage.system_dependents[i]
-                    );
-                }
+        // "flush"
+        for system in systems.iter_mut() {
+            match system.thread_local_execution() {
+                ThreadLocalExecution::NextFlush => system.run_thread_local(world, resources),
+                ThreadLocalExecution::Immediate => { /* already ran immediate */ }
             }
         }
     }
 }
 
-#[derive(Debug, Clone)]
-pub struct ExecutorStage {
+/// Executes the stage in parallel by analyzing system dependencies.
+/// System execution order is undefined except under the following conditions:
+/// * systems in earlier stages run before systems in later stages
+/// * in a given stage, systems that mutate [archetype+component] X cannot run before systems registered before them that read/write [archetype+component] X
+/// * in a given stage, systems the read [archetype+component] X cannot run before systems registered before them that write [archetype+component] X
+/// * in a given stage, systems that mutate resource Y cannot run before systems registered before them that read/write resource Y
+/// * in a given stage, systems the read resource Y cannot run before systems registered before them that write resource Y
+pub struct ParallelSystemStageExecutor {
     /// each system's set of dependencies
     system_dependencies: Vec<FixedBitSet>,
     /// count of each system's dependencies
@@ -124,7 +78,7 @@ pub struct ExecutorStage {
     last_archetypes_generation: ArchetypesGeneration,
 }
 
-impl Default for ExecutorStage {
+impl Default for ParallelSystemStageExecutor {
     fn default() -> Self {
         Self {
             system_dependents: Default::default(),
@@ -138,7 +92,15 @@ impl Default for ExecutorStage {
     }
 }
 
-impl ExecutorStage {
+impl ParallelSystemStageExecutor {
+    pub fn system_dependents(&self) -> &[Vec<usize>] {
+        &self.system_dependents
+    }
+
+    pub fn system_dependencies(&self) -> &[FixedBitSet] {
+        &self.system_dependencies
+    }
+
     /// Sets up state to run the next "batch" of systems. Each batch contains 0..n systems and
     /// optionally a thread local system at the end. After this function runs, a bunch of state
     /// in self will be populated for systems in this batch. Returns the range of systems
@@ -147,8 +109,8 @@ impl ExecutorStage {
     pub fn prepare_to_next_thread_local(
         &mut self,
         world: &World,
-        systems: &mut [Box<dyn System<Input = (), Output = ()>>],
-        schedule_changed: bool,
+        systems: &mut [Box<dyn System<In = (), Out = ()>>],
+        stage_changed: bool,
         next_thread_local_index: usize,
     ) -> Range<usize> {
         // Find the first system in this batch and (if there is one) the thread local system that
@@ -178,7 +140,7 @@ impl ExecutorStage {
         let archetypes_generation_changed =
             self.last_archetypes_generation != world.archetypes_generation();
 
-        if schedule_changed || archetypes_generation_changed {
+        if stage_changed || archetypes_generation_changed {
             // update each system's [archetype+component] access to latest world archetypes
             for system_index in prepare_system_index_range.clone() {
                 systems[system_index].update(world);
@@ -289,7 +251,7 @@ impl ExecutorStage {
                     self.ready_events_of_dependents[system_index].push(
                         self.ready_events[*dependent_system]
                             .as_ref()
-                            .expect("A dependent task should have a non-None ready event")
+                            .expect("A dependent task should have a non-None ready event.")
                             .clone(),
                     );
                 }
@@ -318,7 +280,7 @@ impl ExecutorStage {
             if dependency_count > 0 {
                 self.ready_events[system_index]
                     .as_ref()
-                    .expect("A system with >0 dependency count should have a non-None ready event")
+                    .expect("A system with >0 dependency count should have a non-None ready event.")
                     .reset(dependency_count as isize)
             }
         }
@@ -329,7 +291,7 @@ impl ExecutorStage {
         &self,
         world: &World,
         resources: &Resources,
-        systems: &mut [Box<dyn System<Input = (), Output = ()>>],
+        systems: &mut [Box<dyn System<In = (), Out = ()>>],
         prepared_system_range: Range<usize>,
         compute_pool: &TaskPool,
     ) {
@@ -398,7 +360,10 @@ impl ExecutorStage {
                     // triggering dependents
                     {
                         #[cfg(feature = "trace")]
-                        let system_span = info_span!("system", name = system.name().as_ref());
+                        let system_span = bevy_utils::tracing::info_span!(
+                            "system",
+                            name = system.name().as_ref()
+                        );
                         #[cfg(feature = "trace")]
                         let _system_guard = system_span.enter();
 
@@ -417,21 +382,27 @@ impl ExecutorStage {
             }
         });
     }
+}
 
-    pub fn run(
+impl SystemStageExecutor for ParallelSystemStageExecutor {
+    fn execute_stage(
         &mut self,
+        systems: &mut [Box<dyn System<In = (), Out = ()>>],
+        changed_systems: &[usize],
         world: &mut World,
         resources: &mut Resources,
-        systems: &mut [Box<dyn System<Input = (), Output = ()>>],
-        schedule_changed: bool,
     ) {
         let start_archetypes_generation = world.archetypes_generation();
-        let compute_pool = resources.get_cloned::<ComputeTaskPool>().unwrap();
+        let compute_pool = resources
+            .get_or_insert_with(|| ComputeTaskPool(TaskPool::default()))
+            .clone();
+
+        let stage_changed = !changed_systems.is_empty();
 
         // if the schedule has changed, clear executor state / fill it with new defaults
         // This is mostly zeroing out a bunch of arrays parallel to the systems array. They will get
         // repopulated by prepare_to_next_thread_local() calls
-        if schedule_changed {
+        if stage_changed {
             self.system_dependencies.clear();
             self.system_dependencies
                 .resize_with(systems.len(), || FixedBitSet::with_capacity(systems.len()));
@@ -451,7 +422,8 @@ impl ExecutorStage {
             for (system_index, system) in systems.iter().enumerate() {
                 if system.thread_local_execution() == ThreadLocalExecution::Immediate {
                     #[cfg(feature = "trace")]
-                    let system_span = info_span!("system", name = system.name().as_ref());
+                    let system_span =
+                        bevy_utils::tracing::info_span!("system", name = system.name().as_ref());
                     #[cfg(feature = "trace")]
                     let _system_guard = system_span.enter();
 
@@ -470,7 +442,7 @@ impl ExecutorStage {
             let prepared_system_range = self.prepare_to_next_thread_local(
                 world,
                 systems,
-                schedule_changed,
+                stage_changed,
                 next_thread_local_index,
             );
 
@@ -498,7 +470,10 @@ impl ExecutorStage {
                 let system = systems[thread_local_system_index].as_mut();
 
                 #[cfg(feature = "trace")]
-                let system_span = info_span!("thread_local_system", name = system.name().as_ref());
+                let system_span = bevy_utils::tracing::info_span!(
+                    "thread_local_system",
+                    name = system.name().as_ref()
+                );
                 #[cfg(feature = "trace")]
                 let _system_guard = system_span.enter();
 
@@ -514,7 +489,7 @@ impl ExecutorStage {
             let run_ready_system_index_range = self.prepare_to_next_thread_local(
                 world,
                 systems,
-                schedule_changed,
+                stage_changed,
                 next_thread_local_index,
             );
 
@@ -532,7 +507,8 @@ impl ExecutorStage {
             match system.thread_local_execution() {
                 ThreadLocalExecution::NextFlush => {
                     #[cfg(feature = "trace")]
-                    let system_span = info_span!("system", name = system.name().as_ref());
+                    let system_span =
+                        bevy_utils::tracing::info_span!("system", name = system.name().as_ref());
                     #[cfg(feature = "trace")]
                     let _system_guard = system_span.enter();
                     system.run_thread_local(world, resources);
@@ -548,323 +524,3 @@ impl ExecutorStage {
         }
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::ParallelExecutor;
-    use crate::{
-        resource::{Res, ResMut, Resources},
-        schedule::Schedule,
-        system::Query,
-        Commands, Entity, World,
-    };
-    use bevy_tasks::{ComputeTaskPool, TaskPool};
-    use fixedbitset::FixedBitSet;
-    use parking_lot::Mutex;
-    use std::{collections::HashSet, sync::Arc};
-
-    #[derive(Default)]
-    struct CompletedSystems {
-        completed_systems: Arc<Mutex<HashSet<&'static str>>>,
-    }
-
-    #[test]
-    fn cross_stage_archetype_change_prepare() {
-        let mut world = World::new();
-        let mut resources = Resources::default();
-        resources.insert(ComputeTaskPool(TaskPool::default()));
-
-        let mut schedule = Schedule::default();
-        schedule.add_stage("PreArchetypeChange");
-        schedule.add_stage("PostArchetypeChange");
-
-        fn insert(commands: &mut Commands) {
-            commands.spawn((1u32,));
-        }
-
-        fn read(query: Query<&u32>, entities: Query<Entity>) {
-            for entity in &mut entities.iter() {
-                // query.get() does a "system permission check" that will fail if the entity is from a
-                // new archetype which hasnt been "prepared yet"
-                query.get_component::<u32>(entity).unwrap();
-            }
-
-            assert_eq!(1, entities.iter().count());
-        }
-
-        schedule.add_system_to_stage("PreArchetypeChange", insert);
-        schedule.add_system_to_stage("PostArchetypeChange", read);
-
-        let mut executor = ParallelExecutor::default();
-        schedule.initialize(&mut world, &mut resources);
-        executor.run(&mut schedule, &mut world, &mut resources);
-    }
-
-    #[test]
-    fn intra_stage_archetype_change_prepare() {
-        let mut world = World::new();
-        let mut resources = Resources::default();
-        resources.insert(ComputeTaskPool(TaskPool::default()));
-
-        let mut schedule = Schedule::default();
-        schedule.add_stage("update");
-
-        fn insert(world: &mut World, _resources: &mut Resources) {
-            world.spawn((1u32,));
-        }
-
-        fn read(query: Query<&u32>, entities: Query<Entity>) {
-            for entity in &mut entities.iter() {
-                // query.get() does a "system permission check" that will fail if the entity is from a
-                // new archetype which hasnt been "prepared yet"
-                query.get_component::<u32>(entity).unwrap();
-            }
-
-            assert_eq!(1, entities.iter().count());
-        }
-
-        schedule.add_system_to_stage("update", insert);
-        schedule.add_system_to_stage("update", read);
-        schedule.initialize(&mut world, &mut resources);
-
-        let mut executor = ParallelExecutor::default();
-        executor.run(&mut schedule, &mut world, &mut resources);
-    }
-
-    #[test]
-    fn schedule() {
-        let mut world = World::new();
-        let mut resources = Resources::default();
-        resources.insert(ComputeTaskPool(TaskPool::default()));
-        resources.insert(CompletedSystems::default());
-        resources.insert(1.0f64);
-        resources.insert(2isize);
-
-        world.spawn((1.0f32,));
-        world.spawn((1u32, 1u64));
-        world.spawn((2u32,));
-
-        let mut schedule = Schedule::default();
-        schedule.add_stage("A"); // component queries
-        schedule.add_stage("B"); // thread local
-        schedule.add_stage("C"); // resources
-
-        // A system names
-        const READ_U32_SYSTEM_NAME: &str = "read_u32";
-        const WRITE_FLOAT_SYSTEM_NAME: &str = "write_float";
-        const READ_U32_WRITE_U64_SYSTEM_NAME: &str = "read_u32_write_u64";
-        const READ_U64_SYSTEM_NAME: &str = "read_u64";
-
-        // B system names
-        const WRITE_U64_SYSTEM_NAME: &str = "write_u64";
-        const THREAD_LOCAL_SYSTEM_SYSTEM_NAME: &str = "thread_local_system";
-        const WRITE_F32_SYSTEM_NAME: &str = "write_f32";
-
-        // C system names
-        const READ_F64_RES_SYSTEM_NAME: &str = "read_f64_res";
-        const READ_ISIZE_RES_SYSTEM_NAME: &str = "read_isize_res";
-        const READ_ISIZE_WRITE_F64_RES_SYSTEM_NAME: &str = "read_isize_write_f64_res";
-        const WRITE_F64_RES_SYSTEM_NAME: &str = "write_f64_res";
-
-        // A systems
-
-        fn read_u32(completed_systems: Res<CompletedSystems>, _query: Query<&u32>) {
-            let mut completed_systems = completed_systems.completed_systems.lock();
-            completed_systems.insert(READ_U32_SYSTEM_NAME);
-        }
-
-        fn write_float(completed_systems: Res<CompletedSystems>, _query: Query<&f32>) {
-            let mut completed_systems = completed_systems.completed_systems.lock();
-            completed_systems.insert(WRITE_FLOAT_SYSTEM_NAME);
-        }
-
-        fn read_u32_write_u64(
-            completed_systems: Res<CompletedSystems>,
-            _query: Query<(&u32, &mut u64)>,
-        ) {
-            let mut completed_systems = completed_systems.completed_systems.lock();
-            assert!(!completed_systems.contains(READ_U64_SYSTEM_NAME));
-            completed_systems.insert(READ_U32_WRITE_U64_SYSTEM_NAME);
-        }
-
-        fn read_u64(completed_systems: Res<CompletedSystems>, _query: Query<&u64>) {
-            let mut completed_systems = completed_systems.completed_systems.lock();
-            assert!(completed_systems.contains(READ_U32_WRITE_U64_SYSTEM_NAME));
-            assert!(!completed_systems.contains(WRITE_U64_SYSTEM_NAME));
-            completed_systems.insert(READ_U64_SYSTEM_NAME);
-        }
-
-        schedule.add_system_to_stage("A", read_u32);
-        schedule.add_system_to_stage("A", write_float);
-        schedule.add_system_to_stage("A", read_u32_write_u64);
-        schedule.add_system_to_stage("A", read_u64);
-
-        // B systems
-
-        fn write_u64(completed_systems: Res<CompletedSystems>, _query: Query<&mut u64>) {
-            let mut completed_systems = completed_systems.completed_systems.lock();
-            assert!(completed_systems.contains(READ_U64_SYSTEM_NAME));
-            assert!(!completed_systems.contains(THREAD_LOCAL_SYSTEM_SYSTEM_NAME));
-            assert!(!completed_systems.contains(WRITE_F32_SYSTEM_NAME));
-            completed_systems.insert(WRITE_U64_SYSTEM_NAME);
-        }
-
-        fn thread_local_system(_world: &mut World, resources: &mut Resources) {
-            let completed_systems = resources.get::<CompletedSystems>().unwrap();
-            let mut completed_systems = completed_systems.completed_systems.lock();
-            assert!(completed_systems.contains(WRITE_U64_SYSTEM_NAME));
-            assert!(!completed_systems.contains(WRITE_F32_SYSTEM_NAME));
-            completed_systems.insert(THREAD_LOCAL_SYSTEM_SYSTEM_NAME);
-        }
-
-        fn write_f32(completed_systems: Res<CompletedSystems>, _query: Query<&mut f32>) {
-            let mut completed_systems = completed_systems.completed_systems.lock();
-            assert!(completed_systems.contains(WRITE_U64_SYSTEM_NAME));
-            assert!(completed_systems.contains(THREAD_LOCAL_SYSTEM_SYSTEM_NAME));
-            assert!(!completed_systems.contains(READ_F64_RES_SYSTEM_NAME));
-            completed_systems.insert(WRITE_F32_SYSTEM_NAME);
-        }
-
-        schedule.add_system_to_stage("B", write_u64);
-        schedule.add_system_to_stage("B", thread_local_system);
-        schedule.add_system_to_stage("B", write_f32);
-
-        // C systems
-
-        fn read_f64_res(completed_systems: Res<CompletedSystems>, _f64_res: Res<f64>) {
-            let mut completed_systems = completed_systems.completed_systems.lock();
-            assert!(completed_systems.contains(WRITE_F32_SYSTEM_NAME));
-            assert!(!completed_systems.contains(READ_ISIZE_WRITE_F64_RES_SYSTEM_NAME));
-            assert!(!completed_systems.contains(WRITE_F64_RES_SYSTEM_NAME));
-            completed_systems.insert(READ_F64_RES_SYSTEM_NAME);
-        }
-
-        fn read_isize_res(completed_systems: Res<CompletedSystems>, _isize_res: Res<isize>) {
-            let mut completed_systems = completed_systems.completed_systems.lock();
-            completed_systems.insert(READ_ISIZE_RES_SYSTEM_NAME);
-        }
-
-        fn read_isize_write_f64_res(
-            completed_systems: Res<CompletedSystems>,
-            _isize_res: Res<isize>,
-            _f64_res: ResMut<f64>,
-        ) {
-            let mut completed_systems = completed_systems.completed_systems.lock();
-            assert!(completed_systems.contains(READ_F64_RES_SYSTEM_NAME));
-            assert!(!completed_systems.contains(WRITE_F64_RES_SYSTEM_NAME));
-            completed_systems.insert(READ_ISIZE_WRITE_F64_RES_SYSTEM_NAME);
-        }
-
-        fn write_f64_res(completed_systems: Res<CompletedSystems>, _f64_res: ResMut<f64>) {
-            let mut completed_systems = completed_systems.completed_systems.lock();
-            assert!(completed_systems.contains(READ_F64_RES_SYSTEM_NAME));
-            assert!(completed_systems.contains(READ_ISIZE_WRITE_F64_RES_SYSTEM_NAME));
-            completed_systems.insert(WRITE_F64_RES_SYSTEM_NAME);
-        }
-
-        schedule.add_system_to_stage("C", read_f64_res);
-        schedule.add_system_to_stage("C", read_isize_res);
-        schedule.add_system_to_stage("C", read_isize_write_f64_res);
-        schedule.add_system_to_stage("C", write_f64_res);
-        schedule.initialize(&mut world, &mut resources);
-
-        fn run_executor_and_validate(
-            executor: &mut ParallelExecutor,
-            schedule: &mut Schedule,
-            world: &mut World,
-            resources: &mut Resources,
-        ) {
-            executor.run(schedule, world, resources);
-
-            assert_eq!(
-                executor.stages[0].system_dependents,
-                vec![vec![], vec![], vec![3], vec![]]
-            );
-            assert_eq!(
-                executor.stages[1].system_dependents,
-                vec![vec![1], vec![2], vec![]]
-            );
-            assert_eq!(
-                executor.stages[2].system_dependents,
-                vec![vec![2, 3], vec![], vec![3], vec![]]
-            );
-
-            let stage_0_len = executor.stages[0].system_dependencies.len();
-            let mut read_u64_deps = FixedBitSet::with_capacity(stage_0_len);
-            read_u64_deps.insert(2);
-
-            assert_eq!(
-                executor.stages[0].system_dependencies,
-                vec![
-                    FixedBitSet::with_capacity(stage_0_len),
-                    FixedBitSet::with_capacity(stage_0_len),
-                    FixedBitSet::with_capacity(stage_0_len),
-                    read_u64_deps,
-                ]
-            );
-
-            let stage_1_len = executor.stages[1].system_dependencies.len();
-            let mut thread_local_deps = FixedBitSet::with_capacity(stage_1_len);
-            thread_local_deps.insert(0);
-            let mut write_f64_deps = FixedBitSet::with_capacity(stage_1_len);
-            write_f64_deps.insert(1);
-            assert_eq!(
-                executor.stages[1].system_dependencies,
-                vec![
-                    FixedBitSet::with_capacity(stage_1_len),
-                    thread_local_deps,
-                    write_f64_deps
-                ]
-            );
-
-            let stage_2_len = executor.stages[2].system_dependencies.len();
-            let mut read_isize_write_f64_res_deps = FixedBitSet::with_capacity(stage_2_len);
-            read_isize_write_f64_res_deps.insert(0);
-            let mut write_f64_res_deps = FixedBitSet::with_capacity(stage_2_len);
-            write_f64_res_deps.insert(0);
-            write_f64_res_deps.insert(2);
-            assert_eq!(
-                executor.stages[2].system_dependencies,
-                vec![
-                    FixedBitSet::with_capacity(stage_2_len),
-                    FixedBitSet::with_capacity(stage_2_len),
-                    read_isize_write_f64_res_deps,
-                    write_f64_res_deps
-                ]
-            );
-
-            let completed_systems = resources.get::<CompletedSystems>().unwrap();
-            assert_eq!(
-                completed_systems.completed_systems.lock().len(),
-                11,
-                "completed_systems should have been incremented once for each system"
-            );
-        }
-
-        // Stress test the "clean start" case
-        for _ in 0..1000 {
-            let mut executor = ParallelExecutor::default();
-            run_executor_and_validate(&mut executor, &mut schedule, &mut world, &mut resources);
-            resources
-                .get::<CompletedSystems>()
-                .unwrap()
-                .completed_systems
-                .lock()
-                .clear();
-        }
-
-        // Stress test the "continue running" case
-        let mut executor = ParallelExecutor::default();
-        run_executor_and_validate(&mut executor, &mut schedule, &mut world, &mut resources);
-        for _ in 0..1000 {
-            // run again (with completed_systems reset) to ensure executor works correctly across runs
-            resources
-                .get::<CompletedSystems>()
-                .unwrap()
-                .completed_systems
-                .lock()
-                .clear();
-            run_executor_and_validate(&mut executor, &mut schedule, &mut world, &mut resources);
-        }
-    }
-}
diff --git a/crates/bevy_ecs/src/schedule/state.rs b/crates/bevy_ecs/src/schedule/state.rs
new file mode 100644
index 0000000000000..f54a5f0ebaf1c
--- /dev/null
+++ b/crates/bevy_ecs/src/schedule/state.rs
@@ -0,0 +1,276 @@
+use crate::{Resource, Resources, Stage, System, SystemStage, World};
+use bevy_utils::HashMap;
+use std::{mem::Discriminant, ops::Deref};
+use thiserror::Error;
+
+pub(crate) struct StateStages {
+    update: Box<dyn Stage>,
+    enter: Box<dyn Stage>,
+    exit: Box<dyn Stage>,
+}
+
+impl Default for StateStages {
+    fn default() -> Self {
+        Self {
+            enter: Box::new(SystemStage::parallel()),
+            update: Box::new(SystemStage::parallel()),
+            exit: Box::new(SystemStage::parallel()),
+        }
+    }
+}
+
+pub struct StateStage<T> {
+    stages: HashMap<Discriminant<T>, StateStages>,
+}
+
+impl<T> Default for StateStage<T> {
+    fn default() -> Self {
+        Self {
+            stages: Default::default(),
+        }
+    }
+}
+
+#[allow(clippy::mem_discriminant_non_enum)]
+impl<T> StateStage<T> {
+    pub fn with_enter_stage<S: Stage>(mut self, state: T, stage: S) -> Self {
+        self.set_enter_stage(state, stage);
+        self
+    }
+
+    pub fn with_exit_stage<S: Stage>(mut self, state: T, stage: S) -> Self {
+        self.set_exit_stage(state, stage);
+        self
+    }
+
+    pub fn with_update_stage<S: Stage>(mut self, state: T, stage: S) -> Self {
+        self.set_update_stage(state, stage);
+        self
+    }
+
+    pub fn set_enter_stage<S: Stage>(&mut self, state: T, stage: S) -> &mut Self {
+        let stages = self.state_stages(state);
+        stages.enter = Box::new(stage);
+        self
+    }
+
+    pub fn set_exit_stage<S: Stage>(&mut self, state: T, stage: S) -> &mut Self {
+        let stages = self.state_stages(state);
+        stages.exit = Box::new(stage);
+        self
+    }
+
+    pub fn set_update_stage<S: Stage>(&mut self, state: T, stage: S) -> &mut Self {
+        let stages = self.state_stages(state);
+        stages.update = Box::new(stage);
+        self
+    }
+
+    pub fn on_state_enter<S: System<In = (), Out = ()>>(
+        &mut self,
+        state: T,
+        system: S,
+    ) -> &mut Self {
+        self.enter_stage(state, |system_stage: &mut SystemStage| {
+            system_stage.add_system(system)
+        })
+    }
+
+    pub fn on_state_exit<S: System<In = (), Out = ()>>(
+        &mut self,
+        state: T,
+        system: S,
+    ) -> &mut Self {
+        self.exit_stage(state, |system_stage: &mut SystemStage| {
+            system_stage.add_system(system)
+        })
+    }
+
+    pub fn on_state_update<S: System<In = (), Out = ()>>(
+        &mut self,
+        state: T,
+        system: S,
+    ) -> &mut Self {
+        self.update_stage(state, |system_stage: &mut SystemStage| {
+            system_stage.add_system(system)
+        })
+    }
+
+    pub fn enter_stage<S: Stage, F: FnOnce(&mut S) -> &mut S>(
+        &mut self,
+        state: T,
+        func: F,
+    ) -> &mut Self {
+        let stages = self.state_stages(state);
+        func(
+            stages
+                .enter
+                .downcast_mut()
+                .expect("'Enter' stage does not match the given type"),
+        );
+        self
+    }
+
+    pub fn exit_stage<S: Stage, F: FnOnce(&mut S) -> &mut S>(
+        &mut self,
+        state: T,
+        func: F,
+    ) -> &mut Self {
+        let stages = self.state_stages(state);
+        func(
+            stages
+                .exit
+                .downcast_mut()
+                .expect("'Exit' stage does not match the given type"),
+        );
+        self
+    }
+
+    pub fn update_stage<S: Stage, F: FnOnce(&mut S) -> &mut S>(
+        &mut self,
+        state: T,
+        func: F,
+    ) -> &mut Self {
+        let stages = self.state_stages(state);
+        func(
+            stages
+                .update
+                .downcast_mut()
+                .expect("'Update' stage does not match the given type"),
+        );
+        self
+    }
+
+    fn state_stages(&mut self, state: T) -> &mut StateStages {
+        self.stages
+            .entry(std::mem::discriminant(&state))
+            .or_default()
+    }
+}
+
+#[allow(clippy::mem_discriminant_non_enum)]
+impl<T: Resource + Clone> Stage for StateStage<T> {
+    fn initialize(&mut self, world: &mut World, resources: &mut Resources) {
+        for state_stages in self.stages.values_mut() {
+            state_stages.enter.initialize(world, resources);
+            state_stages.update.initialize(world, resources);
+            state_stages.exit.initialize(world, resources);
+        }
+    }
+
+    fn run(&mut self, world: &mut World, resources: &mut Resources) {
+        let current_stage = loop {
+            let (next_stage, current_stage) = {
+                let mut state = resources
+                    .get_mut::<State<T>>()
+                    .expect("Missing state resource");
+                let result = (
+                    state.next.as_ref().map(|next| std::mem::discriminant(next)),
+                    std::mem::discriminant(&state.current),
+                );
+
+                state.apply_next();
+
+                result
+            };
+
+            // if next_stage is Some, we just applied a new state
+            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);
+                    }
+                }
+
+                if let Some(next_state_stages) = self.stages.get_mut(&next_stage) {
+                    next_state_stages.enter.run(world, resources);
+                }
+            } else {
+                break current_stage;
+            }
+        };
+
+        if let Some(current_state_stages) = self.stages.get_mut(&current_stage) {
+            current_state_stages.update.run(world, resources);
+        }
+    }
+}
+#[derive(Debug, Error)]
+pub enum StateError {
+    #[error("Attempted to change the state to the current state.")]
+    AlreadyInState,
+    #[error("Attempted to queue a state change, but there was already a state queued.")]
+    StateAlreadyQueued,
+}
+
+#[derive(Debug)]
+pub struct State<T: Clone> {
+    previous: Option<T>,
+    current: T,
+    next: Option<T>,
+}
+
+#[allow(clippy::mem_discriminant_non_enum)]
+impl<T: Clone> State<T> {
+    pub fn new(state: T) -> Self {
+        Self {
+            current: state.clone(),
+            previous: None,
+            // add value to queue so that we "enter" the state
+            next: Some(state),
+        }
+    }
+
+    pub fn current(&self) -> &T {
+        &self.current
+    }
+
+    pub fn previous(&self) -> Option<&T> {
+        self.previous.as_ref()
+    }
+
+    pub fn next(&self) -> Option<&T> {
+        self.next.as_ref()
+    }
+
+    /// Queue a state change. This will fail if there is already a state in the queue, or if the given `state` matches the current state
+    pub fn set_next(&mut self, state: T) -> Result<(), StateError> {
+        if std::mem::discriminant(&self.current) == std::mem::discriminant(&state) {
+            return Err(StateError::AlreadyInState);
+        }
+
+        if self.next.is_some() {
+            return Err(StateError::StateAlreadyQueued);
+        }
+
+        self.next = Some(state);
+        Ok(())
+    }
+
+    /// Same as [Self::queue], but there is already a next state, it will be overwritten instead of failing
+    pub fn overwrite_next(&mut self, state: T) -> Result<(), StateError> {
+        if std::mem::discriminant(&self.current) == std::mem::discriminant(&state) {
+            return Err(StateError::AlreadyInState);
+        }
+
+        self.next = Some(state);
+        Ok(())
+    }
+
+    fn apply_next(&mut self) {
+        if let Some(next) = self.next.take() {
+            let previous = std::mem::replace(&mut self.current, next);
+            if std::mem::discriminant(&previous) != std::mem::discriminant(&self.current) {
+                self.previous = Some(previous)
+            }
+        }
+    }
+}
+
+impl<T: Clone> Deref for State<T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        &self.current
+    }
+}
diff --git a/crates/bevy_ecs/src/system/commands.rs b/crates/bevy_ecs/src/system/commands.rs
index 397fecdef7b77..3bd82d9682d04 100644
--- a/crates/bevy_ecs/src/system/commands.rs
+++ b/crates/bevy_ecs/src/system/commands.rs
@@ -16,7 +16,7 @@ pub(crate) struct Spawn<T>
 where
     T: DynamicBundle + Send + Sync + 'static,
 {
-    components: T,
+    bundle: T,
 }
 
 impl<T> Command for Spawn<T>
@@ -24,7 +24,7 @@ where
     T: DynamicBundle + Send + Sync + 'static,
 {
     fn write(self: Box<Self>, world: &mut World, _resources: &mut Resources) {
-        world.spawn(self.components);
+        world.spawn(self.bundle);
     }
 }
 
@@ -33,7 +33,7 @@ where
     I: IntoIterator,
     I::Item: Bundle,
 {
-    components_iter: I,
+    bundles_iter: I,
 }
 
 impl<I> Command for SpawnBatch<I>
@@ -42,7 +42,7 @@ where
     I::Item: Bundle,
 {
     fn write(self: Box<Self>, world: &mut World, _resources: &mut Resources) {
-        world.spawn_batch(self.components_iter);
+        world.spawn_batch(self.bundles_iter);
     }
 }
 
@@ -64,7 +64,7 @@ where
     T: DynamicBundle + Send + Sync + 'static,
 {
     entity: Entity,
-    components: T,
+    bundle: T,
 }
 
 impl<T> Command for Insert<T>
@@ -72,7 +72,7 @@ where
     T: DynamicBundle + Send + Sync + 'static,
 {
     fn write(self: Box<Self>, world: &mut World, _resources: &mut Resources) {
-        world.insert(self.entity, self.components).unwrap();
+        world.insert(self.entity, self.bundle).unwrap();
     }
 }
 
@@ -181,6 +181,7 @@ impl<T: Resource> Command for InsertLocalResource<T> {
     }
 }
 
+/// A list of commands that will be run to populate a `World` and `Resources`.
 #[derive(Default)]
 pub struct Commands {
     commands: Vec<Box<dyn Command>>,
@@ -189,38 +190,78 @@ pub struct Commands {
 }
 
 impl Commands {
-    pub fn spawn(&mut self, components: impl DynamicBundle + Send + Sync + 'static) -> &mut Self {
+    /// 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).
+    ///
+    /// See [`Self::set_current_entity`], [`Self::insert`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use bevy_ecs::prelude::*;
+    ///
+    /// struct Component1;
+    /// struct Component2;
+    ///
+    /// #[derive(Bundle)]
+    /// struct ExampleBundle {
+    ///     a: Component1,
+    ///     b: Component2,
+    /// }
+    ///
+    /// fn example_system(mut commands: Commands) {
+    ///     // Create a new entity with a component bundle.
+    ///     commands.spawn(ExampleBundle {
+    ///         a: Component1,
+    ///         b: Component2,
+    ///     });
+    ///
+    ///     // Create a new entity with a single component.
+    ///     commands.spawn((Component1,));
+    ///     // Create a new entity with two components.
+    ///     commands.spawn((Component1, Component2));
+    /// }
+    /// ```
+    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")
+            .expect("Entity reserver has not been set.")
             .reserve_entity();
-        self.current_entity = Some(entity);
-        self.commands.push(Box::new(Insert { entity, components }));
+        self.set_current_entity(entity);
+        self.insert(entity, bundle);
         self
     }
 
-    pub fn spawn_batch<I>(&mut self, components_iter: I) -> &mut Self
+    /// Equivalent to iterating `bundles_iter` and calling [`Self::spawn`] on each bundle, but slightly more performant.
+    pub fn spawn_batch<I>(&mut self, bundles_iter: I) -> &mut Self
     where
         I: IntoIterator + Send + Sync + 'static,
         I::Item: Bundle,
     {
-        self.add_command(SpawnBatch { components_iter })
+        self.add_command(SpawnBatch { bundles_iter })
     }
 
-    /// Despawns only the specified entity, ignoring any other consideration.
+    /// Despawns only the specified entity, not including its children.
     pub fn despawn(&mut self, entity: Entity) -> &mut Self {
         self.add_command(Despawn { entity })
     }
 
+    /// Inserts a bundle of components into `entity`.
+    ///
+    /// See [`World::insert`].
     pub fn insert(
         &mut self,
         entity: Entity,
-        components: impl DynamicBundle + Send + Sync + 'static,
+        bundle: impl DynamicBundle + Send + Sync + 'static,
     ) -> &mut Self {
-        self.add_command(Insert { entity, components })
+        self.add_command(Insert { 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 })
     }
@@ -229,6 +270,9 @@ impl Commands {
         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,
@@ -240,6 +284,7 @@ impl Commands {
         })
     }
 
+    /// See [`World::remove_one`].
     pub fn remove_one<T>(&mut self, entity: Entity) -> &mut Self
     where
         T: Component,
@@ -250,6 +295,7 @@ impl Commands {
         })
     }
 
+    /// See [`World::remove`].
     pub fn remove<T>(&mut self, entity: Entity) -> &mut Self
     where
         T: Bundle + Send + Sync + 'static,
@@ -260,18 +306,54 @@ impl Commands {
         })
     }
 
-    pub fn with_bundle(
-        &mut self,
-        components: impl DynamicBundle + Send + Sync + 'static,
-    ) -> &mut Self {
-        let current_entity =  self.current_entity.expect("Cannot add components because the 'current entity' is not set. You should spawn an entity first.");
+    /// 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 {
+        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 {
             entity: current_entity,
-            components,
+            bundle,
         }));
         self
     }
 
+    /// Adds a single component to the current entity.
+    ///
+    /// See [`Self::with_bundle`], [`Self::current_entity`].
+    ///
+    /// # Warning
+    ///
+    /// It's possible to call this with a bundle, but this is likely not intended and [`Self::with_bundle`] should be used instead. If `with` is called with a bundle, the bundle itself will be added as a component instead of the bundles' inner components each being added.
+    ///
+    /// # Example
+    ///
+    /// `with` can be chained with [`Self::spawn`].
+    ///
+    /// ```
+    /// use bevy_ecs::prelude::*;
+    ///
+    /// struct Component1;
+    /// struct Component2;
+    ///
+    /// fn example_system(mut commands: Commands) {
+    ///     // Create a new entity with a `Component1` and `Component2`.
+    ///     commands.spawn((Component1,)).with(Component2);
+    ///
+    ///     // Psst! These are also equivalent to the line above!
+    ///     commands.spawn((Component1, Component2));
+    ///     commands.spawn(()).with(Component1).with(Component2);
+    ///     #[derive(Bundle)]
+    ///     struct ExampleBundle {
+    ///         a: Component1,
+    ///         b: Component2,
+    ///     }
+    ///     commands.spawn(()).with_bundle(ExampleBundle {
+    ///         a: Component1,
+    ///         b: Component2,
+    ///     });
+    /// }
+    /// ```
     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 {
@@ -281,22 +363,26 @@ impl Commands {
         self
     }
 
+    /// 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));
         self
     }
 
+    /// See [`Self::add_command`].
     pub fn add_command_boxed(&mut self, command: Box<dyn Command>) -> &mut Self {
         self.commands.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
     }
diff --git a/crates/bevy_ecs/src/system/into_system.rs b/crates/bevy_ecs/src/system/into_system.rs
index 3e52aec040bbd..53cda65efc7ca 100644
--- a/crates/bevy_ecs/src/system/into_system.rs
+++ b/crates/bevy_ecs/src/system/into_system.rs
@@ -1,28 +1,34 @@
+use super::system_param::FetchSystemParam;
 use crate::{
     ArchetypeComponent, Commands, QueryAccess, Resources, System, SystemId, SystemParam,
     ThreadLocalExecution, TypeAccess, World,
 };
 use parking_lot::Mutex;
-use std::{any::TypeId, borrow::Cow, sync::Arc};
+use std::{any::TypeId, borrow::Cow, cell::UnsafeCell, sync::Arc};
 
 pub struct SystemState {
     pub(crate) id: SystemId,
     pub(crate) name: Cow<'static, str>,
-    pub(crate) is_initialized: bool,
     pub(crate) archetype_component_access: TypeAccess<ArchetypeComponent>,
     pub(crate) resource_access: TypeAccess<TypeId>,
     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: Commands,
+    pub(crate) commands: UnsafeCell<Commands>,
     pub(crate) arc_commands: Option<Arc<Mutex<Commands>>>,
-    pub(crate) current_query_index: usize,
+    pub(crate) current_query_index: UnsafeCell<usize>,
 }
 
+// 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) {
-        self.current_query_index = 0;
+        // SAFE: done with unique mutable access to Self
+        unsafe {
+            *self.current_query_index.get() = 0;
+        }
     }
 
     pub fn update(&mut self, world: &World) {
@@ -64,7 +70,7 @@ impl SystemState {
                     conflicts_with_index = Some(prior_index);
                 }
             }
-            panic!("System {} has conflicting queries. {} conflicts with the component access [{}] in this prior query: {}",
+            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"),
@@ -73,12 +79,64 @@ impl SystemState {
     }
 }
 
-pub struct FuncSystem<Input, Return> {
+pub struct FuncSystem<Out> {
+    func:
+        Box<dyn FnMut(&mut SystemState, &World, &Resources) -> Option<Out> + Send + Sync + 'static>,
+    thread_local_func:
+        Box<dyn FnMut(&mut SystemState, &mut World, &mut Resources) + 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(&mut self, world: &World) {
+        self.state.update(world);
+    }
+
+    fn archetype_component_access(&self) -> &TypeAccess<ArchetypeComponent> {
+        &self.state.archetype_component_access
+    }
+
+    fn resource_access(&self) -> &TypeAccess<std::any::TypeId> {
+        &self.state.resource_access
+    }
+
+    fn thread_local_execution(&self) -> ThreadLocalExecution {
+        ThreadLocalExecution::NextFlush
+    }
+
+    unsafe fn run_unsafe(
+        &mut self,
+        _input: Self::In,
+        world: &World,
+        resources: &Resources,
+    ) -> Option<Out> {
+        (self.func)(&mut self.state, world, resources)
+    }
+
+    fn run_thread_local(&mut self, world: &mut World, resources: &mut Resources) {
+        (self.thread_local_func)(&mut self.state, 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(Input, &mut SystemState, &World, &Resources) -> Option<Return>
-            + Send
-            + Sync
-            + 'static,
+        dyn FnMut(In, &mut SystemState, &World, &Resources) -> Option<Out> + Send + Sync + 'static,
     >,
     thread_local_func:
         Box<dyn FnMut(&mut SystemState, &mut World, &mut Resources) + Send + Sync + 'static>,
@@ -86,9 +144,9 @@ pub struct FuncSystem<Input, Return> {
     state: SystemState,
 }
 
-impl<Input: 'static, Output: 'static> System for FuncSystem<Input, Output> {
-    type Input = Input;
-    type Output = Output;
+impl<In: 'static, Out: 'static> System for InputFuncSystem<In, Out> {
+    type In = In;
+    type Out = Out;
 
     fn name(&self) -> std::borrow::Cow<'static, str> {
         self.state.name.clone()
@@ -116,10 +174,10 @@ impl<Input: 'static, Output: 'static> System for FuncSystem<Input, Output> {
 
     unsafe fn run_unsafe(
         &mut self,
-        input: Input,
+        input: In,
         world: &World,
         resources: &Resources,
-    ) -> Option<Output> {
+    ) -> Option<Out> {
         (self.func)(input, &mut self.state, world, resources)
     }
 
@@ -129,11 +187,6 @@ impl<Input: 'static, Output: 'static> System for FuncSystem<Input, Output> {
 
     fn initialize(&mut self, world: &mut World, resources: &mut Resources) {
         (self.init_func)(&mut self.state, world, resources);
-        self.state.is_initialized = true;
-    }
-
-    fn is_initialized(&self) -> bool {
-        self.state.is_initialized
     }
 }
 
@@ -147,36 +200,40 @@ impl<Sys: System> IntoSystem<(), Sys> for Sys {
         self
     }
 }
+pub struct In<In>(pub In);
 
 macro_rules! impl_into_system {
     ($($param: ident),*) => {
-        impl<Func, Input, Return, $($param: SystemParam<Input>),*> IntoSystem<($($param,)*), FuncSystem<Input, Return>> for Func
-        where Func: FnMut($($param),*) -> Return + Send + Sync + 'static, Return: 'static, Input: 'static
+        impl<Func, Out, $($param: SystemParam),*> IntoSystem<($($param,)*), FuncSystem<Out>> for Func
+        where
+            Func:
+                FnMut($($param),*) -> Out +
+                FnMut($(<<$param as SystemParam>::Fetch as FetchSystemParam>::Item),*) -> Out +
+                Send + Sync + 'static, Out: 'static
         {
             #[allow(unused_variables)]
             #[allow(unused_unsafe)]
             #[allow(non_snake_case)]
-            fn system(mut self) -> FuncSystem<Input, Return> {
+            fn system(mut self) -> FuncSystem<Out> {
                 FuncSystem {
                     state: SystemState {
                         name: std::any::type_name::<Self>().into(),
                         archetype_component_access: TypeAccess::default(),
                         resource_access: TypeAccess::default(),
                         local_resource_access: TypeAccess::default(),
-                        is_initialized: false,
                         id: SystemId::new(),
-                        commands: Commands::default(),
+                        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(),
-                        current_query_index: 0,
                     },
-                    func: Box::new(move |input, state, world, resources| {
+                    func: Box::new(move |state, world, resources| {
                         state.reset_indices();
-                        let mut input = Some(input);
+                        // let mut input = Some(input);
                         unsafe {
-                            if let Some(($($param,)*)) = <($($param,)*)>::get_param(&mut input, state, world, resources) {
+                            if let Some(($($param,)*)) = <<($($param,)*) as SystemParam>::Fetch as FetchSystemParam>::get_param(state, world, resources) {
                                 Some(self($($param),*))
                             } else {
                                 None
@@ -184,14 +241,69 @@ macro_rules! impl_into_system {
                         }
                     }),
                     thread_local_func: Box::new(|state, world, resources| {
-                        state.commands.apply(world, resources);
+                        // SAFE: this is called with unique access to SystemState
+                        unsafe {
+                            (&mut *state.commands.get()).apply(world, resources);
+                        }
+                        if let Some(ref commands) = state.arc_commands {
+                            let mut commands = commands.lock();
+                            commands.apply(world, resources);
+                        }
+                    }),
+                    init_func: Box::new(|state, world, resources| {
+                        <<($($param,)*) as SystemParam>::Fetch as FetchSystemParam>::init(state, world, resources)
+                    }),
+                }
+            }
+        }
+        impl<Func, Input, Out, $($param: SystemParam),*> IntoSystem<(Input, $($param,)*), InputFuncSystem<Input, Out>> 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
+        {
+            #[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(),
+                        resource_access: TypeAccess::default(),
+                        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
+                            }
+                        }
+                    }),
+                    thread_local_func: Box::new(|state, world, resources| {
+                        // SAFE: this is called with unique access to SystemState
+                        unsafe {
+                            (&mut *state.commands.get()).apply(world, resources);
+                        }
                         if let Some(ref commands) = state.arc_commands {
                             let mut commands = commands.lock();
                             commands.apply(world, resources);
                         }
                     }),
                     init_func: Box::new(|state, world, resources| {
-                        $($param::init(state, world, resources);)*
+                        <<($($param,)*) as SystemParam>::Fetch as FetchSystemParam>::init(state, world, resources)
                     }),
                 }
             }
@@ -221,9 +333,10 @@ impl_into_system!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P);
 mod tests {
     use super::IntoSystem;
     use crate::{
+        clear_trackers_system,
         resource::{Res, ResMut, Resources},
         schedule::Schedule,
-        ChangedRes, Entity, Local, Or, Query, QuerySet, System, With, World,
+        ChangedRes, Entity, Local, Or, Query, QuerySet, System, SystemStage, With, World,
     };
 
     #[derive(Debug, Eq, PartialEq, Default)]
@@ -286,7 +399,7 @@ mod tests {
         world.spawn((A, C));
         world.spawn((A, D));
 
-        run_system(&mut world, &mut resources, query_system);
+        run_system(&mut world, &mut resources, query_system.system());
 
         assert!(*resources.get::<bool>().unwrap(), "system ran");
     }
@@ -295,12 +408,14 @@ mod tests {
     fn or_query_set_system() {
         // Regression test for issue #762
         use crate::{Added, Changed, Mutated, Or};
-        let query_system = move |mut ran: ResMut<bool>,
-                                 set: QuerySet<(
-            Query<(), Or<(Changed<A>, Changed<B>)>>,
-            Query<(), Or<(Added<A>, Added<B>)>>,
-            Query<(), Or<(Mutated<A>, Mutated<B>)>>,
-        )>| {
+        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();
@@ -317,7 +432,7 @@ mod tests {
         resources.insert(false);
         world.spawn((A, B));
 
-        run_system(&mut world, &mut resources, query_system);
+        run_system(&mut world, &mut resources, query_system.system());
 
         assert!(*resources.get::<bool>().unwrap(), "system ran");
     }
@@ -336,18 +451,22 @@ mod tests {
         let ent = world.spawn((0,));
 
         let mut schedule = Schedule::default();
-        schedule.add_stage("update");
-        schedule.add_system_to_stage("update", incr_e_on_flip);
-        schedule.initialize(&mut world, &mut resources);
-
-        schedule.run(&mut world, &mut resources);
+        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.system()),
+        );
+
+        schedule.initialize_and_run(&mut world, &mut resources);
         assert_eq!(*(world.get::<i32>(ent).unwrap()), 1);
 
-        schedule.run(&mut world, &mut resources);
+        schedule.initialize_and_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);
+        schedule.initialize_and_run(&mut world, &mut resources);
         assert_eq!(*(world.get::<i32>(ent).unwrap()), 2);
     }
 
@@ -369,25 +488,29 @@ mod tests {
         let ent = world.spawn((0,));
 
         let mut schedule = Schedule::default();
-        schedule.add_stage("update");
-        schedule.add_system_to_stage("update", incr_e_on_flip);
-        schedule.initialize(&mut world, &mut resources);
-
-        schedule.run(&mut world, &mut resources);
+        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.system()),
+        );
+
+        schedule.initialize_and_run(&mut world, &mut resources);
         assert_eq!(*(world.get::<i32>(ent).unwrap()), 1);
 
-        schedule.run(&mut world, &mut resources);
+        schedule.initialize_and_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);
+        schedule.initialize_and_run(&mut world, &mut resources);
         assert_eq!(*(world.get::<i32>(ent).unwrap()), 2);
 
-        schedule.run(&mut world, &mut resources);
+        schedule.initialize_and_run(&mut world, &mut resources);
         assert_eq!(*(world.get::<i32>(ent).unwrap()), 2);
 
         *resources.get_mut::<i32>().unwrap() = 20;
-        schedule.run(&mut world, &mut resources);
+        schedule.initialize_and_run(&mut world, &mut resources);
         assert_eq!(*(world.get::<i32>(ent).unwrap()), 3);
     }
 
@@ -400,7 +523,7 @@ mod tests {
         let mut resources = Resources::default();
         world.spawn((A,));
 
-        run_system(&mut world, &mut resources, sys);
+        run_system(&mut world, &mut resources, sys.system());
     }
 
     #[test]
@@ -412,7 +535,7 @@ mod tests {
         let mut resources = Resources::default();
         world.spawn((A,));
 
-        run_system(&mut world, &mut resources, sys);
+        run_system(&mut world, &mut resources, sys.system());
     }
 
     #[test]
@@ -423,7 +546,7 @@ mod tests {
         let mut resources = Resources::default();
         world.spawn((A,));
 
-        run_system(&mut world, &mut resources, sys);
+        run_system(&mut world, &mut resources, sys.system());
     }
 
     #[test]
@@ -435,7 +558,7 @@ mod tests {
         let mut resources = Resources::default();
         world.spawn((A,));
 
-        run_system(&mut world, &mut resources, sys);
+        run_system(&mut world, &mut resources, sys.system());
     }
 
     #[test]
@@ -446,24 +569,19 @@ mod tests {
         let mut world = World::default();
         let mut resources = Resources::default();
         world.spawn((A,));
-        run_system(&mut world, &mut resources, sys);
+        run_system(&mut world, &mut resources, sys.system());
     }
 
-    fn run_system<
-        Params,
-        SystemType: System<Input = (), Output = ()>,
-        Sys: IntoSystem<Params, SystemType>,
-    >(
+    fn run_system<S: System<In = (), Out = ()>>(
         world: &mut World,
         resources: &mut Resources,
-        system: Sys,
+        system: S,
     ) {
         let mut schedule = Schedule::default();
-        schedule.add_stage("update");
-        schedule.add_system_to_stage("update", system);
-
-        schedule.initialize(world, resources);
-        schedule.run(world, resources);
+        let mut update = SystemStage::parallel();
+        update.add_system(system);
+        schedule.add_stage("update", update);
+        schedule.initialize_and_run(world, resources);
     }
 
     #[derive(Default)]
@@ -471,40 +589,34 @@ mod tests {
         _buffer: Vec<u8>,
     }
 
-    fn test_for_conflicting_resources<
-        Params,
-        SystemType: System<Input = (), Output = ()>,
-        Sys: IntoSystem<Params, SystemType>,
-    >(
-        sys: Sys,
-    ) {
+    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);
+        run_system(&mut world, &mut resources, sys.system());
     }
 
     #[test]
     #[should_panic]
     fn conflicting_system_resources() {
         fn sys(_: ResMut<BufferRes>, _: Res<BufferRes>) {}
-        test_for_conflicting_resources(sys)
+        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)
+        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)
+        test_for_conflicting_resources(sys.system())
     }
 
     #[test]
@@ -512,19 +624,19 @@ mod tests {
     fn conflicting_changed_and_mutable_resource() {
         // A tempting pattern, but unsound if allowed.
         fn sys(_: ResMut<BufferRes>, _: ChangedRes<BufferRes>) {}
-        test_for_conflicting_resources(sys)
+        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)
+        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)
+        test_for_conflicting_resources(sys.system())
     }
 }
diff --git a/crates/bevy_ecs/src/system/into_thread_local.rs b/crates/bevy_ecs/src/system/into_thread_local.rs
index 4fe61b3da74b0..d08f33a200d7a 100644
--- a/crates/bevy_ecs/src/system/into_thread_local.rs
+++ b/crates/bevy_ecs/src/system/into_thread_local.rs
@@ -15,8 +15,8 @@ pub struct ThreadLocalSystemFn {
 }
 
 impl System for ThreadLocalSystemFn {
-    type Input = ();
-    type Output = ();
+    type In = ();
+    type Out = ();
 
     fn name(&self) -> Cow<'static, str> {
         self.name.clone()
@@ -54,10 +54,6 @@ impl System for ThreadLocalSystemFn {
     fn id(&self) -> SystemId {
         self.id
     }
-
-    fn is_initialized(&self) -> bool {
-        true
-    }
 }
 
 impl<F> IntoSystem<(&mut World, &mut Resources), ThreadLocalSystemFn> for F
diff --git a/crates/bevy_ecs/src/system/query/mod.rs b/crates/bevy_ecs/src/system/query/mod.rs
index 5fa89aa9d0f1d..60a309a029b76 100644
--- a/crates/bevy_ecs/src/system/query/mod.rs
+++ b/crates/bevy_ecs/src/system/query/mod.rs
@@ -181,6 +181,21 @@ impl<'a, Q: WorldQuery, F: QueryFilter> Query<'a, Q, F> {
             .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>()
     }
diff --git a/crates/bevy_ecs/src/system/system.rs b/crates/bevy_ecs/src/system/system.rs
index 85bb0cefd7ea5..fac4eab2e9442 100644
--- a/crates/bevy_ecs/src/system/system.rs
+++ b/crates/bevy_ecs/src/system/system.rs
@@ -20,11 +20,10 @@ impl SystemId {
 
 /// An ECS system that can be added to a [Schedule](crate::Schedule)
 pub trait System: Send + Sync + 'static {
-    type Input;
-    type Output;
+    type In;
+    type Out;
     fn name(&self) -> Cow<'static, str>;
     fn id(&self) -> SystemId;
-    fn is_initialized(&self) -> bool;
     fn update(&mut self, world: &World);
     fn archetype_component_access(&self) -> &TypeAccess<ArchetypeComponent>;
     fn resource_access(&self) -> &TypeAccess<TypeId>;
@@ -35,16 +34,16 @@ pub trait System: Send + Sync + 'static {
     /// 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::Input,
+        input: Self::In,
         world: &World,
         resources: &Resources,
-    ) -> Option<Self::Output>;
+    ) -> Option<Self::Out>;
     fn run(
         &mut self,
-        input: Self::Input,
+        input: Self::In,
         world: &mut World,
         resources: &mut Resources,
-    ) -> Option<Self::Output> {
+    ) -> Option<Self::Out> {
         // SAFE: world and resources are exclusively borrowed
         unsafe { self.run_unsafe(input, world, resources) }
     }
diff --git a/crates/bevy_ecs/src/system/system_chaining.rs b/crates/bevy_ecs/src/system/system_chaining.rs
index 5d5397c80c654..b0cfd4c055a9b 100644
--- a/crates/bevy_ecs/src/system/system_chaining.rs
+++ b/crates/bevy_ecs/src/system/system_chaining.rs
@@ -1,6 +1,5 @@
 use crate::{
-    ArchetypeComponent, IntoSystem, Resources, System, SystemId, ThreadLocalExecution, TypeAccess,
-    World,
+    ArchetypeComponent, Resources, System, SystemId, ThreadLocalExecution, TypeAccess, World,
 };
 use std::{any::TypeId, borrow::Cow};
 
@@ -13,11 +12,9 @@ pub struct ChainSystem<SystemA, SystemB> {
     pub(crate) resource_access: TypeAccess<TypeId>,
 }
 
-impl<SystemA: System, SystemB: System<Input = SystemA::Output>> System
-    for ChainSystem<SystemA, SystemB>
-{
-    type Input = SystemA::Input;
-    type Output = SystemB::Output;
+impl<SystemA: System, SystemB: System<In = SystemA::Out>> System for ChainSystem<SystemA, SystemB> {
+    type In = SystemA::In;
+    type Out = SystemB::Out;
 
     fn name(&self) -> Cow<'static, str> {
         self.name.clone()
@@ -27,10 +24,6 @@ impl<SystemA: System, SystemB: System<Input = SystemA::Output>> System
         self.id
     }
 
-    fn is_initialized(&self) -> bool {
-        self.system_a.is_initialized() && self.system_b.is_initialized()
-    }
-
     fn update(&mut self, world: &World) {
         self.archetype_component_access.clear();
         self.resource_access.clear();
@@ -56,10 +49,10 @@ impl<SystemA: System, SystemB: System<Input = SystemA::Output>> System
 
     unsafe fn run_unsafe(
         &mut self,
-        input: Self::Input,
+        input: Self::In,
         world: &World,
         resources: &Resources,
-    ) -> Option<Self::Output> {
+    ) -> Option<Self::Out> {
         let out = self.system_a.run_unsafe(input, world, resources).unwrap();
         self.system_b.run_unsafe(out, world, resources)
     }
@@ -75,31 +68,23 @@ impl<SystemA: System, SystemB: System<Input = SystemA::Output>> System
     }
 }
 
-pub trait IntoChainSystem<AParams, BParams, IntoB, SystemA, SystemB>:
-    IntoSystem<AParams, SystemA> + Sized
+pub trait IntoChainSystem<SystemB>: System + Sized
 where
-    IntoB: IntoSystem<BParams, SystemB>,
-    SystemA: System,
-    SystemB: System<Input = SystemA::Output>,
+    SystemB: System<In = Self::Out>,
 {
-    fn chain(self, system: IntoB) -> ChainSystem<SystemA, SystemB>;
+    fn chain(self, system: SystemB) -> ChainSystem<Self, SystemB>;
 }
 
-impl<AParams, BParams, IntoA, IntoB, SystemA, SystemB>
-    IntoChainSystem<AParams, BParams, IntoB, SystemA, SystemB> for IntoA
+impl<SystemA, SystemB> IntoChainSystem<SystemB> for SystemA
 where
     SystemA: System,
-    SystemB: System<Input = SystemA::Output>,
-    IntoA: IntoSystem<AParams, SystemA>,
-    IntoB: IntoSystem<BParams, SystemB>,
+    SystemB: System<In = SystemA::Out>,
 {
-    fn chain(self, system: IntoB) -> ChainSystem<SystemA, SystemB> {
-        let system_a = self.system();
-        let system_b = system.system();
+    fn chain(self, system: SystemB) -> ChainSystem<SystemA, SystemB> {
         ChainSystem {
-            name: Cow::Owned(format!("Chain({}, {})", system_a.name(), system_b.name())),
-            system_a,
-            system_b,
+            name: Cow::Owned(format!("Chain({}, {})", self.name(), system.name())),
+            system_a: self,
+            system_b: system,
             archetype_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 2a29afc9f554f..0b29e91371e0c 100644
--- a/crates/bevy_ecs/src/system/system_param.rs
+++ b/crates/bevy_ecs/src/system/system_param.rs
@@ -4,50 +4,43 @@ use crate::{
     SystemState, TypeAccess, World, WorldQuery,
 };
 use parking_lot::Mutex;
-use std::{any::TypeId, sync::Arc};
-
-pub struct In<Input>(pub Input);
-
-impl<Input> SystemParam<Input> for In<Input> {
-    #[inline]
-    unsafe fn get_param(
-        input: &mut Option<Input>,
-        _system_state: &mut SystemState,
-        _world: &World,
-        _resources: &Resources,
-    ) -> Option<Self> {
-        Some(In(input.take().unwrap()))
-    }
-
-    fn init(_system_state: &mut SystemState, _world: &World, _resources: &mut Resources) {}
+use std::{any::TypeId, marker::PhantomData, sync::Arc};
+pub trait SystemParam: Sized {
+    type Fetch: for<'a> FetchSystemParam<'a>;
 }
 
-pub trait SystemParam<Input>: Sized {
+pub trait FetchSystemParam<'a> {
+    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(
-        input: &mut Option<Input>,
-        system_state: &mut SystemState,
-        world: &World,
-        resources: &Resources,
-    ) -> Option<Self>;
+        system_state: &'a SystemState,
+        world: &'a World,
+        resources: &'a Resources,
+    ) -> Option<Self::Item>;
+}
+
+pub struct FetchQuery<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, F: QueryFilter, Input> SystemParam<Input> for Query<'a, Q, F> {
+impl<'a, Q: WorldQuery, F: QueryFilter> FetchSystemParam<'a> for FetchQuery<Q, F> {
+    type Item = Query<'a, Q, F>;
+
     #[inline]
     unsafe fn get_param(
-        _input: &mut Option<Input>,
-        system_state: &mut SystemState,
-        world: &World,
-        _resources: &Resources,
-    ) -> Option<Self> {
-        let query_index = system_state.current_query_index;
-        let world: &'a World = std::mem::transmute(world);
+        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> =
-            std::mem::transmute(&system_state.query_archetype_component_accesses[query_index]);
-        system_state.current_query_index += 1;
+            &system_state.query_archetype_component_accesses[query_index];
+        *system_state.current_query_index.get() += 1;
         Some(Query::new(world, archetype_component_access))
     }
 
@@ -63,16 +56,23 @@ impl<'a, Q: WorldQuery, F: QueryFilter, Input> SystemParam<Input> for Query<'a,
     }
 }
 
-impl<T: QueryTuple, Input> SystemParam<Input> for QuerySet<T> {
+pub struct FetchQuerySet<T>(PhantomData<T>);
+
+impl<T: QueryTuple> SystemParam for QuerySet<T> {
+    type Fetch = FetchQuerySet<T>;
+}
+
+impl<'a, T: QueryTuple> FetchSystemParam<'a> for FetchQuerySet<T> {
+    type Item = QuerySet<T>;
+
     #[inline]
     unsafe fn get_param(
-        _input: &mut Option<Input>,
-        system_state: &mut SystemState,
-        world: &World,
-        _resources: &Resources,
-    ) -> Option<Self> {
-        let query_index = system_state.current_query_index;
-        system_state.current_query_index += 1;
+        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],
@@ -90,26 +90,39 @@ impl<T: QueryTuple, Input> SystemParam<Input> for QuerySet<T> {
     }
 }
 
-impl<'a, Input> SystemParam<Input> for &'a mut Commands {
+pub struct FetchCommands;
+
+impl<'a> SystemParam for &'a mut Commands {
+    type Fetch = FetchCommands;
+}
+impl<'a> FetchSystemParam<'a> for FetchCommands {
+    type Item = &'a mut Commands;
+
     fn init(system_state: &mut SystemState, world: &World, _resources: &mut Resources) {
-        system_state
-            .commands
-            .set_entity_reserver(world.get_entity_reserver())
+        // SAFE: this is called with unique access to SystemState
+        unsafe {
+            (&mut *system_state.commands.get()).set_entity_reserver(world.get_entity_reserver())
+        }
     }
 
     #[inline]
     unsafe fn get_param(
-        _input: &mut Option<Input>,
-        system_state: &mut SystemState,
-        _world: &World,
-        _resources: &Resources,
-    ) -> Option<Self> {
-        let commands: &'a mut Commands = std::mem::transmute(&mut system_state.commands);
-        Some(commands)
+        system_state: &'a SystemState,
+        _world: &'a World,
+        _resources: &'a Resources,
+    ) -> Option<Self::Item> {
+        Some(&mut *system_state.commands.get())
     }
 }
 
-impl<Input> SystemParam<Input> for Arc<Mutex<Commands>> {
+pub struct FetchArcCommands;
+impl SystemParam for Arc<Mutex<Commands>> {
+    type Fetch = FetchArcCommands;
+}
+
+impl<'a> FetchSystemParam<'a> for FetchArcCommands {
+    type Item = Arc<Mutex<Commands>>;
+
     fn init(system_state: &mut SystemState, world: &World, _resources: &mut Resources) {
         system_state.arc_commands.get_or_insert_with(|| {
             let mut commands = Commands::default();
@@ -120,16 +133,23 @@ impl<Input> SystemParam<Input> for Arc<Mutex<Commands>> {
 
     #[inline]
     unsafe fn get_param(
-        _input: &mut Option<Input>,
-        system_state: &mut SystemState,
+        system_state: &SystemState,
         _world: &World,
         _resources: &Resources,
-    ) -> Option<Self> {
+    ) -> Option<Self::Item> {
         Some(system_state.arc_commands.as_ref().unwrap().clone())
     }
 }
 
-impl<'a, T: Resource, Input> SystemParam<Input> for Res<'a, T> {
+pub struct FetchRes<T>(PhantomData<T>);
+
+impl<'a, T: Resource> SystemParam for Res<'a, T> {
+    type Fetch = FetchRes<T>;
+}
+
+impl<'a, T: Resource> FetchSystemParam<'a> for FetchRes<T> {
+    type Item = Res<'a, T>;
+
     fn init(system_state: &mut SystemState, _world: &World, _resources: &mut Resources) {
         if system_state.resource_access.is_write(&TypeId::of::<T>()) {
             panic!(
@@ -144,18 +164,24 @@ impl<'a, T: Resource, Input> SystemParam<Input> for Res<'a, T> {
 
     #[inline]
     unsafe fn get_param(
-        _input: &mut Option<Input>,
-        _system_state: &mut SystemState,
-        _world: &World,
-        resources: &Resources,
-    ) -> Option<Self> {
+        _system_state: &'a SystemState,
+        _world: &'a World,
+        resources: &'a Resources,
+    ) -> Option<Self::Item> {
         Some(Res::new(
             resources.get_unsafe_ref::<T>(ResourceIndex::Global),
         ))
     }
 }
 
-impl<'a, T: Resource, Input> SystemParam<Input> for ResMut<'a, T> {
+pub struct FetchResMut<T>(PhantomData<T>);
+
+impl<'a, T: Resource> SystemParam for ResMut<'a, T> {
+    type Fetch = FetchResMut<T>;
+}
+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.
@@ -175,18 +201,25 @@ impl<'a, T: Resource, Input> SystemParam<Input> for ResMut<'a, T> {
 
     #[inline]
     unsafe fn get_param(
-        _input: &mut Option<Input>,
-        _system_state: &mut SystemState,
-        _world: &World,
-        resources: &Resources,
-    ) -> Option<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, mutated))
     }
 }
 
-impl<'a, T: Resource, Input> SystemParam<Input> for ChangedRes<'a, T> {
+pub struct FetchChangedRes<T>(PhantomData<T>);
+
+impl<'a, T: Resource> SystemParam for ChangedRes<'a, T> {
+    type Fetch = FetchChangedRes<T>;
+}
+
+impl<'a, T: Resource> FetchSystemParam<'a> for FetchChangedRes<T> {
+    type Item = ChangedRes<'a, T>;
+
     fn init(system_state: &mut SystemState, _world: &World, _resources: &mut Resources) {
         if system_state.resource_access.is_write(&TypeId::of::<T>()) {
             panic!(
@@ -201,11 +234,10 @@ impl<'a, T: Resource, Input> SystemParam<Input> for ChangedRes<'a, T> {
 
     #[inline]
     unsafe fn get_param(
-        _input: &mut Option<Input>,
-        _system_state: &mut SystemState,
-        _world: &World,
-        resources: &Resources,
-    ) -> Option<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);
         if *added.as_ptr() || *mutated.as_ptr() {
@@ -216,7 +248,14 @@ impl<'a, T: Resource, Input> SystemParam<Input> for ChangedRes<'a, T> {
     }
 }
 
-impl<'a, T: Resource + FromResources, Input> SystemParam<Input> for Local<'a, T> {
+pub struct FetchLocal<T>(PhantomData<T>);
+
+impl<'a, T: Resource + FromResources> SystemParam for Local<'a, T> {
+    type Fetch = FetchLocal<T>;
+}
+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
@@ -244,52 +283,61 @@ impl<'a, T: Resource + FromResources, Input> SystemParam<Input> for Local<'a, T>
 
     #[inline]
     unsafe fn get_param(
-        _input: &mut Option<Input>,
-        system_state: &mut SystemState,
-        _world: &World,
-        resources: &Resources,
-    ) -> Option<Self> {
+        system_state: &'a SystemState,
+        _world: &'a World,
+        resources: &'a Resources,
+    ) -> Option<Self::Item> {
         Some(Local::new(resources, system_state.id))
     }
 }
 
+pub struct FetchParamTuple<T>(PhantomData<T>);
+pub struct FetchOr<T>(PhantomData<T>);
+
 macro_rules! impl_system_param_tuple {
     ($($param: ident),*) => {
+        impl<$($param: SystemParam),*> SystemParam for ($($param,)*) {
+            type Fetch = FetchParamTuple<($($param::Fetch,)*)>;
+        }
         #[allow(unused_variables)]
-        impl<Input, $($param: SystemParam<Input>),*> SystemParam<Input> for ($($param,)*) {
+        impl<'a, $($param: FetchSystemParam<'a>),*> FetchSystemParam<'a> for FetchParamTuple<($($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(
-                input: &mut Option<Input>,
-                system_state: &mut SystemState,
-                world: &World,
-                resources: &Resources,
-            ) -> Option<Self> {
-                Some(($($param::get_param(input, system_state, world, resources)?,)*))
+                system_state: &'a SystemState,
+                world: &'a World,
+                resources: &'a Resources,
+            ) -> Option<Self::Item> {
+                Some(($($param::get_param(system_state, world, resources)?,)*))
             }
         }
 
+        impl<$($param: SystemParam),*> SystemParam for Or<($(Option<$param>,)*)> {
+            type Fetch = FetchOr<($($param::Fetch,)*)>;
+        }
+
         #[allow(unused_variables)]
         #[allow(unused_mut)]
         #[allow(non_snake_case)]
-        impl<Input, $($param: SystemParam<Input>),*> SystemParam<Input> for Or<($(Option<$param>,)*)> {
+        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);)*
             }
 
             #[inline]
             unsafe fn get_param(
-                input: &mut Option<Input>,
-                system_state: &mut SystemState,
-                world: &World,
-                resources: &Resources,
-            ) -> Option<Self> {
+                system_state: &'a SystemState,
+                world: &'a World,
+                resources: &'a Resources,
+            ) -> Option<Self::Item> {
                 let mut has_some = false;
                 $(
-                    let $param = $param::get_param(input, system_state, world, resources);
+                    let $param = $param::get_param(system_state, world, resources);
                     if $param.is_some() {
                         has_some = true;
                     }
diff --git a/crates/bevy_gilrs/Cargo.toml b/crates/bevy_gilrs/Cargo.toml
index 4adb09b0278c7..2480e7f7b2f51 100644
--- a/crates/bevy_gilrs/Cargo.toml
+++ b/crates/bevy_gilrs/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_gilrs"
-version = "0.3.0"
+version = "0.4.0"
 edition = "2018"
 authors = ["Bevy Contributors <bevyengine@gmail.com>", "Carter Anderson <mcanders1@gmail.com>"]
 description = "Gamepad system made using Gilrs for Bevy Engine"
@@ -11,10 +11,10 @@ keywords = ["bevy"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.3.0" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.3.0" }
-bevy_input = { path = "../bevy_input", version = "0.3.0" }
-bevy_utils = { path = "../bevy_utils", version = "0.3.0" }
+bevy_app = { path = "../bevy_app", version = "0.4.0" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.4.0" }
+bevy_input = { path = "../bevy_input", version = "0.4.0" }
+bevy_utils = { path = "../bevy_utils", version = "0.4.0" }
 
 # other
 gilrs = "0.8.0"
\ No newline at end of file
diff --git a/crates/bevy_gilrs/src/lib.rs b/crates/bevy_gilrs/src/lib.rs
index f07d925709f37..0149a16fd98e3 100644
--- a/crates/bevy_gilrs/src/lib.rs
+++ b/crates/bevy_gilrs/src/lib.rs
@@ -2,6 +2,7 @@ mod converter;
 mod gilrs_system;
 
 use bevy_app::{prelude::*, startup_stage::PRE_STARTUP};
+use bevy_ecs::IntoSystem;
 use bevy_utils::tracing::error;
 use gilrs::GilrsBuilder;
 use gilrs_system::{gilrs_event_startup_system, gilrs_event_system};
@@ -18,8 +19,8 @@ impl Plugin for GilrsPlugin {
         {
             Ok(gilrs) => {
                 app.add_thread_local_resource(gilrs)
-                    .add_startup_system_to_stage(PRE_STARTUP, gilrs_event_startup_system)
-                    .add_system_to_stage(stage::PRE_EVENT, gilrs_event_system);
+                    .add_startup_system_to_stage(PRE_STARTUP, gilrs_event_startup_system.system())
+                    .add_system_to_stage(stage::PRE_EVENT, gilrs_event_system.system());
             }
             Err(err) => error!("Failed to start Gilrs. {}", err),
         }
diff --git a/crates/bevy_gltf/Cargo.toml b/crates/bevy_gltf/Cargo.toml
index 65f7f9563a8bd..1b0937e69a160 100644
--- a/crates/bevy_gltf/Cargo.toml
+++ b/crates/bevy_gltf/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_gltf"
-version = "0.3.0"
+version = "0.4.0"
 edition = "2018"
 authors = [
     "Bevy Contributors <bevyengine@gmail.com>",
@@ -14,15 +14,15 @@ keywords = ["bevy"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.3.0" }
-bevy_asset = { path = "../bevy_asset", version = "0.3.0" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.3.0" }
-bevy_pbr = { path = "../bevy_pbr", version = "0.3.0" }
-bevy_render = { path = "../bevy_render", version = "0.3.0" }
-bevy_transform = { path = "../bevy_transform", version = "0.3.0" }
-bevy_math = { path = "../bevy_math", version = "0.3.0" }
-bevy_scene = { path = "../bevy_scene", version = "0.3.0" }
-bevy_type_registry = { path = "../bevy_type_registry", version = "0.3.0" }
+bevy_app = { path = "../bevy_app", version = "0.4.0" }
+bevy_asset = { path = "../bevy_asset", version = "0.4.0" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.4.0" }
+bevy_pbr = { path = "../bevy_pbr", version = "0.4.0" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.4.0", features = ["bevy"] }
+bevy_render = { path = "../bevy_render", version = "0.4.0" }
+bevy_transform = { path = "../bevy_transform", version = "0.4.0" }
+bevy_math = { path = "../bevy_math", version = "0.4.0" }
+bevy_scene = { path = "../bevy_scene", version = "0.4.0" }
 
 # other
 gltf = { version = "0.15.2", default-features = false, features = ["utils"] }
diff --git a/crates/bevy_gltf/src/loader.rs b/crates/bevy_gltf/src/loader.rs
index a6b7e1384951f..25bad7a423cc9 100644
--- a/crates/bevy_gltf/src/loader.rs
+++ b/crates/bevy_gltf/src/loader.rs
@@ -11,7 +11,9 @@ use bevy_render::{
     pipeline::PrimitiveTopology,
     prelude::{Color, Texture},
     render_graph::base,
-    texture::{AddressMode, FilterMode, SamplerDescriptor, TextureFormat},
+    texture::{
+        AddressMode, Extent3d, FilterMode, SamplerDescriptor, TextureDimension, TextureFormat,
+    },
 };
 use bevy_scene::Scene;
 use bevy_transform::{
@@ -21,7 +23,7 @@ use bevy_transform::{
 use gltf::{
     mesh::Mode,
     texture::{MagFilter, MinFilter, WrappingMode},
-    Primitive,
+    Material, Primitive,
 };
 use image::{GenericImageView, ImageFormat};
 use std::path::Path;
@@ -30,23 +32,23 @@ use thiserror::Error;
 /// An error that occurs when loading a GLTF file
 #[derive(Error, Debug)]
 pub enum GltfError {
-    #[error("Unsupported primitive mode.")]
+    #[error("unsupported primitive mode")]
     UnsupportedPrimitive { mode: Mode },
-    #[error("Unsupported min filter.")]
+    #[error("unsupported min filter")]
     UnsupportedMinFilter { filter: MinFilter },
-    #[error("Invalid GLTF file.")]
+    #[error("invalid GLTF file")]
     Gltf(#[from] gltf::Error),
-    #[error("Binary blob is missing.")]
+    #[error("binary blob is missing")]
     MissingBlob,
-    #[error("Failed to decode base64 mesh data.")]
+    #[error("failed to decode base64 mesh data")]
     Base64Decode(#[from] base64::DecodeError),
-    #[error("Unsupported buffer format.")]
+    #[error("unsupported buffer format")]
     BufferFormatUnsupported,
-    #[error("Invalid image mime type.")]
+    #[error("invalid image mime type")]
     InvalidImageMimeType(String),
-    #[error("Failed to load an image.")]
+    #[error("failed to load an image")]
     ImageError(#[from] image::ImageError),
-    #[error("Failed to load an asset path.")]
+    #[error("failed to load an asset path")]
     AssetIoError(#[from] AssetIoError),
 }
 
@@ -136,7 +138,8 @@ async fn load_gltf<'a, 'b>(
                 &texture_label,
                 LoadedAsset::new(Texture {
                     data: image.clone().into_vec(),
-                    size: bevy_math::f32::vec2(size.0 as f32, size.1 as f32),
+                    size: Extent3d::new(size.0, size.1, 1),
+                    dimension: TextureDimension::D2,
                     format: TextureFormat::Rgba8Unorm,
                     sampler: texture_sampler(&texture)?,
                 }),
@@ -145,38 +148,7 @@ async fn load_gltf<'a, 'b>(
     }
 
     for material in gltf.materials() {
-        let material_label = material_label(&material);
-        let pbr = material.pbr_metallic_roughness();
-        let mut dependencies = Vec::new();
-        let texture_handle = if let Some(info) = pbr.base_color_texture() {
-            match info.texture().source().source() {
-                gltf::image::Source::View { .. } => {
-                    let label = texture_label(&info.texture());
-                    let path = AssetPath::new_ref(load_context.path(), Some(&label));
-                    Some(load_context.get_handle(path))
-                }
-                gltf::image::Source::Uri { uri, .. } => {
-                    let parent = load_context.path().parent().unwrap();
-                    let image_path = parent.join(uri);
-                    let asset_path = AssetPath::new(image_path, None);
-                    let handle = load_context.get_handle(asset_path.clone());
-                    dependencies.push(asset_path);
-                    Some(handle)
-                }
-            }
-        } else {
-            None
-        };
-        let color = pbr.base_color_factor();
-        load_context.set_labeled_asset(
-            &material_label,
-            LoadedAsset::new(StandardMaterial {
-                albedo: Color::rgba(color[0], color[1], color[2], color[3]),
-                albedo_texture: texture_handle,
-                ..Default::default()
-            })
-            .with_dependencies(dependencies),
-        )
+        load_material(&material, load_context);
     }
 
     for scene in gltf.scenes() {
@@ -202,6 +174,42 @@ async fn load_gltf<'a, 'b>(
     Ok(())
 }
 
+fn load_material(material: &Material, load_context: &mut LoadContext) {
+    let material_label = material_label(&material);
+    let pbr = material.pbr_metallic_roughness();
+    let mut dependencies = Vec::new();
+    let texture_handle = if let Some(info) = pbr.base_color_texture() {
+        match info.texture().source().source() {
+            gltf::image::Source::View { .. } => {
+                let label = texture_label(&info.texture());
+                let path = AssetPath::new_ref(load_context.path(), Some(&label));
+                Some(load_context.get_handle(path))
+            }
+            gltf::image::Source::Uri { uri, .. } => {
+                let parent = load_context.path().parent().unwrap();
+                let image_path = parent.join(uri);
+                let asset_path = AssetPath::new(image_path, None);
+                let handle = load_context.get_handle(asset_path.clone());
+                dependencies.push(asset_path);
+                Some(handle)
+            }
+        }
+    } else {
+        None
+    };
+
+    let color = pbr.base_color_factor();
+    load_context.set_labeled_asset(
+        &material_label,
+        LoadedAsset::new(StandardMaterial {
+            albedo: Color::rgba(color[0], color[1], color[2], color[3]),
+            albedo_texture: texture_handle,
+            ..Default::default()
+        })
+        .with_dependencies(dependencies),
+    )
+}
+
 fn load_node(
     gltf_node: &gltf::Node,
     world_builder: &mut WorldChildBuilder,
@@ -236,7 +244,7 @@ fn load_node(
                 };
 
                 node.with(Camera {
-                    name: Some(base::camera::CAMERA2D.to_owned()),
+                    name: Some(base::camera::CAMERA_2D.to_owned()),
                     projection_matrix: orthographic_projection.get_projection_matrix(),
                     ..Default::default()
                 });
@@ -255,7 +263,7 @@ fn load_node(
                     perspective_projection.aspect_ratio = aspect_ratio;
                 }
                 node.with(Camera {
-                    name: Some(base::camera::CAMERA3D.to_owned()),
+                    name: Some(base::camera::CAMERA_3D.to_owned()),
                     projection_matrix: perspective_projection.get_projection_matrix(),
                     ..Default::default()
                 });
@@ -268,13 +276,22 @@ fn load_node(
         if let Some(mesh) = gltf_node.mesh() {
             // append primitives
             for primitive in mesh.primitives() {
+                let material = primitive.material();
+                let material_label = material_label(&material);
+
+                // This will make sure we load the default material now since it would not have been
+                // added when iterating over all the gltf materials (since the default material is
+                // not explicitly listed in the gltf).
+                if !load_context.has_labeled_asset(&material_label) {
+                    load_material(&material, load_context);
+                }
+
                 let primitive_label = primitive_label(&mesh, &primitive);
                 let mesh_asset_path =
                     AssetPath::new_ref(load_context.path(), Some(&primitive_label));
-                let material = primitive.material();
-                let material_label = material_label(&material);
                 let material_asset_path =
                     AssetPath::new_ref(load_context.path(), Some(&material_label));
+
                 parent.spawn(PbrBundle {
                     mesh: load_context.get_handle(mesh_asset_path),
                     material: load_context.get_handle(material_asset_path),
diff --git a/crates/bevy_input/Cargo.toml b/crates/bevy_input/Cargo.toml
index 0c4e22807fe7b..5349a01dbb7cc 100644
--- a/crates/bevy_input/Cargo.toml
+++ b/crates/bevy_input/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_input"
-version = "0.3.0"
+version = "0.4.0"
 edition = "2018"
 authors = [
     "Bevy Contributors <bevyengine@gmail.com>",
@@ -18,10 +18,10 @@ serialize = ["serde"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.3.0" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.3.0" }
-bevy_math = { path = "../bevy_math", version = "0.3.0" }
-bevy_utils = { path = "../bevy_utils", version = "0.3.0" }
+bevy_app = { path = "../bevy_app", version = "0.4.0" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.4.0" }
+bevy_math = { path = "../bevy_math", version = "0.4.0" }
+bevy_utils = { path = "../bevy_utils", version = "0.4.0" }
 
 # other
 serde = { version = "1", features = ["derive"], optional = true }
diff --git a/crates/bevy_input/src/input.rs b/crates/bevy_input/src/input.rs
index 72876dcd2da09..31e0b9980c4b0 100644
--- a/crates/bevy_input/src/input.rs
+++ b/crates/bevy_input/src/input.rs
@@ -71,3 +71,80 @@ where
         self.just_released.iter()
     }
 }
+
+#[cfg(test)]
+mod test {
+
+    #[test]
+    fn input_test() {
+        use crate::Input;
+
+        /// Used for testing `Input` functionality
+        #[derive(Copy, Clone, Eq, PartialEq, Hash)]
+        enum DummyInput {
+            Input1,
+            Input2,
+        }
+
+        let mut input = Input::default();
+
+        // Test pressing
+        input.press(DummyInput::Input1);
+        input.press(DummyInput::Input2);
+
+        // Check if they were "just pressed" (pressed on this update)
+        assert!(input.just_pressed(DummyInput::Input1));
+        assert!(input.just_pressed(DummyInput::Input2));
+
+        // Check if they are also marked as pressed
+        assert!(input.pressed(DummyInput::Input1));
+        assert!(input.pressed(DummyInput::Input2));
+
+        // Update the `Input` and check press state
+        input.update();
+
+        // Check if they're marked "just pressed"
+        assert!(!input.just_pressed(DummyInput::Input1));
+        assert!(!input.just_pressed(DummyInput::Input2));
+
+        // Check if they're marked as pressed
+        assert!(input.pressed(DummyInput::Input1));
+        assert!(input.pressed(DummyInput::Input2));
+
+        // Release the inputs and check state
+
+        input.release(DummyInput::Input1);
+        input.release(DummyInput::Input2);
+
+        // Check if they're marked as "just released" (released on this update)
+        assert!(input.just_released(DummyInput::Input1));
+        assert!(input.just_released(DummyInput::Input2));
+
+        // Check that they're not incorrectly marked as pressed
+        assert!(!input.pressed(DummyInput::Input1));
+        assert!(!input.pressed(DummyInput::Input2));
+
+        // Update the `Input` and check for removal from `just_released`
+
+        input.update();
+
+        // Check that they're not incorrectly marked as just released
+        assert!(!input.just_released(DummyInput::Input1));
+        assert!(!input.just_released(DummyInput::Input2));
+
+        // Set up an `Input` to test resetting.
+        let mut input = Input::default();
+
+        input.press(DummyInput::Input1);
+        input.release(DummyInput::Input2);
+
+        // Reset the `Input` and test it was reset correctly.
+        input.reset(DummyInput::Input1);
+        input.reset(DummyInput::Input2);
+
+        assert!(!input.just_pressed(DummyInput::Input1));
+        assert!(!input.pressed(DummyInput::Input1));
+
+        assert!(!input.just_released(DummyInput::Input2));
+    }
+}
diff --git a/crates/bevy_input/src/lib.rs b/crates/bevy_input/src/lib.rs
index a21fbca1e4b69..ba81fc2bab987 100644
--- a/crates/bevy_input/src/lib.rs
+++ b/crates/bevy_input/src/lib.rs
@@ -7,6 +7,7 @@ pub mod system;
 pub mod touch;
 
 pub use axis::*;
+use bevy_ecs::IntoSystem;
 pub use input::*;
 
 pub mod prelude {
@@ -27,7 +28,6 @@ use keyboard::{keyboard_input_system, KeyCode, KeyboardInput};
 use mouse::{mouse_button_input_system, MouseButton, MouseButtonInput, MouseMotion, MouseWheel};
 use touch::{touch_screen_input_system, TouchInput, Touches};
 
-use bevy_app::startup_stage::STARTUP;
 use gamepad::{
     gamepad_event_system, GamepadAxis, GamepadButton, GamepadEvent, GamepadEventRaw,
     GamepadSettings,
@@ -44,20 +44,23 @@ impl Plugin for InputPlugin {
             .add_event::<MouseMotion>()
             .add_event::<MouseWheel>()
             .init_resource::<Input<KeyCode>>()
-            .add_system_to_stage(bevy_app::stage::EVENT, keyboard_input_system)
+            .add_system_to_stage(bevy_app::stage::EVENT, keyboard_input_system.system())
             .init_resource::<Input<MouseButton>>()
-            .add_system_to_stage(bevy_app::stage::EVENT, mouse_button_input_system)
+            .add_system_to_stage(bevy_app::stage::EVENT, mouse_button_input_system.system())
             .add_event::<GamepadEvent>()
             .add_event::<GamepadEventRaw>()
             .init_resource::<GamepadSettings>()
             .init_resource::<Input<GamepadButton>>()
             .init_resource::<Axis<GamepadAxis>>()
             .init_resource::<Axis<GamepadButton>>()
-            .add_system_to_stage(bevy_app::stage::EVENT, gamepad_event_system)
-            .add_startup_system_to_stage(STARTUP, gamepad_event_system)
+            .add_system_to_stage(bevy_app::stage::EVENT, gamepad_event_system.system())
+            .add_startup_system_to_stage(
+                bevy_app::startup_stage::STARTUP,
+                gamepad_event_system.system(),
+            )
             .add_event::<TouchInput>()
             .init_resource::<Touches>()
-            .add_system_to_stage(bevy_app::stage::EVENT, touch_screen_input_system);
+            .add_system_to_stage(bevy_app::stage::EVENT, touch_screen_input_system.system());
     }
 }
 
diff --git a/crates/bevy_input/src/mouse.rs b/crates/bevy_input/src/mouse.rs
index 3123785fb069a..f20cfb7331c6d 100644
--- a/crates/bevy_input/src/mouse.rs
+++ b/crates/bevy_input/src/mouse.rs
@@ -17,7 +17,7 @@ pub enum MouseButton {
     Left,
     Right,
     Middle,
-    Other(u8),
+    Other(u16),
 }
 
 /// A mouse motion event
diff --git a/crates/bevy_input/src/touch.rs b/crates/bevy_input/src/touch.rs
index 9e78f7d05bedf..31f65d2477924 100644
--- a/crates/bevy_input/src/touch.rs
+++ b/crates/bevy_input/src/touch.rs
@@ -2,7 +2,6 @@ use bevy_app::{EventReader, Events};
 use bevy_ecs::{Local, Res, ResMut};
 use bevy_math::Vec2;
 use bevy_utils::HashMap;
-use core::ops::DerefMut;
 
 /// Represents a touch event
 ///
@@ -85,13 +84,13 @@ pub struct TouchSystemState {
 
 #[derive(Debug, Clone, Copy)]
 pub struct Touch {
-    pub id: u64,
-    pub start_position: Vec2,
-    pub start_force: Option<ForceTouch>,
-    pub previous_position: Vec2,
-    pub previous_force: Option<ForceTouch>,
-    pub position: Vec2,
-    pub force: Option<ForceTouch>,
+    id: u64,
+    start_position: Vec2,
+    start_force: Option<ForceTouch>,
+    previous_position: Vec2,
+    previous_force: Option<ForceTouch>,
+    position: Vec2,
+    force: Option<ForceTouch>,
 }
 
 impl Touch {
@@ -102,6 +101,36 @@ impl Touch {
     pub fn distance(&self) -> Vec2 {
         self.position - self.start_position
     }
+
+    #[inline]
+    pub fn id(&self) -> u64 {
+        self.id
+    }
+
+    #[inline]
+    pub fn start_position(&self) -> Vec2 {
+        self.start_position
+    }
+
+    #[inline]
+    pub fn start_force(&self) -> Option<ForceTouch> {
+        self.start_force
+    }
+
+    #[inline]
+    pub fn previous_position(&self) -> Vec2 {
+        self.previous_position
+    }
+
+    #[inline]
+    pub fn position(&self) -> Vec2 {
+        self.position
+    }
+
+    #[inline]
+    pub fn force(&self) -> Option<ForceTouch> {
+        self.force
+    }
 }
 
 impl From<&TouchInput> for Touch {
@@ -139,10 +168,8 @@ impl Touches {
         self.just_pressed.contains_key(&id)
     }
 
-    pub fn iter_just_pressed(&self) -> impl Iterator<Item = &Touch> + '_ {
-        self.just_pressed
-            .iter()
-            .map(move |(id, _)| self.pressed.get(id).unwrap())
+    pub fn iter_just_pressed(&self) -> impl Iterator<Item = &Touch> {
+        self.just_pressed.values()
     }
 
     pub fn get_released(&self, id: u64) -> Option<&Touch> {
@@ -153,54 +180,234 @@ impl Touches {
         self.just_released.contains_key(&id)
     }
 
-    pub fn iter_just_released(&self) -> impl Iterator<Item = &Touch> + '_ {
-        self.just_released
-            .iter()
-            .map(move |(id, _)| self.pressed.get(id).unwrap())
+    pub fn iter_just_released(&self) -> impl Iterator<Item = &Touch> {
+        self.just_released.values()
     }
 
     pub fn just_cancelled(&self, id: u64) -> bool {
         self.just_cancelled.contains_key(&id)
     }
 
-    pub fn iter_just_cancelled(&self) -> impl Iterator<Item = &Touch> + '_ {
-        self.just_cancelled
-            .iter()
-            .map(move |(id, _)| self.pressed.get(id).unwrap())
+    pub fn iter_just_cancelled(&self) -> impl Iterator<Item = &Touch> {
+        self.just_cancelled.values()
     }
-}
 
-/// Updates the Touches resource with the latest TouchInput events
-pub fn touch_screen_input_system(
-    mut state: Local<TouchSystemState>,
-    mut touch_state: ResMut<Touches>,
-    touch_input_events: Res<Events<TouchInput>>,
-) {
-    let touch_state = touch_state.deref_mut();
-    touch_state.just_pressed.clear();
-    touch_state.just_released.clear();
-    for event in state.touch_event_reader.iter(&touch_input_events) {
+    fn process_touch_event(&mut self, event: &TouchInput) {
         match event.phase {
             TouchPhase::Started => {
-                touch_state.pressed.insert(event.id, event.into());
-                touch_state.just_pressed.insert(event.id, event.into());
+                self.pressed.insert(event.id, event.into());
+                self.just_pressed.insert(event.id, event.into());
             }
             TouchPhase::Moved => {
-                let mut new_touch = touch_state.pressed.get(&event.id).cloned().unwrap();
+                let mut new_touch = self.pressed.get(&event.id).cloned().unwrap();
                 new_touch.previous_position = new_touch.position;
                 new_touch.previous_force = new_touch.force;
                 new_touch.position = event.position;
                 new_touch.force = event.force;
-                touch_state.pressed.insert(event.id, new_touch);
+                self.pressed.insert(event.id, new_touch);
             }
             TouchPhase::Ended => {
-                touch_state.just_released.insert(event.id, event.into());
-                touch_state.pressed.remove_entry(&event.id);
+                self.just_released.insert(event.id, event.into());
+                self.pressed.remove_entry(&event.id);
             }
             TouchPhase::Cancelled => {
-                touch_state.just_cancelled.insert(event.id, event.into());
-                touch_state.pressed.remove_entry(&event.id);
+                self.just_cancelled.insert(event.id, event.into());
+                self.pressed.remove_entry(&event.id);
             }
         };
     }
+
+    fn update(&mut self) {
+        self.just_pressed.clear();
+        self.just_released.clear();
+        self.just_cancelled.clear();
+    }
+}
+
+/// Updates the Touches resource with the latest TouchInput events
+pub fn touch_screen_input_system(
+    mut state: Local<TouchSystemState>,
+    mut touch_state: ResMut<Touches>,
+    touch_input_events: Res<Events<TouchInput>>,
+) {
+    touch_state.update();
+
+    for event in state.touch_event_reader.iter(&touch_input_events) {
+        touch_state.process_touch_event(event);
+    }
+}
+
+#[cfg(test)]
+mod test {
+
+    #[test]
+    fn touch_update() {
+        use crate::{touch::Touch, Touches};
+        use bevy_math::Vec2;
+
+        let mut touches = Touches::default();
+
+        let touch_event = Touch {
+            id: 4,
+            start_position: Vec2::new(0.0, 0.0),
+            start_force: None,
+            previous_position: Vec2::new(0.0, 0.0),
+            previous_force: None,
+            position: Vec2::new(0.0, 0.0),
+            force: None,
+        };
+
+        // Add a touch to `just_pressed`, 'just_released', and 'just cancelled'
+
+        touches.just_pressed.insert(4, touch_event);
+        touches.just_released.insert(4, touch_event);
+        touches.just_cancelled.insert(4, touch_event);
+
+        touches.update();
+
+        // Verify that all the `just_x` maps are cleared
+        assert!(touches.just_pressed.is_empty());
+        assert!(touches.just_released.is_empty());
+        assert!(touches.just_cancelled.is_empty());
+    }
+
+    #[test]
+    fn touch_process() {
+        use crate::{touch::TouchPhase, TouchInput, Touches};
+        use bevy_math::Vec2;
+
+        let mut touches = Touches::default();
+
+        // Test adding a `TouchPhase::Started`
+
+        let touch_event = TouchInput {
+            phase: TouchPhase::Started,
+            position: Vec2::new(4.0, 4.0),
+            force: None,
+            id: 4,
+        };
+
+        touches.update();
+        touches.process_touch_event(&touch_event);
+
+        assert!(touches.pressed.get(&touch_event.id).is_some());
+        assert!(touches.just_pressed.get(&touch_event.id).is_some());
+
+        // Test adding a `TouchPhase::Moved`
+
+        let moved_touch_event = TouchInput {
+            phase: TouchPhase::Moved,
+            position: Vec2::new(5.0, 5.0),
+            force: None,
+            id: touch_event.id,
+        };
+
+        touches.update();
+        touches.process_touch_event(&moved_touch_event);
+
+        assert_eq!(
+            touches
+                .pressed
+                .get(&moved_touch_event.id)
+                .expect("Missing from pressed after move.")
+                .previous_position,
+            touch_event.position
+        );
+
+        // Test cancelling an event
+
+        let cancel_touch_event = TouchInput {
+            phase: TouchPhase::Cancelled,
+            position: Vec2::new(1.0, 1.0),
+            force: None,
+            id: touch_event.id,
+        };
+
+        touches.update();
+        touches.process_touch_event(&cancel_touch_event);
+
+        assert!(touches.just_cancelled.get(&cancel_touch_event.id).is_some());
+        assert!(touches.pressed.get(&cancel_touch_event.id).is_none());
+
+        // Test ending an event
+
+        let end_touch_event = TouchInput {
+            phase: TouchPhase::Ended,
+            position: Vec2::new(4.0, 4.0),
+            force: None,
+            id: 4,
+        };
+
+        touches.update();
+        touches.process_touch_event(&touch_event);
+        touches.process_touch_event(&end_touch_event);
+
+        assert!(touches.just_released.get(&touch_event.id).is_some());
+        assert!(touches.pressed.get(&touch_event.id).is_none());
+    }
+
+    #[test]
+    fn touch_pressed() {
+        use crate::{touch::TouchPhase, TouchInput, Touches};
+        use bevy_math::Vec2;
+
+        let mut touches = Touches::default();
+
+        let touch_event = TouchInput {
+            phase: TouchPhase::Started,
+            position: Vec2::new(4.0, 4.0),
+            force: None,
+            id: 4,
+        };
+
+        // Register the touch and test that it was registered correctly
+        touches.process_touch_event(&touch_event);
+
+        assert!(touches.get_pressed(touch_event.id).is_some());
+        assert!(touches.just_pressed(touch_event.id));
+        assert_eq!(touches.iter().count(), 1);
+    }
+
+    #[test]
+    fn touch_released() {
+        use crate::{touch::TouchPhase, TouchInput, Touches};
+        use bevy_math::Vec2;
+
+        let mut touches = Touches::default();
+
+        let touch_event = TouchInput {
+            phase: TouchPhase::Ended,
+            position: Vec2::new(4.0, 4.0),
+            force: None,
+            id: 4,
+        };
+
+        // Register the touch and test that it was registered correctly
+        touches.process_touch_event(&touch_event);
+
+        assert!(touches.get_released(touch_event.id).is_some());
+        assert!(touches.just_released(touch_event.id));
+        assert_eq!(touches.iter_just_released().count(), 1);
+    }
+
+    #[test]
+    fn touch_cancelled() {
+        use crate::{touch::TouchPhase, TouchInput, Touches};
+        use bevy_math::Vec2;
+
+        let mut touches = Touches::default();
+
+        let touch_event = TouchInput {
+            phase: TouchPhase::Cancelled,
+            position: Vec2::new(4.0, 4.0),
+            force: None,
+            id: 4,
+        };
+
+        // Register the touch and test that it was registered correctly
+        touches.process_touch_event(&touch_event);
+
+        assert!(touches.just_cancelled(touch_event.id));
+        assert_eq!(touches.iter_just_cancelled().count(), 1);
+    }
 }
diff --git a/crates/bevy_internal/Cargo.toml b/crates/bevy_internal/Cargo.toml
index 41bc4ffdbab47..b2ee4dffb293f 100644
--- a/crates/bevy_internal/Cargo.toml
+++ b/crates/bevy_internal/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_internal"
-version = "0.3.0"
+version = "0.4.0"
 edition = "2018"
 authors = [
     "Bevy Contributors <bevyengine@gmail.com>",
@@ -21,6 +21,9 @@ trace_chrome = [ "bevy_log/tracing-chrome" ]
 # Image format support for texture loading (PNG and HDR are enabled by default)
 hdr = ["bevy_render/hdr"]
 png = ["bevy_render/png"]
+dds = ["bevy_render/dds"]
+tga = ["bevy_render/tga"]
+jpeg = ["bevy_render/jpeg"]
 
 # Audio format support (MP3 is enabled by default)
 flac = ["bevy_audio/flac"]
@@ -36,34 +39,33 @@ x11 = ["bevy_winit/x11"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.3.0" }
-bevy_asset = { path = "../bevy_asset", version = "0.3.0" }
-bevy_type_registry = { path = "../bevy_type_registry", version = "0.3.0" }
-bevy_core = { path = "../bevy_core", version = "0.3.0" }
-bevy_derive = { path = "../bevy_derive", version = "0.3.0" }
-bevy_diagnostic = { path = "../bevy_diagnostic", version = "0.3.0" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.3.0" }
-bevy_input = { path = "../bevy_input", version = "0.3.0" }
-bevy_log = { path = "../bevy_log", version = "0.3.0" }
-bevy_math = { path = "../bevy_math", version = "0.3.0" }
-bevy_property = { path = "../bevy_property", version = "0.3.0" }
-bevy_scene = { path = "../bevy_scene", version = "0.3.0" }
-bevy_transform = { path = "../bevy_transform", version = "0.3.0" }
-bevy_utils = { path = "../bevy_utils", version = "0.3.0" }
-bevy_window = { path = "../bevy_window", version = "0.3.0" }
-bevy_tasks = { path = "../bevy_tasks", version = "0.3.0" }
+bevy_app = { path = "../bevy_app", version = "0.4.0" }
+bevy_asset = { path = "../bevy_asset", version = "0.4.0" }
+bevy_core = { path = "../bevy_core", version = "0.4.0" }
+bevy_derive = { path = "../bevy_derive", version = "0.4.0" }
+bevy_diagnostic = { path = "../bevy_diagnostic", version = "0.4.0" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.4.0" }
+bevy_input = { path = "../bevy_input", version = "0.4.0" }
+bevy_log = { path = "../bevy_log", version = "0.4.0" }
+bevy_math = { path = "../bevy_math", version = "0.4.0" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.4.0", features = ["bevy"] }
+bevy_scene = { path = "../bevy_scene", version = "0.4.0" }
+bevy_transform = { path = "../bevy_transform", version = "0.4.0" }
+bevy_utils = { path = "../bevy_utils", version = "0.4.0" }
+bevy_window = { path = "../bevy_window", version = "0.4.0" }
+bevy_tasks = { path = "../bevy_tasks", version = "0.4.0" }
 # bevy (optional)
-bevy_audio = { path = "../bevy_audio", optional = true, version = "0.3.0" }
-bevy_gltf = { path = "../bevy_gltf", optional = true, version = "0.3.0" }
-bevy_pbr = { path = "../bevy_pbr", optional = true, version = "0.3.0" }
-bevy_render = { path = "../bevy_render", optional = true, version = "0.3.0" }
-bevy_dynamic_plugin = { path = "../bevy_dynamic_plugin", optional = true, version = "0.3.0" }
-bevy_sprite = { path = "../bevy_sprite", optional = true, version = "0.3.0" }
-bevy_text = { path = "../bevy_text", optional = true, version = "0.3.0" }
-bevy_ui = { path = "../bevy_ui", optional = true, version = "0.3.0" }
-bevy_wgpu = { path = "../bevy_wgpu", optional = true, version = "0.3.0" }
-bevy_winit = { path = "../bevy_winit", optional = true, version = "0.3.0" }
-bevy_gilrs = { path = "../bevy_gilrs", optional = true, version = "0.3.0" }
+bevy_audio = { path = "../bevy_audio", optional = true, version = "0.4.0" }
+bevy_gltf = { path = "../bevy_gltf", optional = true, version = "0.4.0" }
+bevy_pbr = { path = "../bevy_pbr", optional = true, version = "0.4.0" }
+bevy_render = { path = "../bevy_render", optional = true, version = "0.4.0" }
+bevy_dynamic_plugin = { path = "../bevy_dynamic_plugin", optional = true, version = "0.4.0" }
+bevy_sprite = { path = "../bevy_sprite", optional = true, version = "0.4.0" }
+bevy_text = { path = "../bevy_text", optional = true, version = "0.4.0" }
+bevy_ui = { path = "../bevy_ui", optional = true, version = "0.4.0" }
+bevy_wgpu = { path = "../bevy_wgpu", optional = true, version = "0.4.0" }
+bevy_winit = { path = "../bevy_winit", optional = true, version = "0.4.0" }
+bevy_gilrs = { path = "../bevy_gilrs", optional = true, version = "0.4.0" }
 
 [target.'cfg(target_os = "android")'.dependencies]
 ndk-glue = {version = "0.2", features = ["logger"]}
diff --git a/crates/bevy_internal/src/default_plugins.rs b/crates/bevy_internal/src/default_plugins.rs
index 0af6f824ae583..e416c8b17ad7d 100644
--- a/crates/bevy_internal/src/default_plugins.rs
+++ b/crates/bevy_internal/src/default_plugins.rs
@@ -5,7 +5,7 @@ pub struct DefaultPlugins;
 impl PluginGroup for DefaultPlugins {
     fn build(&mut self, group: &mut PluginGroupBuilder) {
         group.add(bevy_log::LogPlugin::default());
-        group.add(bevy_type_registry::TypeRegistryPlugin::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 +50,7 @@ pub struct MinimalPlugins;
 
 impl PluginGroup for MinimalPlugins {
     fn build(&mut self, group: &mut PluginGroupBuilder) {
-        group.add(bevy_type_registry::TypeRegistryPlugin::default());
+        group.add(bevy_reflect::ReflectPlugin::default());
         group.add(bevy_core::CorePlugin::default());
         group.add(bevy_app::ScheduleRunnerPlugin::default());
     }
diff --git a/crates/bevy_internal/src/lib.rs b/crates/bevy_internal/src/lib.rs
index 4af34e8a8fe60..4f2450bfa66d1 100644
--- a/crates/bevy_internal/src/lib.rs
+++ b/crates/bevy_internal/src/lib.rs
@@ -44,9 +44,12 @@ pub mod math {
     pub use bevy_math::*;
 }
 
-pub mod property {
-    //! Dynamically interact with struct fields and names.
-    pub use bevy_property::*;
+pub mod reflect {
+    // TODO: remove these renames once TypeRegistryArc is no longer required
+    //! Type reflection used for dynamically interacting with rust types.
+    pub use bevy_reflect::{
+        TypeRegistry as TypeRegistryInternal, TypeRegistryArc as TypeRegistry, *,
+    };
 }
 
 pub mod scene {
@@ -64,11 +67,6 @@ pub mod transform {
     pub use bevy_transform::*;
 }
 
-pub mod type_registry {
-    //! Registered types and components can be used when loading scenes.
-    pub use bevy_type_registry::*;
-}
-
 pub mod utils {
     pub use bevy_utils::*;
 }
diff --git a/crates/bevy_internal/src/prelude.rs b/crates/bevy_internal/src/prelude.rs
index 17a8cda72c935..354ea005f293f 100644
--- a/crates/bevy_internal/src/prelude.rs
+++ b/crates/bevy_internal/src/prelude.rs
@@ -1,8 +1,7 @@
 pub use crate::{
     app::prelude::*, asset::prelude::*, core::prelude::*, ecs::prelude::*, input::prelude::*,
-    log::prelude::*, math::prelude::*, property::prelude::*, scene::prelude::*,
-    transform::prelude::*, type_registry::RegisterType, window::prelude::*, DefaultPlugins,
-    MinimalPlugins,
+    log::prelude::*, math::prelude::*, reflect::prelude::*, scene::prelude::*,
+    transform::prelude::*, window::prelude::*, DefaultPlugins, MinimalPlugins,
 };
 
 pub use bevy_derive::bevy_main;
diff --git a/crates/bevy_log/Cargo.toml b/crates/bevy_log/Cargo.toml
index d3c482932ae92..32c0ad3281a8e 100644
--- a/crates/bevy_log/Cargo.toml
+++ b/crates/bevy_log/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_log"
-version = "0.3.0"
+version = "0.4.0"
 edition = "2018"
 authors = [
     "Bevy Contributors <bevyengine@gmail.com>",
@@ -14,11 +14,11 @@ keywords = ["bevy"]
 
 
 [dependencies]
-bevy_app = { path = "../bevy_app", version = "0.3.0" }
-bevy_utils = { path = "../bevy_utils", version = "0.3.0" }
+bevy_app = { path = "../bevy_app", version = "0.4.0" }
+bevy_utils = { path = "../bevy_utils", version = "0.4.0" }
 
 tracing-subscriber = {version = "0.2.15", features = ["registry"]}
-tracing-chrome = { version = "0.2.0", optional = true } 
+tracing-chrome = { version = "0.3.0", optional = true }
 
 [target.'cfg(target_os = "android")'.dependencies]
 android_log-sys = "0.2.0"
diff --git a/crates/bevy_log/src/lib.rs b/crates/bevy_log/src/lib.rs
index 4bb1af857a472..397d4937d52b5 100644
--- a/crates/bevy_log/src/lib.rs
+++ b/crates/bevy_log/src/lib.rs
@@ -12,6 +12,8 @@ pub use bevy_utils::tracing::{
 };
 
 use bevy_app::{AppBuilder, Plugin};
+#[cfg(feature = "tracing-chrome")]
+use tracing_subscriber::fmt::{format::DefaultFields, FormattedFields};
 use tracing_subscriber::{prelude::*, registry::Registry, EnvFilter};
 
 /// Adds logging to Apps.
@@ -31,7 +33,7 @@ pub struct LogSettings {
 impl Default for LogSettings {
     fn default() -> Self {
         Self {
-            filter: "wgpu=warn".to_string(),
+            filter: "wgpu=error".to_string(),
             level: Level::INFO,
         }
     }
@@ -55,17 +57,30 @@ impl Plugin for LogPlugin {
             let subscriber = subscriber.with(fmt_layer);
             #[cfg(feature = "tracing-chrome")]
             {
-                let (chrome_layer, guard) = tracing_chrome::ChromeLayerBuilder::new().build();
+                let (chrome_layer, guard) = tracing_chrome::ChromeLayerBuilder::new()
+                    .name_fn(Box::new(|event_or_span| match event_or_span {
+                        tracing_chrome::EventOrSpan::Event(event) => event.metadata().name().into(),
+                        tracing_chrome::EventOrSpan::Span(span) => {
+                            if let Some(fields) =
+                                span.extensions().get::<FormattedFields<DefaultFields>>()
+                            {
+                                format!("{}: {}", span.metadata().name(), fields.fields.as_str())
+                            } else {
+                                span.metadata().name().into()
+                            }
+                        }
+                    }))
+                    .build();
                 app.resources_mut().insert_thread_local(guard);
                 let subscriber = subscriber.with(chrome_layer);
                 bevy_utils::tracing::subscriber::set_global_default(subscriber)
-                    .expect("Could not set global default tracing 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");
             }
 
             #[cfg(not(feature = "tracing-chrome"))]
             {
                 bevy_utils::tracing::subscriber::set_global_default(subscriber)
-                    .expect("Could not set global default tracing 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");
             }
         }
 
@@ -76,14 +91,14 @@ impl Plugin for LogPlugin {
                 tracing_wasm::WASMLayerConfig::default(),
             ));
             bevy_utils::tracing::subscriber::set_global_default(subscriber)
-                .expect("Could not set global default tracing 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");
         }
 
         #[cfg(target_os = "android")]
         {
             let subscriber = subscriber.with(android_tracing::AndroidLayer::default());
             bevy_utils::tracing::subscriber::set_global_default(subscriber)
-                .expect("Could not set global default tracing 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_math/Cargo.toml b/crates/bevy_math/Cargo.toml
index 22870fc6677f7..469312111bd4f 100644
--- a/crates/bevy_math/Cargo.toml
+++ b/crates/bevy_math/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_math"
-version = "0.3.0"
+version = "0.4.0"
 edition = "2018"
 authors = [
     "Bevy Contributors <bevyengine@gmail.com>",
@@ -13,4 +13,5 @@ license = "MIT"
 keywords = ["bevy"]
 
 [dependencies]
-glam = { version = "0.10.0", features = ["serde"] }
+glam = { version = "0.11.0", features = ["serde"] }
+bevy_reflect = { path = "../bevy_reflect", version = "0.4.0", features = ["bevy"] }
diff --git a/crates/bevy_math/src/face_toward.rs b/crates/bevy_math/src/face_toward.rs
index d090989fd4ccd..f873964b18afc 100644
--- a/crates/bevy_math/src/face_toward.rs
+++ b/crates/bevy_math/src/face_toward.rs
@@ -19,3 +19,23 @@ impl FaceToward for Mat4 {
         )
     }
 }
+
+#[cfg(test)]
+mod test {
+    #[test]
+    fn face_toward_mat4() {
+        use crate::{FaceToward, Mat4, Vec3, Vec4};
+
+        // Completely arbitrary arguments
+        let matrix = Mat4::face_toward(
+            Vec3::new(50.0, 60.0, 0.0),
+            Vec3::new(0.0, 0.0, 0.0),
+            Vec3::new(0.0, 1.0, 0.0),
+        );
+
+        assert_eq!(matrix.x_axis, Vec4::new(0.0, 0.0, -1.0, -0.0));
+        assert_eq!(matrix.y_axis, Vec4::new(-0.7682213, 0.6401844, 0.0, 0.0));
+        assert_eq!(matrix.z_axis, Vec4::new(0.6401844, 0.7682213, 0.0, 0.0));
+        assert_eq!(matrix.w_axis, Vec4::new(50.0, 60.0, 0.0, 1.0));
+    }
+}
diff --git a/crates/bevy_math/src/geometry.rs b/crates/bevy_math/src/geometry.rs
index 2ded532e060c9..27a0073c1c6f3 100644
--- a/crates/bevy_math/src/geometry.rs
+++ b/crates/bevy_math/src/geometry.rs
@@ -1,20 +1,21 @@
+use bevy_reflect::Reflect;
 use glam::Vec2;
 use std::ops::{Add, AddAssign};
 
 /// A two dimensional "size" as defined by a width and height
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct Size<T = f32> {
+#[derive(Copy, Clone, PartialEq, Debug, Reflect)]
+pub struct Size<T: Reflect = f32> {
     pub width: T,
     pub height: T,
 }
 
-impl<T> Size<T> {
+impl<T: Reflect> Size<T> {
     pub fn new(width: T, height: T) -> Self {
         Size { width, height }
     }
 }
 
-impl<T: Default> Default for Size<T> {
+impl<T: Default + Reflect> Default for Size<T> {
     fn default() -> Self {
         Self {
             width: Default::default(),
@@ -24,15 +25,15 @@ impl<T: Default> Default for Size<T> {
 }
 
 /// A rect, as defined by its "side" locations
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct Rect<T> {
+#[derive(Copy, Clone, PartialEq, Debug, Reflect)]
+pub struct Rect<T: Reflect> {
     pub left: T,
     pub right: T,
     pub top: T,
     pub bottom: T,
 }
 
-impl<T> Rect<T> {
+impl<T: Reflect> Rect<T> {
     pub fn all(value: T) -> Self
     where
         T: Clone,
@@ -46,7 +47,7 @@ impl<T> Rect<T> {
     }
 }
 
-impl<T: Default> Default for Rect<T> {
+impl<T: Default + Reflect> Default for Rect<T> {
     fn default() -> Self {
         Self {
             left: Default::default(),
@@ -57,7 +58,7 @@ impl<T: Default> Default for Rect<T> {
     }
 }
 
-impl<T> Add<Vec2> for Size<T>
+impl<T: Reflect> Add<Vec2> for Size<T>
 where
     T: Add<f32, Output = T>,
 {
@@ -71,7 +72,7 @@ where
     }
 }
 
-impl<T> AddAssign<Vec2> for Size<T>
+impl<T: Reflect> AddAssign<Vec2> for Size<T>
 where
     T: AddAssign<f32>,
 {
diff --git a/crates/bevy_pbr/Cargo.toml b/crates/bevy_pbr/Cargo.toml
index d2591350dee14..8a09959024cb7 100644
--- a/crates/bevy_pbr/Cargo.toml
+++ b/crates/bevy_pbr/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_pbr"
-version = "0.3.0"
+version = "0.4.0"
 edition = "2018"
 authors = [
     "Bevy Contributors <bevyengine@gmail.com>",
@@ -13,14 +13,13 @@ license = "MIT"
 keywords = ["bevy"]
 
 [dependencies]
-bevy_app = { path = "../bevy_app", version = "0.3.0" }
-bevy_asset = { path = "../bevy_asset", version = "0.3.0" }
-bevy_core = { path = "../bevy_core", version = "0.3.0" }
-bevy_derive = { path = "../bevy_derive", version = "0.3.0" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.3.0" }
-bevy_math = { path = "../bevy_math", version = "0.3.0" }
-bevy_property = { path = "../bevy_property", version = "0.3.0" }
-bevy_render = { path = "../bevy_render", version = "0.3.0" }
-bevy_transform = { path = "../bevy_transform", version = "0.3.0" }
-bevy_type_registry = { path = "../bevy_type_registry", version = "0.3.0" }
-bevy_window = { path = "../bevy_window", version = "0.3.0" }
+bevy_app = { path = "../bevy_app", version = "0.4.0" }
+bevy_asset = { path = "../bevy_asset", version = "0.4.0" }
+bevy_core = { path = "../bevy_core", version = "0.4.0" }
+bevy_derive = { path = "../bevy_derive", version = "0.4.0" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.4.0" }
+bevy_math = { path = "../bevy_math", version = "0.4.0" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.4.0", features = ["bevy"] }
+bevy_render = { path = "../bevy_render", version = "0.4.0" }
+bevy_transform = { path = "../bevy_transform", version = "0.4.0" }
+bevy_window = { path = "../bevy_window", version = "0.4.0" }
diff --git a/crates/bevy_pbr/src/entity.rs b/crates/bevy_pbr/src/entity.rs
index 4c355e90b2d89..5cf11e89844e4 100644
--- a/crates/bevy_pbr/src/entity.rs
+++ b/crates/bevy_pbr/src/entity.rs
@@ -5,6 +5,7 @@ use bevy_render::{
     draw::Draw,
     mesh::Mesh,
     pipeline::{RenderPipeline, RenderPipelines},
+    prelude::Visible,
     render_graph::base::MainPass,
 };
 use bevy_transform::prelude::{GlobalTransform, Transform};
@@ -16,6 +17,7 @@ pub struct PbrBundle {
     pub material: Handle<StandardMaterial>,
     pub main_pass: MainPass,
     pub draw: Draw,
+    pub visible: Visible,
     pub render_pipelines: RenderPipelines,
     pub transform: Transform,
     pub global_transform: GlobalTransform,
@@ -25,9 +27,10 @@ impl Default for PbrBundle {
     fn default() -> Self {
         Self {
             render_pipelines: RenderPipelines::from_pipelines(vec![RenderPipeline::new(
-                FORWARD_PIPELINE_HANDLE,
+                FORWARD_PIPELINE_HANDLE.typed(),
             )]),
             mesh: Default::default(),
+            visible: Default::default(),
             material: Default::default(),
             main_pass: Default::default(),
             draw: Default::default(),
diff --git a/crates/bevy_pbr/src/lib.rs b/crates/bevy_pbr/src/lib.rs
index bf9577efce75f..fc7a5b2c061ce 100644
--- a/crates/bevy_pbr/src/lib.rs
+++ b/crates/bevy_pbr/src/lib.rs
@@ -4,6 +4,7 @@ mod entity;
 mod light;
 mod material;
 
+use bevy_ecs::IntoSystem;
 pub use entity::*;
 pub use light::*;
 pub use material::*;
@@ -14,9 +15,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_type_registry::RegisterType;
-use light::Light;
 use material::StandardMaterial;
 use render_graph::add_pbr_graph;
 
@@ -27,10 +27,10 @@ pub struct PbrPlugin;
 impl Plugin for PbrPlugin {
     fn build(&self, app: &mut AppBuilder) {
         app.add_asset::<StandardMaterial>()
-            .register_component::<Light>()
+            .register_type::<Light>()
             .add_system_to_stage(
                 stage::POST_UPDATE,
-                shader::asset_shader_defs_system::<StandardMaterial>,
+                shader::asset_shader_defs_system::<StandardMaterial>.system(),
             )
             .init_resource::<AmbientLight>();
         let resources = app.resources();
diff --git a/crates/bevy_pbr/src/light.rs b/crates/bevy_pbr/src/light.rs
index 40f81403846ad..c0a0bb65dd31f 100644
--- a/crates/bevy_pbr/src/light.rs
+++ b/crates/bevy_pbr/src/light.rs
@@ -1,5 +1,5 @@
 use bevy_core::Byteable;
-use bevy_property::Properties;
+use bevy_reflect::{Reflect, ReflectComponent};
 use bevy_render::{
     camera::{CameraProjection, PerspectiveProjection},
     color::Color,
@@ -8,7 +8,8 @@ use bevy_transform::components::GlobalTransform;
 use std::ops::Range;
 
 /// A point light
-#[derive(Debug, Properties)]
+#[derive(Debug, Reflect)]
+#[reflect(Component)]
 pub struct Light {
     pub color: Color,
     pub fov: f32,
diff --git a/crates/bevy_pbr/src/material.rs b/crates/bevy_pbr/src/material.rs
index 6f63146730685..7973c0a6f659e 100644
--- a/crates/bevy_pbr/src/material.rs
+++ b/crates/bevy_pbr/src/material.rs
@@ -1,6 +1,6 @@
 use bevy_asset::{self, Handle};
+use bevy_reflect::TypeUuid;
 use bevy_render::{color::Color, renderer::RenderResources, shader::ShaderDefs, texture::Texture};
-use bevy_type_registry::TypeUuid;
 
 /// A material with "standard" properties used in PBR lighting
 #[derive(Debug, RenderResources, ShaderDefs, TypeUuid)]
diff --git a/crates/bevy_pbr/src/render_graph/forward_pipeline/forward.vert b/crates/bevy_pbr/src/render_graph/forward_pipeline/forward.vert
index 00cd153602e63..028a86389c012 100644
--- a/crates/bevy_pbr/src/render_graph/forward_pipeline/forward.vert
+++ b/crates/bevy_pbr/src/render_graph/forward_pipeline/forward.vert
@@ -17,7 +17,6 @@ layout(set = 2, binding = 0) uniform Transform {
 };
 
 void main() {
-    v_Normal = (Model * vec4(Vertex_Normal, 1.0)).xyz;
     v_Normal = mat3(Model) * Vertex_Normal;
     v_Position = (Model * vec4(Vertex_Position, 1.0)).xyz;
     v_Uv = Vertex_Uv;
diff --git a/crates/bevy_pbr/src/render_graph/forward_pipeline/mod.rs b/crates/bevy_pbr/src/render_graph/forward_pipeline/mod.rs
index e87425ecb5f83..8a3c17e6e1718 100644
--- a/crates/bevy_pbr/src/render_graph/forward_pipeline/mod.rs
+++ b/crates/bevy_pbr/src/render_graph/forward_pipeline/mod.rs
@@ -1,4 +1,5 @@
-use bevy_asset::{Assets, Handle};
+use bevy_asset::{Assets, HandleUntyped};
+use bevy_reflect::TypeUuid;
 use bevy_render::{
     pipeline::{
         BlendDescriptor, BlendFactor, BlendOperation, ColorStateDescriptor, ColorWrite,
@@ -8,10 +9,9 @@ use bevy_render::{
     shader::{Shader, ShaderStage, ShaderStages},
     texture::TextureFormat,
 };
-use bevy_type_registry::TypeUuid;
 
-pub const FORWARD_PIPELINE_HANDLE: Handle<PipelineDescriptor> =
-    Handle::weak_from_u64(PipelineDescriptor::TYPE_UUID, 13148362314012771389);
+pub const FORWARD_PIPELINE_HANDLE: HandleUntyped =
+    HandleUntyped::weak_from_u64(PipelineDescriptor::TYPE_UUID, 13148362314012771389);
 
 pub(crate) fn build_forward_pipeline(shaders: &mut Assets<Shader>) -> PipelineDescriptor {
     PipelineDescriptor {
diff --git a/crates/bevy_pbr/src/render_graph/lights_node.rs b/crates/bevy_pbr/src/render_graph/lights_node.rs
index 12b720a973a1a..a4a5d4bbe1fdb 100644
--- a/crates/bevy_pbr/src/render_graph/lights_node.rs
+++ b/crates/bevy_pbr/src/render_graph/lights_node.rs
@@ -51,7 +51,7 @@ struct LightCount {
 unsafe impl Byteable for LightCount {}
 
 impl SystemNode for LightsNode {
-    fn get_system(&self, commands: &mut Commands) -> Box<dyn System<Input = (), Output = ()>> {
+    fn get_system(&self, commands: &mut Commands) -> Box<dyn System<In = (), Out = ()>> {
         let system = lights_node_system.system();
         commands.insert_local_resource(
             system.id(),
diff --git a/crates/bevy_property/Cargo.toml b/crates/bevy_property/Cargo.toml
deleted file mode 100644
index b4e503ee7000c..0000000000000
--- a/crates/bevy_property/Cargo.toml
+++ /dev/null
@@ -1,26 +0,0 @@
-[package]
-name = "bevy_property"
-version = "0.3.0"
-edition = "2018"
-authors = [
-    "Bevy Contributors <bevyengine@gmail.com>",
-    "Carter Anderson <mcanders1@gmail.com>",
-]
-description = "Dynamically interact with struct fields using their names"
-homepage = "https://bevyengine.org"
-repository = "https://github.com/bevyengine/bevy"
-license = "MIT"
-keywords = ["bevy"]
-
-[dependencies]
-# bevy
-bevy_ecs = { path = "../bevy_ecs", version = "0.3.0" }
-bevy_math = { path = "../bevy_math", version = "0.3.0" }
-bevy_property_derive = { path = "bevy_property_derive", version = "0.3.0" }
-bevy_utils = { path = "../bevy_utils", version = "0.3.0" }
-
-# other
-erased-serde = "0.3"
-ron = "0.6.2"
-serde = "1"
-smallvec = { version = "1.4", features = ["serde"] }
diff --git a/crates/bevy_property/bevy_property_derive/src/lib.rs b/crates/bevy_property/bevy_property_derive/src/lib.rs
deleted file mode 100644
index 6b16fda9048ea..0000000000000
--- a/crates/bevy_property/bevy_property_derive/src/lib.rs
+++ /dev/null
@@ -1,431 +0,0 @@
-extern crate proc_macro;
-
-mod modules;
-
-use find_crate::Manifest;
-use modules::{get_modules, get_path};
-use proc_macro::TokenStream;
-use quote::quote;
-use syn::{
-    parse::{Parse, ParseStream},
-    parse_macro_input,
-    punctuated::Punctuated,
-    token::{Comma, Where},
-    Data, DataStruct, DeriveInput, Field, Fields, Generics, Ident, Index, Member,
-};
-
-#[derive(Default)]
-struct PropAttributeArgs {
-    pub ignore: Option<bool>,
-}
-
-static PROP_ATTRIBUTE_NAME: &str = "property";
-
-#[proc_macro_derive(Properties, attributes(property, module))]
-pub fn derive_properties(input: TokenStream) -> TokenStream {
-    let ast = parse_macro_input!(input as DeriveInput);
-    let unit_struct_punctuated = Punctuated::new();
-    let fields = match &ast.data {
-        Data::Struct(DataStruct {
-            fields: Fields::Named(fields),
-            ..
-        }) => &fields.named,
-        Data::Struct(DataStruct {
-            fields: Fields::Unnamed(fields),
-            ..
-        }) => &fields.unnamed,
-        Data::Struct(DataStruct {
-            fields: Fields::Unit,
-            ..
-        }) => &unit_struct_punctuated,
-        _ => panic!("expected a struct with named fields"),
-    };
-    let fields_and_args = fields
-        .iter()
-        .enumerate()
-        .map(|(i, f)| {
-            (
-                f,
-                f.attrs
-                    .iter()
-                    .find(|a| *a.path.get_ident().as_ref().unwrap() == PROP_ATTRIBUTE_NAME)
-                    .map(|a| {
-                        syn::custom_keyword!(ignore);
-                        let mut attribute_args = PropAttributeArgs { ignore: None };
-                        a.parse_args_with(|input: ParseStream| {
-                            if input.parse::<Option<ignore>>()?.is_some() {
-                                attribute_args.ignore = Some(true);
-                                return Ok(());
-                            }
-                            Ok(())
-                        })
-                        .expect("invalid 'property' attribute format");
-
-                        attribute_args
-                    }),
-                i,
-            )
-        })
-        .collect::<Vec<(&Field, Option<PropAttributeArgs>, usize)>>();
-    let active_fields = fields_and_args
-        .iter()
-        .filter(|(_field, attrs, _i)| {
-            attrs.is_none()
-                || match attrs.as_ref().unwrap().ignore {
-                    Some(ignore) => !ignore,
-                    None => true,
-                }
-        })
-        .map(|(f, _attr, i)| (*f, *i))
-        .collect::<Vec<(&Field, usize)>>();
-
-    let modules = get_modules();
-    let bevy_property_path = get_path(&modules.bevy_property);
-
-    let field_names = active_fields
-        .iter()
-        .map(|(field, index)| {
-            field
-                .ident
-                .as_ref()
-                .map(|i| i.to_string())
-                .unwrap_or_else(|| index.to_string())
-        })
-        .collect::<Vec<String>>();
-    let field_idents = active_fields
-        .iter()
-        .map(|(field, index)| {
-            field
-                .ident
-                .as_ref()
-                .map(|ident| Member::Named(ident.clone()))
-                .unwrap_or_else(|| Member::Unnamed(Index::from(*index)))
-        })
-        .collect::<Vec<_>>();
-    let field_count = active_fields.len();
-    let field_indices = (0..field_count).collect::<Vec<usize>>();
-
-    let generics = ast.generics;
-    let (impl_generics, ty_generics, _where_clause) = generics.split_for_impl();
-
-    let struct_name = &ast.ident;
-
-    TokenStream::from(quote! {
-        impl #impl_generics #bevy_property_path::Properties for #struct_name#ty_generics {
-            fn prop(&self, name: &str) -> Option<&dyn #bevy_property_path::Property> {
-                match name {
-                    #(#field_names => Some(&self.#field_idents),)*
-                    _ => None,
-                }
-            }
-
-            fn prop_mut(&mut self, name: &str) -> Option<&mut dyn #bevy_property_path::Property> {
-                match name {
-                    #(#field_names => Some(&mut self.#field_idents),)*
-                    _ => None,
-                }
-            }
-
-            fn prop_with_index(&self, index: usize) -> Option<&dyn #bevy_property_path::Property> {
-                match index {
-                    #(#field_indices => Some(&self.#field_idents),)*
-                    _ => None,
-                }
-            }
-
-            fn prop_with_index_mut(&mut self, index: usize) -> Option<&mut dyn #bevy_property_path::Property> {
-                match index {
-                    #(#field_indices => Some(&mut self.#field_idents),)*
-                    _ => None,
-                }
-            }
-
-            fn prop_name(&self, index: usize) -> Option<&str> {
-                match index {
-                    #(#field_indices => Some(#field_names),)*
-                    _ => None,
-                }
-            }
-
-            fn prop_len(&self) -> usize {
-                #field_count
-            }
-
-            fn iter_props(&self) -> #bevy_property_path::PropertyIter {
-                #bevy_property_path::PropertyIter::new(self)
-            }
-        }
-
-        impl #impl_generics #bevy_property_path::DeserializeProperty for #struct_name#ty_generics {
-            fn deserialize(
-                deserializer: &mut dyn #bevy_property_path::erased_serde::Deserializer,
-                property_type_registry: &#bevy_property_path::PropertyTypeRegistry) ->
-                    Result<Box<dyn #bevy_property_path::Property>, #bevy_property_path::erased_serde::Error> {
-                    use #bevy_property_path::serde::de::DeserializeSeed;
-                    let dynamic_properties_deserializer = #bevy_property_path::property_serde::DynamicPropertiesDeserializer::new(property_type_registry);
-                    let dynamic_properties: #bevy_property_path::DynamicProperties = dynamic_properties_deserializer.deserialize(deserializer)?;
-                    Ok(Box::new(dynamic_properties))
-            }
-        }
-
-        impl #impl_generics #bevy_property_path::Property for #struct_name#ty_generics {
-            #[inline]
-            fn type_name(&self) -> &str {
-                std::any::type_name::<Self>()
-            }
-
-            #[inline]
-            fn any(&self) -> &dyn std::any::Any {
-                self
-            }
-            #[inline]
-            fn any_mut(&mut self) -> &mut dyn std::any::Any {
-                self
-            }
-            #[inline]
-            fn clone_prop(&self) -> Box<dyn #bevy_property_path::Property> {
-                Box::new(self.to_dynamic())
-            }
-            #[inline]
-            fn set(&mut self, value: &dyn #bevy_property_path::Property) {
-                // TODO: type check
-                self.apply(value);
-            }
-
-            #[inline]
-            fn apply(&mut self, value: &dyn #bevy_property_path::Property) {
-                if let Some(properties) = value.as_properties() {
-                    if properties.property_type() != self.property_type() {
-                        panic!(
-                            "Properties type mismatch. This type is {:?} but the applied type is {:?}",
-                            self.property_type(),
-                            properties.property_type()
-                        );
-                    }
-                    for (i, prop) in properties.iter_props().enumerate() {
-                        let name = properties.prop_name(i).unwrap();
-                        self.prop_mut(name).map(|p| p.apply(prop));
-                    }
-                } else {
-                    panic!("attempted to apply non-Properties type to Properties type");
-                }
-            }
-
-            #[inline]
-            fn as_properties(&self) -> Option<&dyn #bevy_property_path::Properties> {
-                Some(self)
-            }
-
-            fn serializable<'a>(&'a self, registry: &'a #bevy_property_path::PropertyTypeRegistry) -> #bevy_property_path::property_serde::Serializable<'a> {
-                #bevy_property_path::property_serde::Serializable::Owned(Box::new(#bevy_property_path::property_serde::MapSerializer::new(self, registry)))
-            }
-
-            fn property_type(&self) -> #bevy_property_path::PropertyType {
-                #bevy_property_path::PropertyType::Map
-            }
-        }
-    })
-}
-
-#[proc_macro_derive(Property)]
-pub fn derive_property(input: TokenStream) -> TokenStream {
-    let ast = parse_macro_input!(input as DeriveInput);
-    let modules = get_modules();
-    let bevy_property_path = get_path(&modules.bevy_property);
-
-    let generics = ast.generics;
-    let (impl_generics, ty_generics, _where_clause) = generics.split_for_impl();
-
-    let struct_name = &ast.ident;
-
-    TokenStream::from(quote! {
-        impl #impl_generics #bevy_property_path::Property for #struct_name#ty_generics  {
-            #[inline]
-            fn type_name(&self) -> &str {
-                std::any::type_name::<Self>()
-            }
-
-            #[inline]
-            fn any(&self) -> &dyn std::any::Any {
-                self
-            }
-
-            #[inline]
-            fn any_mut(&mut self) -> &mut dyn std::any::Any {
-                self
-            }
-
-            #[inline]
-            fn clone_prop(&self) -> Box<dyn #bevy_property_path::Property> {
-                Box::new(self.clone())
-            }
-
-            #[inline]
-            fn apply(&mut self, value: &dyn #bevy_property_path::Property) {
-                self.set(value);
-            }
-
-            #[inline]
-            fn set(&mut self, value: &dyn #bevy_property_path::Property) {
-                let value = value.any();
-                if let Some(prop) = value.downcast_ref::<Self>() {
-                    *self = prop.clone();
-                } else {
-                    panic!("prop value is not {}", std::any::type_name::<Self>());
-                }
-            }
-
-            #[inline]
-            fn serializable<'a>(&'a self, registry: &'a #bevy_property_path::PropertyTypeRegistry) -> #bevy_property_path::property_serde::Serializable<'a> {
-                #bevy_property_path::property_serde::Serializable::Owned(Box::new(#bevy_property_path::property_serde::PropertyValueSerializer::new(self, registry)))
-            }
-
-            fn property_type(&self) -> #bevy_property_path::PropertyType {
-                #bevy_property_path::PropertyType::Value
-            }
-        }
-
-        impl #impl_generics #bevy_property_path::DeserializeProperty for #struct_name#ty_generics  {
-            fn deserialize(
-                deserializer: &mut dyn #bevy_property_path::erased_serde::Deserializer,
-                property_type_registry: &#bevy_property_path::PropertyTypeRegistry) ->
-                    Result<Box<dyn #bevy_property_path::Property>, #bevy_property_path::erased_serde::Error> {
-                    let property = <#struct_name#ty_generics as #bevy_property_path::serde::Deserialize>::deserialize(deserializer)?;
-                    Ok(Box::new(property))
-            }
-       }
-    })
-}
-
-struct PropertyDef {
-    type_name: Ident,
-    generics: Generics,
-    serialize_fn: Option<Ident>,
-    deserialize_fn: Option<Ident>,
-}
-
-impl Parse for PropertyDef {
-    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
-        let type_ident = input.parse::<Ident>()?;
-        let generics = input.parse::<Generics>()?;
-        let mut lookahead = input.lookahead1();
-        let mut where_clause = None;
-        if lookahead.peek(Where) {
-            where_clause = Some(input.parse()?);
-            lookahead = input.lookahead1();
-        }
-
-        let mut serialize_fn = None;
-        if lookahead.peek(Comma) {
-            input.parse::<Comma>()?;
-            serialize_fn = Some(input.parse::<Ident>()?);
-            lookahead = input.lookahead1();
-        }
-
-        let mut deserialize_fn = None;
-        if lookahead.peek(Comma) {
-            input.parse::<Comma>()?;
-            deserialize_fn = Some(input.parse::<Ident>()?);
-        }
-
-        Ok(PropertyDef {
-            type_name: type_ident,
-            generics: Generics {
-                where_clause,
-                ..generics
-            },
-            serialize_fn,
-            deserialize_fn,
-        })
-    }
-}
-
-#[proc_macro]
-pub fn impl_property(input: TokenStream) -> TokenStream {
-    let property_def = parse_macro_input!(input as PropertyDef);
-
-    let manifest = Manifest::new().unwrap();
-    let crate_path = if let Some(package) = manifest.find(|name| name == "bevy") {
-        format!("{}::property", package.name)
-    } else if let Some(package) = manifest.find(|name| name == "bevy_property") {
-        package.name
-    } else {
-        "crate".to_string()
-    };
-    let bevy_property_path = get_path(&crate_path);
-
-    let (impl_generics, ty_generics, where_clause) = property_def.generics.split_for_impl();
-    let ty = &property_def.type_name;
-    let serialize_fn = if let Some(serialize_fn) = property_def.serialize_fn {
-        quote! { #serialize_fn(self) }
-    } else {
-        quote! {
-            #bevy_property_path::property_serde::Serializable::Owned(Box::new(#bevy_property_path::property_serde::PropertyValueSerializer::new(self, registry)))
-        }
-    };
-    let deserialize_fn = if let Some(deserialize_fn) = property_def.deserialize_fn {
-        quote! { #deserialize_fn(deserializer, property_type_registry) }
-    } else {
-        quote! {
-            let property = <#ty#ty_generics as #bevy_property_path::serde::Deserialize>::deserialize(deserializer)?;
-            Ok(Box::new(property))
-        }
-    };
-
-    TokenStream::from(quote! {
-        impl #impl_generics #bevy_property_path::Property for #ty#ty_generics #where_clause  {
-            #[inline]
-            fn type_name(&self) -> &str {
-                std::any::type_name::<Self>()
-            }
-
-            #[inline]
-            fn any(&self) -> &dyn std::any::Any {
-                self
-            }
-
-            #[inline]
-            fn any_mut(&mut self) -> &mut dyn std::any::Any {
-                self
-            }
-
-            #[inline]
-            fn clone_prop(&self) -> Box<dyn #bevy_property_path::Property> {
-                Box::new(self.clone())
-            }
-
-            #[inline]
-            fn apply(&mut self, value: &dyn #bevy_property_path::Property) {
-                self.set(value);
-            }
-
-            #[inline]
-            fn set(&mut self, value: &dyn #bevy_property_path::Property) {
-                let value = value.any();
-                if let Some(prop) = value.downcast_ref::<Self>() {
-                    *self = prop.clone();
-                } else {
-                    panic!("prop value is not {}", std::any::type_name::<Self>());
-                }
-            }
-
-            #[inline]
-            fn serializable<'a>(&'a self, registry: &'a #bevy_property_path::PropertyTypeRegistry) -> #bevy_property_path::property_serde::Serializable<'a> {
-                #serialize_fn
-            }
-
-            fn property_type(&self) -> #bevy_property_path::PropertyType {
-                #bevy_property_path::PropertyType::Value
-            }
-        }
-
-        impl #impl_generics #bevy_property_path::DeserializeProperty for #ty#ty_generics #where_clause  {
-            fn deserialize(
-                deserializer: &mut dyn #bevy_property_path::erased_serde::Deserializer,
-                property_type_registry: &#bevy_property_path::PropertyTypeRegistry) ->
-                    Result<Box<dyn #bevy_property_path::Property>, #bevy_property_path::erased_serde::Error> {
-                    #deserialize_fn
-            }
-       }
-    })
-}
diff --git a/crates/bevy_property/src/dynamic_properties.rs b/crates/bevy_property/src/dynamic_properties.rs
deleted file mode 100644
index 6312c8ebdbac6..0000000000000
--- a/crates/bevy_property/src/dynamic_properties.rs
+++ /dev/null
@@ -1,223 +0,0 @@
-use crate::{
-    property_serde::{DynamicPropertiesDeserializer, DynamicPropertiesSerializer, Serializable},
-    DeserializeProperty, Properties, Property, PropertyIter, PropertyType, PropertyTypeRegistry,
-};
-use bevy_utils::HashMap;
-use serde::de::DeserializeSeed;
-use std::{any::Any, borrow::Cow, fmt};
-
-pub struct DynamicProperties {
-    pub type_name: String,
-    pub props: Vec<Box<dyn Property>>,
-    pub prop_names: Vec<Cow<'static, str>>,
-    pub prop_indices: HashMap<Cow<'static, str>, usize>,
-    pub property_type: PropertyType,
-}
-
-impl fmt::Debug for DynamicProperties {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let props = self
-            .props
-            .iter()
-            .map(|p| p.as_ref() as *const dyn Property)
-            .collect::<Vec<_>>();
-
-        f.debug_struct("DynamicProperties")
-            .field("type_name", &self.type_name)
-            .field("props", &props)
-            .field("prop_names", &self.prop_names)
-            .field("prop_indices", &self.prop_indices)
-            .field("property_type", &self.property_type)
-            .finish()
-    }
-}
-
-impl DynamicProperties {
-    pub fn map() -> Self {
-        DynamicProperties {
-            type_name: std::any::type_name::<Self>().to_string(),
-            props: Default::default(),
-            prop_names: Default::default(),
-            prop_indices: Default::default(),
-            property_type: PropertyType::Map,
-        }
-    }
-
-    pub fn seq() -> Self {
-        DynamicProperties {
-            type_name: std::any::type_name::<Self>().to_string(),
-            props: Default::default(),
-            prop_names: Default::default(),
-            prop_indices: Default::default(),
-            property_type: PropertyType::Seq,
-        }
-    }
-
-    pub fn push(&mut self, prop: Box<dyn Property>, name: Option<&str>) {
-        // TODO: validate map / seq operations
-        self.props.push(prop);
-        if let Some(name) = name {
-            let cow_name: Cow<'static, str> = Cow::Owned(name.to_string()); // moo
-            self.prop_names.push(cow_name.clone());
-            self.prop_indices.insert(cow_name, self.props.len() - 1);
-        }
-    }
-
-    pub fn set<T: Property>(&mut self, name: &str, prop: T) {
-        // TODO: validate map / seq operations
-        if let Some(index) = self.prop_indices.get(name) {
-            self.props[*index] = Box::new(prop);
-        } else {
-            self.push(Box::new(prop), Some(name));
-        }
-    }
-
-    pub fn set_box(&mut self, name: &str, prop: Box<dyn Property>) {
-        // TODO: validate map / seq operations
-        if let Some(index) = self.prop_indices.get(name) {
-            self.props[*index] = prop;
-        } else {
-            self.push(prop, Some(name));
-        }
-    }
-}
-
-impl Properties for DynamicProperties {
-    #[inline]
-    fn prop(&self, name: &str) -> Option<&dyn Property> {
-        if let Some(index) = self.prop_indices.get(name) {
-            Some(&*self.props[*index])
-        } else {
-            None
-        }
-    }
-
-    #[inline]
-    fn prop_mut(&mut self, name: &str) -> Option<&mut dyn Property> {
-        if let Some(index) = self.prop_indices.get(name) {
-            Some(&mut *self.props[*index])
-        } else {
-            None
-        }
-    }
-
-    #[inline]
-    fn prop_with_index(&self, index: usize) -> Option<&dyn Property> {
-        self.props.get(index).map(|prop| &**prop)
-    }
-
-    #[inline]
-    fn prop_with_index_mut(&mut self, index: usize) -> Option<&mut dyn Property> {
-        self.props.get_mut(index).map(|prop| &mut **prop)
-    }
-
-    #[inline]
-    fn prop_name(&self, index: usize) -> Option<&str> {
-        match self.property_type {
-            PropertyType::Seq => None,
-            PropertyType::Map => self.prop_names.get(index).map(|name| name.as_ref()),
-            _ => panic!("DynamicProperties cannot be Value types"),
-        }
-    }
-
-    #[inline]
-    fn prop_len(&self) -> usize {
-        self.props.len()
-    }
-
-    fn iter_props(&self) -> PropertyIter {
-        PropertyIter {
-            props: self,
-            index: 0,
-        }
-    }
-}
-
-impl Property for DynamicProperties {
-    #[inline]
-    fn type_name(&self) -> &str {
-        &self.type_name
-    }
-
-    #[inline]
-    fn any(&self) -> &dyn Any {
-        self
-    }
-
-    #[inline]
-    fn any_mut(&mut self) -> &mut dyn Any {
-        self
-    }
-
-    #[inline]
-    fn clone_prop(&self) -> Box<dyn Property> {
-        Box::new(self.to_dynamic())
-    }
-
-    #[inline]
-    fn set(&mut self, value: &dyn Property) {
-        if let Some(properties) = value.as_properties() {
-            *self = properties.to_dynamic();
-        } else {
-            panic!("attempted to apply non-Properties type to Properties type");
-        }
-    }
-
-    #[inline]
-    fn apply(&mut self, value: &dyn Property) {
-        if let Some(properties) = value.as_properties() {
-            if properties.property_type() != self.property_type {
-                panic!(
-                    "Properties type mismatch. This type is {:?} but the applied type is {:?}",
-                    self.property_type,
-                    properties.property_type()
-                );
-            }
-            match self.property_type {
-                PropertyType::Map => {
-                    for (i, prop) in properties.iter_props().enumerate() {
-                        let name = properties.prop_name(i).unwrap();
-                        if let Some(p) = self.prop_mut(name) {
-                            p.apply(prop);
-                        }
-                    }
-                }
-                PropertyType::Seq => {
-                    for (i, prop) in properties.iter_props().enumerate() {
-                        if let Some(p) = self.prop_with_index_mut(i) {
-                            p.apply(prop);
-                        }
-                    }
-                }
-                _ => panic!("DynamicProperties cannot be Value types"),
-            }
-        } else {
-            panic!("attempted to apply non-Properties type to Properties type");
-        }
-    }
-
-    fn as_properties(&self) -> Option<&dyn Properties> {
-        Some(self)
-    }
-
-    fn serializable<'a>(&'a self, registry: &'a PropertyTypeRegistry) -> Serializable<'a> {
-        Serializable::Owned(Box::new(DynamicPropertiesSerializer::new(self, registry)))
-    }
-
-    fn property_type(&self) -> PropertyType {
-        self.property_type
-    }
-}
-
-impl DeserializeProperty for DynamicProperties {
-    fn deserialize(
-        deserializer: &mut dyn erased_serde::Deserializer,
-        property_type_registry: &PropertyTypeRegistry,
-    ) -> Result<Box<dyn Property>, erased_serde::Error> {
-        let dynamic_properties_deserializer =
-            DynamicPropertiesDeserializer::new(property_type_registry);
-        let dynamic_properties: DynamicProperties =
-            dynamic_properties_deserializer.deserialize(deserializer)?;
-        Ok(Box::new(dynamic_properties))
-    }
-}
diff --git a/crates/bevy_property/src/impl_property/impl_property_bevy_ecs.rs b/crates/bevy_property/src/impl_property/impl_property_bevy_ecs.rs
deleted file mode 100644
index 466fb1fd10bf0..0000000000000
--- a/crates/bevy_property/src/impl_property/impl_property_bevy_ecs.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-use crate::{impl_property, property_serde::Serializable, Property, PropertyTypeRegistry};
-use bevy_ecs::Entity;
-use erased_serde::Deserializer;
-use serde::Deserialize;
-
-impl_property!(Entity, serialize_entity, deserialize_entity);
-
-mod private {
-    use serde::{Deserialize, Serialize};
-    #[derive(Serialize, Deserialize)]
-    pub(super) struct Entity(pub(super) u32);
-}
-
-fn serialize_entity(entity: &Entity) -> Serializable {
-    Serializable::Owned(Box::new(private::Entity(entity.id())))
-}
-
-fn deserialize_entity(
-    deserializer: &mut dyn Deserializer,
-    _registry: &PropertyTypeRegistry,
-) -> Result<Box<dyn Property>, erased_serde::Error> {
-    let entity = private::Entity::deserialize(deserializer)?;
-    Ok(Box::new(Entity::new(entity.0)))
-}
diff --git a/crates/bevy_property/src/impl_property/impl_property_glam.rs b/crates/bevy_property/src/impl_property/impl_property_glam.rs
deleted file mode 100644
index e01ab9557ed17..0000000000000
--- a/crates/bevy_property/src/impl_property/impl_property_glam.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-use crate::impl_property;
-use bevy_math::{Mat3, Mat4, Quat, Vec2, Vec3};
-
-impl_property!(Vec2);
-impl_property!(Vec3);
-impl_property!(Mat3);
-impl_property!(Mat4);
-impl_property!(Quat);
diff --git a/crates/bevy_property/src/impl_property/impl_property_smallvec.rs b/crates/bevy_property/src/impl_property/impl_property_smallvec.rs
deleted file mode 100644
index caf78a6aa792a..0000000000000
--- a/crates/bevy_property/src/impl_property/impl_property_smallvec.rs
+++ /dev/null
@@ -1,50 +0,0 @@
-use crate::{property_serde::Serializable, Property, PropertyType, PropertyTypeRegistry};
-use serde::Serialize;
-use smallvec::{Array, SmallVec};
-use std::any::Any;
-
-impl<T, I> Property for SmallVec<T>
-where
-    T: Clone + Send + Sync + Serialize + 'static + Array<Item = I>,
-    I: Send + Sync + Clone + Serialize + 'static,
-{
-    #[inline]
-    fn type_name(&self) -> &str {
-        std::any::type_name::<Self>()
-    }
-
-    #[inline]
-    fn any(&self) -> &dyn Any {
-        self
-    }
-
-    #[inline]
-    fn any_mut(&mut self) -> &mut dyn Any {
-        self
-    }
-
-    #[inline]
-    fn clone_prop(&self) -> Box<dyn Property> {
-        Box::new(self.clone())
-    }
-
-    #[inline]
-    fn apply(&mut self, value: &dyn Property) {
-        self.set(value);
-    }
-
-    fn set(&mut self, value: &dyn Property) {
-        let value = value.any();
-        if let Some(prop) = value.downcast_ref::<Self>() {
-            *self = prop.clone();
-        }
-    }
-
-    fn serializable<'a>(&'a self, _registry: &'a PropertyTypeRegistry) -> Serializable<'a> {
-        Serializable::Borrowed(self)
-    }
-
-    fn property_type(&self) -> PropertyType {
-        PropertyType::Value
-    }
-}
diff --git a/crates/bevy_property/src/impl_property/impl_property_std.rs b/crates/bevy_property/src/impl_property/impl_property_std.rs
deleted file mode 100644
index 819fdd4c049cf..0000000000000
--- a/crates/bevy_property/src/impl_property/impl_property_std.rs
+++ /dev/null
@@ -1,861 +0,0 @@
-use crate::{
-    impl_property,
-    property_serde::{SeqSerializer, Serializable},
-    Properties, Property, PropertyIter, PropertyType, PropertyTypeRegistry,
-};
-use serde::{Deserialize, Serialize};
-use std::{
-    any::Any,
-    collections::{BTreeMap, HashMap, HashSet},
-    hash::{BuildHasher, Hash},
-    ops::Range,
-};
-
-impl<T> Properties for Vec<T>
-where
-    T: Property + Clone + Default,
-{
-    fn prop(&self, _name: &str) -> Option<&dyn Property> {
-        None
-    }
-
-    fn prop_mut(&mut self, _name: &str) -> Option<&mut dyn Property> {
-        None
-    }
-
-    fn prop_with_index(&self, index: usize) -> Option<&dyn Property> {
-        Some(&self[index])
-    }
-
-    fn prop_with_index_mut(&mut self, index: usize) -> Option<&mut dyn Property> {
-        Some(&mut self[index])
-    }
-
-    fn prop_name(&self, _index: usize) -> Option<&str> {
-        None
-    }
-
-    fn prop_len(&self) -> usize {
-        self.len()
-    }
-
-    fn iter_props(&self) -> PropertyIter {
-        PropertyIter::new(self)
-    }
-}
-
-impl<T> Property for Vec<T>
-where
-    T: Property + Clone + Default,
-{
-    fn type_name(&self) -> &str {
-        std::any::type_name::<Self>()
-    }
-
-    fn any(&self) -> &dyn Any {
-        self
-    }
-
-    fn any_mut(&mut self) -> &mut dyn Any {
-        self
-    }
-
-    fn clone_prop(&self) -> Box<dyn Property> {
-        Box::new(self.clone())
-    }
-
-    fn set(&mut self, value: &dyn Property) {
-        if let Some(properties) = value.as_properties() {
-            let len = properties.prop_len();
-            self.resize_with(len, T::default);
-
-            if properties.property_type() != self.property_type() {
-                panic!(
-                    "Properties type mismatch. This type is {:?} but the applied type is {:?}",
-                    self.property_type(),
-                    properties.property_type()
-                );
-            }
-            for (i, prop) in properties.iter_props().enumerate() {
-                if let Some(p) = self.prop_with_index_mut(i) {
-                    p.apply(prop)
-                }
-            }
-        } else {
-            panic!("attempted to apply non-Properties type to Properties type");
-        }
-    }
-
-    fn apply(&mut self, value: &dyn Property) {
-        self.set(value);
-    }
-
-    fn as_properties(&self) -> Option<&dyn Properties> {
-        Some(self)
-    }
-
-    fn serializable<'a>(&'a self, registry: &'a PropertyTypeRegistry) -> Serializable<'a> {
-        Serializable::Owned(Box::new(SeqSerializer::new(self, registry)))
-    }
-
-    fn property_type(&self) -> PropertyType {
-        PropertyType::Seq
-    }
-}
-
-// impl_property!(SEQUENCE, VecDeque<T> where T: Clone + Send + Sync + Serialize + 'static);
-impl_property!(Option<T> where T: Clone + Send + Sync + Serialize + for<'de> Deserialize<'de> + 'static);
-impl_property!(HashSet<T, H> where T: Clone + Eq + Send + Sync + Hash + Serialize + for<'de> Deserialize<'de> + 'static, H: Clone + Send + Sync + Default + BuildHasher + 'static);
-impl_property!(HashMap<K, V, H> where
-    K: Clone + Eq + Send + Sync + Hash + Serialize + for<'de> Deserialize<'de> + 'static,
-    V: Clone + Send + Sync + Serialize + for<'de> Deserialize<'de> + 'static,
-    H: Clone + Send + Sync + Default + BuildHasher + 'static);
-impl_property!(BTreeMap<K, V> where
-    K: Clone + Ord + Send + Sync + Serialize + for<'de> Deserialize<'de> + 'static,
-    V: Clone + Send + Sync + Serialize + for<'de> Deserialize<'de> + 'static);
-impl_property!(Range<T> where T: Clone + Send + Sync + Serialize + for<'de> Deserialize<'de> + 'static);
-
-// TODO: Implement lossless primitive types in RON and remove all of these primitive "cast checks"
-impl Property for String {
-    #[inline]
-    fn type_name(&self) -> &str {
-        std::any::type_name::<Self>()
-    }
-
-    #[inline]
-    fn any(&self) -> &dyn Any {
-        self
-    }
-
-    #[inline]
-    fn any_mut(&mut self) -> &mut dyn Any {
-        self
-    }
-
-    #[inline]
-    fn clone_prop(&self) -> Box<dyn Property> {
-        Box::new(self.clone())
-    }
-
-    #[inline]
-    fn apply(&mut self, value: &dyn Property) {
-        self.set(value);
-    }
-
-    fn set(&mut self, value: &dyn Property) {
-        let value = value.any();
-        if let Some(prop) = value.downcast_ref::<Self>() {
-            *self = prop.clone();
-        } else {
-            panic!("prop value is not {}", std::any::type_name::<Self>());
-        }
-    }
-
-    fn serializable<'a>(&'a self, _registry: &'a PropertyTypeRegistry) -> Serializable<'a> {
-        Serializable::Borrowed(self)
-    }
-}
-
-impl Property for bool {
-    #[inline]
-    fn type_name(&self) -> &str {
-        std::any::type_name::<Self>()
-    }
-
-    #[inline]
-    fn any(&self) -> &dyn Any {
-        self
-    }
-
-    #[inline]
-    fn any_mut(&mut self) -> &mut dyn Any {
-        self
-    }
-
-    #[inline]
-    fn clone_prop(&self) -> Box<dyn Property> {
-        Box::new(*self)
-    }
-
-    #[inline]
-    fn apply(&mut self, value: &dyn Property) {
-        self.set(value);
-    }
-
-    fn set(&mut self, value: &dyn Property) {
-        let value = value.any();
-        if let Some(prop) = value.downcast_ref::<Self>() {
-            *self = *prop;
-        } else {
-            panic!("prop value is not {}", std::any::type_name::<Self>());
-        }
-    }
-
-    fn serializable<'a>(&'a self, _registry: &'a PropertyTypeRegistry) -> Serializable<'a> {
-        Serializable::Borrowed(self)
-    }
-}
-
-impl Property for usize {
-    #[inline]
-    fn type_name(&self) -> &str {
-        std::any::type_name::<Self>()
-    }
-
-    #[inline]
-    fn any(&self) -> &dyn Any {
-        self
-    }
-
-    #[inline]
-    fn any_mut(&mut self) -> &mut dyn Any {
-        self
-    }
-
-    #[inline]
-    fn clone_prop(&self) -> Box<dyn Property> {
-        Box::new(*self)
-    }
-
-    #[inline]
-    fn apply(&mut self, value: &dyn Property) {
-        self.set(value);
-    }
-
-    fn set(&mut self, value: &dyn Property) {
-        let value = value.any();
-        if let Some(prop) = value.downcast_ref::<Self>() {
-            *self = *prop;
-        } else if let Some(prop) = value.downcast_ref::<u64>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<u32>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<u16>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<u8>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<isize>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<i64>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<i32>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<i16>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<i8>() {
-            *self = *prop as Self;
-        } else {
-            panic!("prop value is not {}", std::any::type_name::<Self>());
-        }
-    }
-
-    fn serializable<'a>(&'a self, _registry: &'a PropertyTypeRegistry) -> Serializable<'a> {
-        Serializable::Borrowed(self)
-    }
-}
-
-impl Property for u64 {
-    #[inline]
-    fn type_name(&self) -> &str {
-        std::any::type_name::<Self>()
-    }
-
-    #[inline]
-    fn any(&self) -> &dyn Any {
-        self
-    }
-
-    #[inline]
-    fn any_mut(&mut self) -> &mut dyn Any {
-        self
-    }
-
-    #[inline]
-    fn clone_prop(&self) -> Box<dyn Property> {
-        Box::new(*self)
-    }
-
-    #[inline]
-    fn apply(&mut self, value: &dyn Property) {
-        self.set(value);
-    }
-
-    fn set(&mut self, value: &dyn Property) {
-        let value = value.any();
-        if let Some(prop) = value.downcast_ref::<Self>() {
-            *self = *prop;
-        } else if let Some(prop) = value.downcast_ref::<usize>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<u32>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<u16>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<u8>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<isize>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<i64>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<i32>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<i16>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<i8>() {
-            *self = *prop as Self;
-        } else {
-            panic!("prop value is not {}", std::any::type_name::<Self>());
-        }
-    }
-
-    fn serializable<'a>(&'a self, _registry: &'a PropertyTypeRegistry) -> Serializable<'a> {
-        Serializable::Borrowed(self)
-    }
-}
-
-impl Property for u32 {
-    #[inline]
-    fn type_name(&self) -> &str {
-        std::any::type_name::<Self>()
-    }
-
-    #[inline]
-    fn any(&self) -> &dyn Any {
-        self
-    }
-
-    #[inline]
-    fn any_mut(&mut self) -> &mut dyn Any {
-        self
-    }
-
-    #[inline]
-    fn clone_prop(&self) -> Box<dyn Property> {
-        Box::new(*self)
-    }
-
-    #[inline]
-    fn apply(&mut self, value: &dyn Property) {
-        self.set(value);
-    }
-
-    fn set(&mut self, value: &dyn Property) {
-        let value = value.any();
-        if let Some(prop) = value.downcast_ref::<Self>() {
-            *self = *prop;
-        } else if let Some(prop) = value.downcast_ref::<u64>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<usize>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<u16>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<u8>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<isize>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<i64>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<i32>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<i16>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<i8>() {
-            *self = *prop as Self;
-        } else {
-            panic!("prop value is not {}", std::any::type_name::<Self>());
-        }
-    }
-
-    fn serializable<'a>(&'a self, _registry: &'a PropertyTypeRegistry) -> Serializable<'a> {
-        Serializable::Borrowed(self)
-    }
-}
-
-impl Property for u16 {
-    #[inline]
-    fn type_name(&self) -> &str {
-        std::any::type_name::<Self>()
-    }
-
-    #[inline]
-    fn any(&self) -> &dyn Any {
-        self
-    }
-
-    #[inline]
-    fn any_mut(&mut self) -> &mut dyn Any {
-        self
-    }
-
-    #[inline]
-    fn clone_prop(&self) -> Box<dyn Property> {
-        Box::new(*self)
-    }
-
-    #[inline]
-    fn apply(&mut self, value: &dyn Property) {
-        self.set(value);
-    }
-
-    fn set(&mut self, value: &dyn Property) {
-        let value = value.any();
-        if let Some(prop) = value.downcast_ref::<Self>() {
-            *self = *prop;
-        } else if let Some(prop) = value.downcast_ref::<u64>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<u32>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<usize>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<u8>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<isize>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<i64>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<i32>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<i16>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<i8>() {
-            *self = *prop as Self;
-        } else {
-            panic!("prop value is not {}", std::any::type_name::<Self>());
-        }
-    }
-
-    fn serializable<'a>(&'a self, _registry: &'a PropertyTypeRegistry) -> Serializable<'a> {
-        Serializable::Borrowed(self)
-    }
-}
-
-impl Property for u8 {
-    #[inline]
-    fn type_name(&self) -> &str {
-        std::any::type_name::<Self>()
-    }
-
-    #[inline]
-    fn any(&self) -> &dyn Any {
-        self
-    }
-
-    #[inline]
-    fn any_mut(&mut self) -> &mut dyn Any {
-        self
-    }
-
-    #[inline]
-    fn clone_prop(&self) -> Box<dyn Property> {
-        Box::new(*self)
-    }
-
-    #[inline]
-    fn apply(&mut self, value: &dyn Property) {
-        self.set(value);
-    }
-
-    fn set(&mut self, value: &dyn Property) {
-        let value = value.any();
-        if let Some(prop) = value.downcast_ref::<Self>() {
-            *self = *prop;
-        } else if let Some(prop) = value.downcast_ref::<u64>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<u32>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<u16>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<usize>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<isize>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<i64>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<i32>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<i16>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<i8>() {
-            *self = *prop as Self;
-        } else {
-            panic!("prop value is not {}", std::any::type_name::<Self>());
-        }
-    }
-
-    fn serializable<'a>(&'a self, _registry: &'a PropertyTypeRegistry) -> Serializable<'a> {
-        Serializable::Borrowed(self)
-    }
-}
-
-impl Property for isize {
-    #[inline]
-    fn type_name(&self) -> &str {
-        std::any::type_name::<Self>()
-    }
-
-    #[inline]
-    fn any(&self) -> &dyn Any {
-        self
-    }
-
-    #[inline]
-    fn any_mut(&mut self) -> &mut dyn Any {
-        self
-    }
-
-    #[inline]
-    fn clone_prop(&self) -> Box<dyn Property> {
-        Box::new(*self)
-    }
-
-    #[inline]
-    fn apply(&mut self, value: &dyn Property) {
-        self.set(value);
-    }
-
-    fn set(&mut self, value: &dyn Property) {
-        let value = value.any();
-        if let Some(prop) = value.downcast_ref::<Self>() {
-            *self = *prop;
-        } else if let Some(prop) = value.downcast_ref::<i64>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<i32>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<i16>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<i8>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<usize>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<u64>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<u32>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<u16>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<u8>() {
-            *self = *prop as Self;
-        } else {
-            panic!("prop value is not {}", std::any::type_name::<Self>());
-        }
-    }
-
-    fn serializable<'a>(&'a self, _registry: &'a PropertyTypeRegistry) -> Serializable<'a> {
-        Serializable::Borrowed(self)
-    }
-}
-
-impl Property for i64 {
-    #[inline]
-    fn type_name(&self) -> &str {
-        std::any::type_name::<Self>()
-    }
-
-    #[inline]
-    fn any(&self) -> &dyn Any {
-        self
-    }
-
-    #[inline]
-    fn any_mut(&mut self) -> &mut dyn Any {
-        self
-    }
-
-    #[inline]
-    fn clone_prop(&self) -> Box<dyn Property> {
-        Box::new(*self)
-    }
-
-    #[inline]
-    fn apply(&mut self, value: &dyn Property) {
-        self.set(value);
-    }
-
-    fn set(&mut self, value: &dyn Property) {
-        let value = value.any();
-        if let Some(prop) = value.downcast_ref::<Self>() {
-            *self = *prop;
-        } else if let Some(prop) = value.downcast_ref::<isize>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<i32>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<i16>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<i8>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<usize>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<u64>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<u32>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<u16>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<u8>() {
-            *self = *prop as Self;
-        } else {
-            panic!("prop value is not {}", std::any::type_name::<Self>());
-        }
-    }
-
-    fn serializable<'a>(&'a self, _registry: &'a PropertyTypeRegistry) -> Serializable<'a> {
-        Serializable::Borrowed(self)
-    }
-}
-
-impl Property for i32 {
-    #[inline]
-    fn type_name(&self) -> &str {
-        std::any::type_name::<Self>()
-    }
-
-    #[inline]
-    fn any(&self) -> &dyn Any {
-        self
-    }
-
-    #[inline]
-    fn any_mut(&mut self) -> &mut dyn Any {
-        self
-    }
-
-    #[inline]
-    fn clone_prop(&self) -> Box<dyn Property> {
-        Box::new(*self)
-    }
-
-    #[inline]
-    fn apply(&mut self, value: &dyn Property) {
-        self.set(value);
-    }
-
-    fn set(&mut self, value: &dyn Property) {
-        let value = value.any();
-        if let Some(prop) = value.downcast_ref::<Self>() {
-            *self = *prop;
-        } else if let Some(prop) = value.downcast_ref::<i64>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<isize>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<i16>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<i8>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<usize>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<u64>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<u32>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<u16>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<u8>() {
-            *self = *prop as Self;
-        } else {
-            panic!("prop value is not {}", std::any::type_name::<Self>());
-        }
-    }
-
-    fn serializable<'a>(&'a self, _registry: &'a PropertyTypeRegistry) -> Serializable<'a> {
-        Serializable::Borrowed(self)
-    }
-}
-
-impl Property for i16 {
-    #[inline]
-    fn type_name(&self) -> &str {
-        std::any::type_name::<Self>()
-    }
-
-    #[inline]
-    fn any(&self) -> &dyn Any {
-        self
-    }
-
-    #[inline]
-    fn any_mut(&mut self) -> &mut dyn Any {
-        self
-    }
-
-    #[inline]
-    fn clone_prop(&self) -> Box<dyn Property> {
-        Box::new(*self)
-    }
-
-    #[inline]
-    fn apply(&mut self, value: &dyn Property) {
-        self.set(value);
-    }
-
-    fn set(&mut self, value: &dyn Property) {
-        let value = value.any();
-        if let Some(prop) = value.downcast_ref::<Self>() {
-            *self = *prop;
-        } else if let Some(prop) = value.downcast_ref::<i64>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<i32>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<isize>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<i8>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<usize>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<u64>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<u32>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<u16>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<u8>() {
-            *self = *prop as Self;
-        } else {
-            panic!("prop value is not {}", std::any::type_name::<Self>());
-        }
-    }
-
-    fn serializable<'a>(&'a self, _registry: &'a PropertyTypeRegistry) -> Serializable<'a> {
-        Serializable::Borrowed(self)
-    }
-}
-
-impl Property for i8 {
-    #[inline]
-    fn type_name(&self) -> &str {
-        std::any::type_name::<Self>()
-    }
-
-    #[inline]
-    fn any(&self) -> &dyn Any {
-        self
-    }
-
-    #[inline]
-    fn any_mut(&mut self) -> &mut dyn Any {
-        self
-    }
-
-    #[inline]
-    fn clone_prop(&self) -> Box<dyn Property> {
-        Box::new(*self)
-    }
-
-    #[inline]
-    fn apply(&mut self, value: &dyn Property) {
-        self.set(value);
-    }
-
-    fn set(&mut self, value: &dyn Property) {
-        let value = value.any();
-        if let Some(prop) = value.downcast_ref::<Self>() {
-            *self = *prop;
-        } else if let Some(prop) = value.downcast_ref::<i64>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<i32>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<i16>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<isize>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<usize>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<u64>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<u32>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<u16>() {
-            *self = *prop as Self;
-        } else if let Some(prop) = value.downcast_ref::<u8>() {
-            *self = *prop as Self;
-        } else {
-            panic!("prop value is not {}", std::any::type_name::<Self>());
-        }
-    }
-
-    fn serializable<'a>(&'a self, _registry: &'a PropertyTypeRegistry) -> Serializable<'a> {
-        Serializable::Borrowed(self)
-    }
-}
-
-impl Property for f32 {
-    #[inline]
-    fn type_name(&self) -> &str {
-        std::any::type_name::<Self>()
-    }
-
-    #[inline]
-    fn any(&self) -> &dyn Any {
-        self
-    }
-
-    #[inline]
-    fn any_mut(&mut self) -> &mut dyn Any {
-        self
-    }
-
-    #[inline]
-    fn clone_prop(&self) -> Box<dyn Property> {
-        Box::new(*self)
-    }
-
-    #[inline]
-    fn apply(&mut self, value: &dyn Property) {
-        self.set(value);
-    }
-
-    fn set(&mut self, value: &dyn Property) {
-        let value = value.any();
-        if let Some(prop) = value.downcast_ref::<Self>() {
-            *self = *prop;
-        } else if let Some(prop) = value.downcast_ref::<f64>() {
-            *self = *prop as Self;
-        } else {
-            panic!("prop value is not {}", std::any::type_name::<Self>());
-        }
-    }
-
-    fn serializable<'a>(&'a self, _registry: &'a PropertyTypeRegistry) -> Serializable<'a> {
-        Serializable::Borrowed(self)
-    }
-}
-
-impl Property for f64 {
-    #[inline]
-    fn type_name(&self) -> &str {
-        std::any::type_name::<Self>()
-    }
-
-    #[inline]
-    fn any(&self) -> &dyn Any {
-        self
-    }
-
-    #[inline]
-    fn any_mut(&mut self) -> &mut dyn Any {
-        self
-    }
-
-    #[inline]
-    fn clone_prop(&self) -> Box<dyn Property> {
-        Box::new(*self)
-    }
-
-    #[inline]
-    fn apply(&mut self, value: &dyn Property) {
-        self.set(value);
-    }
-
-    fn set(&mut self, value: &dyn Property) {
-        let value = value.any();
-        if let Some(prop) = value.downcast_ref::<Self>() {
-            *self = *prop;
-        } else if let Some(prop) = value.downcast_ref::<f32>() {
-            *self = *prop as Self;
-        } else {
-            panic!("prop value is not {}", std::any::type_name::<Self>());
-        }
-    }
-
-    fn serializable<'a>(&'a self, _registry: &'a PropertyTypeRegistry) -> Serializable<'a> {
-        Serializable::Borrowed(self)
-    }
-}
diff --git a/crates/bevy_property/src/impl_property/mod.rs b/crates/bevy_property/src/impl_property/mod.rs
deleted file mode 100644
index a81be0bf6b181..0000000000000
--- a/crates/bevy_property/src/impl_property/mod.rs
+++ /dev/null
@@ -1,4 +0,0 @@
-mod impl_property_bevy_ecs;
-mod impl_property_glam;
-mod impl_property_smallvec;
-mod impl_property_std;
diff --git a/crates/bevy_property/src/lib.rs b/crates/bevy_property/src/lib.rs
deleted file mode 100644
index 87c2953e49c7a..0000000000000
--- a/crates/bevy_property/src/lib.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-pub mod impl_property;
-pub mod property_serde;
-pub mod ron;
-
-mod dynamic_properties;
-mod properties;
-mod property;
-mod type_registry;
-
-pub use dynamic_properties::*;
-pub use properties::*;
-pub use property::*;
-pub use type_registry::*;
-
-pub use bevy_property_derive::*;
-pub use erased_serde;
-pub use serde;
-
-pub mod prelude {
-    pub use crate::{DynamicProperties, Properties, PropertiesVal, Property, PropertyVal};
-}
diff --git a/crates/bevy_property/src/properties.rs b/crates/bevy_property/src/properties.rs
deleted file mode 100644
index 66b08c973ebe2..0000000000000
--- a/crates/bevy_property/src/properties.rs
+++ /dev/null
@@ -1,92 +0,0 @@
-use crate::{DynamicProperties, Property, PropertyType, PropertyVal};
-
-pub trait Properties: Property {
-    fn prop(&self, name: &str) -> Option<&dyn Property>;
-    fn prop_mut(&mut self, name: &str) -> Option<&mut dyn Property>;
-    fn prop_with_index(&self, index: usize) -> Option<&dyn Property>;
-    fn prop_with_index_mut(&mut self, index: usize) -> Option<&mut dyn Property>;
-    fn prop_name(&self, index: usize) -> Option<&str>;
-    fn prop_len(&self) -> usize;
-    fn iter_props(&self) -> PropertyIter;
-    fn set_prop(&mut self, name: &str, value: &dyn Property) {
-        if let Some(prop) = self.prop_mut(name) {
-            prop.set(value);
-        } else {
-            panic!("prop does not exist: {}", name);
-        }
-    }
-    fn to_dynamic(&self) -> DynamicProperties {
-        let mut dynamic_props = match self.property_type() {
-            PropertyType::Map => {
-                let mut dynamic_props = DynamicProperties::map();
-                for (i, prop) in self.iter_props().enumerate() {
-                    let name = self
-                        .prop_name(i)
-                        .expect("All properties in maps should have a name");
-                    dynamic_props.set_box(name, prop.clone_prop());
-                }
-                dynamic_props
-            }
-            PropertyType::Seq => {
-                let mut dynamic_props = DynamicProperties::seq();
-                for prop in self.iter_props() {
-                    dynamic_props.push(prop.clone_prop(), None);
-                }
-                dynamic_props
-            }
-            _ => panic!("Properties cannot be Value types"),
-        };
-
-        dynamic_props.type_name = self.type_name().to_string();
-        dynamic_props
-    }
-}
-
-pub struct PropertyIter<'a> {
-    pub(crate) props: &'a dyn Properties,
-    pub(crate) index: usize,
-}
-
-impl<'a> PropertyIter<'a> {
-    pub fn new(props: &'a dyn Properties) -> Self {
-        PropertyIter { props, index: 0 }
-    }
-}
-
-impl<'a> Iterator for PropertyIter<'a> {
-    type Item = &'a dyn Property;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        if self.index < self.props.prop_len() {
-            let prop = self.props.prop_with_index(self.index).unwrap();
-            self.index += 1;
-            Some(prop)
-        } else {
-            None
-        }
-    }
-}
-
-pub trait PropertiesVal {
-    fn prop_val<T: 'static>(&self, name: &str) -> Option<&T>;
-    fn set_prop_val<T: 'static>(&mut self, name: &str, value: T);
-}
-
-impl<P> PropertiesVal for P
-where
-    P: Properties,
-{
-    #[inline]
-    fn prop_val<T: 'static>(&self, name: &str) -> Option<&T> {
-        self.prop(name).and_then(|p| p.any().downcast_ref::<T>())
-    }
-
-    #[inline]
-    fn set_prop_val<T: 'static>(&mut self, name: &str, value: T) {
-        if let Some(prop) = self.prop_mut(name) {
-            prop.set_val(value);
-        } else {
-            panic!("prop does not exist or is incorrect type: {}", name);
-        }
-    }
-}
diff --git a/crates/bevy_property/src/property.rs b/crates/bevy_property/src/property.rs
deleted file mode 100644
index 6385531f751de..0000000000000
--- a/crates/bevy_property/src/property.rs
+++ /dev/null
@@ -1,55 +0,0 @@
-use crate::{property_serde::Serializable, Properties, PropertyTypeRegistry};
-use erased_serde::Deserializer;
-use std::any::Any;
-
-#[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Debug)]
-pub enum PropertyType {
-    Map,
-    Seq,
-    Value,
-}
-
-// TODO: consider removing send + sync requirements
-pub trait Property: Send + Sync + Any + 'static {
-    fn type_name(&self) -> &str;
-    fn any(&self) -> &dyn Any;
-    fn any_mut(&mut self) -> &mut dyn Any;
-    fn clone_prop(&self) -> Box<dyn Property>;
-    fn set(&mut self, value: &dyn Property);
-    fn apply(&mut self, value: &dyn Property);
-    fn property_type(&self) -> PropertyType {
-        PropertyType::Value
-    }
-    fn as_properties(&self) -> Option<&dyn Properties> {
-        None
-    }
-    fn serializable<'a>(&'a self, registry: &'a PropertyTypeRegistry) -> Serializable<'a>;
-}
-
-pub trait DeserializeProperty {
-    fn deserialize(
-        deserializer: &mut dyn Deserializer,
-        property_type_registry: &PropertyTypeRegistry,
-    ) -> Result<Box<dyn Property>, erased_serde::Error>;
-}
-
-pub trait PropertyVal {
-    fn val<T: 'static>(&self) -> Option<&T>;
-    fn set_val<T: 'static>(&mut self, value: T);
-}
-
-impl PropertyVal for dyn Property {
-    #[inline]
-    fn val<T: 'static>(&self) -> Option<&T> {
-        self.any().downcast_ref::<T>()
-    }
-
-    #[inline]
-    fn set_val<T: 'static>(&mut self, value: T) {
-        if let Some(prop) = self.any_mut().downcast_mut::<T>() {
-            *prop = value;
-        } else {
-            panic!("prop value is not {}", std::any::type_name::<T>());
-        }
-    }
-}
diff --git a/crates/bevy_property/src/property_serde.rs b/crates/bevy_property/src/property_serde.rs
deleted file mode 100644
index 93921b4689033..0000000000000
--- a/crates/bevy_property/src/property_serde.rs
+++ /dev/null
@@ -1,545 +0,0 @@
-use crate::{DynamicProperties, Properties, Property, PropertyType, PropertyTypeRegistry};
-use de::SeqAccess;
-use serde::{
-    de::{self, DeserializeSeed, MapAccess, Visitor},
-    ser::{SerializeMap, SerializeSeq},
-    Serialize,
-};
-
-pub const TYPE_FIELD: &str = "type";
-pub const MAP_FIELD: &str = "map";
-pub const SEQ_FIELD: &str = "seq";
-pub const VALUE_FIELD: &str = "value";
-
-pub enum Serializable<'a> {
-    Owned(Box<dyn erased_serde::Serialize + 'a>),
-    Borrowed(&'a dyn erased_serde::Serialize),
-}
-
-impl<'a> Serializable<'a> {
-    #[allow(clippy::should_implement_trait)]
-    pub fn borrow(&self) -> &dyn erased_serde::Serialize {
-        match self {
-            Serializable::Borrowed(serialize) => serialize,
-            Serializable::Owned(serialize) => serialize,
-        }
-    }
-}
-
-pub struct PropertyValueSerializer<'a, T>
-where
-    T: Property + Serialize,
-{
-    pub property: &'a T,
-    pub registry: &'a PropertyTypeRegistry,
-}
-
-impl<'a, T> PropertyValueSerializer<'a, T>
-where
-    T: Property + Serialize,
-{
-    pub fn new(property: &'a T, registry: &'a PropertyTypeRegistry) -> Self {
-        PropertyValueSerializer { property, registry }
-    }
-}
-
-impl<'a, T> Serialize for PropertyValueSerializer<'a, T>
-where
-    T: Property + Serialize,
-{
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        let mut state = serializer.serialize_map(Some(2))?;
-        state.serialize_entry(
-            TYPE_FIELD,
-            format_type_name(self.registry, self.property.type_name()),
-        )?;
-        state.serialize_entry(VALUE_FIELD, self.property)?;
-        state.end()
-    }
-}
-
-pub struct DynamicPropertiesSerializer<'a> {
-    pub dynamic_properties: &'a DynamicProperties,
-    pub registry: &'a PropertyTypeRegistry,
-}
-
-impl<'a> DynamicPropertiesSerializer<'a> {
-    pub fn new(
-        dynamic_properties: &'a DynamicProperties,
-        registry: &'a PropertyTypeRegistry,
-    ) -> Self {
-        DynamicPropertiesSerializer {
-            dynamic_properties,
-            registry,
-        }
-    }
-}
-
-impl<'a> Serialize for DynamicPropertiesSerializer<'a> {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        match self.dynamic_properties.property_type {
-            PropertyType::Map => {
-                MapSerializer::new(self.dynamic_properties, self.registry).serialize(serializer)
-            }
-            PropertyType::Seq => {
-                SeqSerializer::new(self.dynamic_properties, self.registry).serialize(serializer)
-            }
-            _ => Err(serde::ser::Error::custom(
-                "DynamicProperties cannot be Value type",
-            )),
-        }
-    }
-}
-
-pub struct MapSerializer<'a> {
-    pub properties: &'a dyn Properties,
-    pub registry: &'a PropertyTypeRegistry,
-}
-
-impl<'a> MapSerializer<'a> {
-    pub fn new(properties: &'a dyn Properties, registry: &'a PropertyTypeRegistry) -> Self {
-        MapSerializer {
-            properties,
-            registry,
-        }
-    }
-}
-
-fn format_type_name<'a>(registry: &'a PropertyTypeRegistry, type_name: &'a str) -> &'a str {
-    registry.format_type_name(type_name).unwrap_or(type_name)
-}
-
-impl<'a> Serialize for MapSerializer<'a> {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        let mut state = serializer.serialize_map(Some(2))?;
-
-        state.serialize_entry(
-            TYPE_FIELD,
-            format_type_name(self.registry, self.properties.type_name()),
-        )?;
-        state.serialize_entry(
-            MAP_FIELD,
-            &MapValueSerializer {
-                properties: self.properties,
-                registry: self.registry,
-            },
-        )?;
-        state.end()
-    }
-}
-
-pub struct MapValueSerializer<'a> {
-    pub properties: &'a dyn Properties,
-    pub registry: &'a PropertyTypeRegistry,
-}
-
-impl<'a> Serialize for MapValueSerializer<'a> {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        let mut state = serializer.serialize_map(Some(self.properties.prop_len()))?;
-        for (index, property) in self.properties.iter_props().enumerate() {
-            let name = self.properties.prop_name(index).unwrap();
-            state.serialize_entry(name, property.serializable(self.registry).borrow())?;
-        }
-        state.end()
-    }
-}
-
-pub struct SeqSerializer<'a> {
-    pub properties: &'a dyn Properties,
-    pub registry: &'a PropertyTypeRegistry,
-}
-
-impl<'a> SeqSerializer<'a> {
-    pub fn new(properties: &'a dyn Properties, registry: &'a PropertyTypeRegistry) -> Self {
-        SeqSerializer {
-            properties,
-            registry,
-        }
-    }
-}
-
-impl<'a> Serialize for SeqSerializer<'a> {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        let mut state = serializer.serialize_map(Some(2))?;
-        state.serialize_entry(
-            TYPE_FIELD,
-            format_type_name(self.registry, self.properties.type_name()),
-        )?;
-        state.serialize_entry(
-            SEQ_FIELD,
-            &SeqValueSerializer {
-                properties: self.properties,
-                registry: self.registry,
-            },
-        )?;
-        state.end()
-    }
-}
-
-pub struct SeqValueSerializer<'a> {
-    pub properties: &'a dyn Properties,
-    pub registry: &'a PropertyTypeRegistry,
-}
-
-impl<'a> Serialize for SeqValueSerializer<'a> {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        let mut state = serializer.serialize_seq(Some(self.properties.prop_len()))?;
-        for prop in self.properties.iter_props() {
-            state.serialize_element(prop.serializable(self.registry).borrow())?;
-        }
-        state.end()
-    }
-}
-
-pub struct DynamicPropertiesDeserializer<'a> {
-    registry: &'a PropertyTypeRegistry,
-}
-
-impl<'a> DynamicPropertiesDeserializer<'a> {
-    pub fn new(registry: &'a PropertyTypeRegistry) -> Self {
-        DynamicPropertiesDeserializer { registry }
-    }
-}
-
-impl<'a, 'de> DeserializeSeed<'de> for DynamicPropertiesDeserializer<'a> {
-    type Value = DynamicProperties;
-
-    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        deserializer.deserialize_map(DynamicPropertiesVisitor {
-            registry: self.registry,
-        })
-    }
-}
-
-struct DynamicPropertiesVisitor<'a> {
-    registry: &'a PropertyTypeRegistry,
-}
-
-impl<'a, 'de> Visitor<'de> for DynamicPropertiesVisitor<'a> {
-    type Value = DynamicProperties;
-
-    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
-        formatter.write_str("dynamic property")
-    }
-
-    fn visit_map<V>(self, map: V) -> Result<Self::Value, V::Error>
-    where
-        V: MapAccess<'de>,
-    {
-        match visit_map(map, self.registry)? {
-            DynamicPropertiesOrProperty::DynamicProperties(value) => Ok(value),
-            _ => Err(de::Error::custom("Expected DynamicProperties")),
-        }
-    }
-}
-
-pub struct PropertyDeserializer<'a> {
-    type_name: Option<&'a str>,
-    registry: &'a PropertyTypeRegistry,
-}
-
-impl<'a, 'de> DeserializeSeed<'de> for PropertyDeserializer<'a> {
-    type Value = Box<dyn Property>;
-
-    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        if let Some(type_name) = self.type_name {
-            let registration = self.registry.get(type_name).ok_or_else(|| {
-                de::Error::custom(format!("TypeRegistration is missing for {}", type_name))
-            })?;
-            registration.deserialize(deserializer, self.registry)
-        } else {
-            deserializer.deserialize_any(AnyPropVisitor {
-                registry: self.registry,
-            })
-        }
-    }
-}
-
-pub struct SeqPropertyDeserializer<'a> {
-    registry: &'a PropertyTypeRegistry,
-}
-
-impl<'a, 'de> DeserializeSeed<'de> for SeqPropertyDeserializer<'a> {
-    type Value = DynamicProperties;
-
-    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        deserializer.deserialize_seq(SeqPropertyVisitor {
-            registry: self.registry,
-        })
-    }
-}
-
-pub struct SeqPropertyVisitor<'a> {
-    registry: &'a PropertyTypeRegistry,
-}
-
-impl<'a, 'de> Visitor<'de> for SeqPropertyVisitor<'a> {
-    type Value = DynamicProperties;
-
-    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
-        formatter.write_str("property value")
-    }
-
-    fn visit_seq<V>(self, mut seq: V) -> Result<Self::Value, V::Error>
-    where
-        V: SeqAccess<'de>,
-    {
-        let mut dynamic_properties = DynamicProperties::seq();
-        while let Some(prop) = seq.next_element_seed(PropertyDeserializer {
-            registry: self.registry,
-            type_name: None,
-        })? {
-            dynamic_properties.push(prop, None);
-        }
-        Ok(dynamic_properties)
-    }
-}
-
-pub struct MapPropertyDeserializer<'a> {
-    registry: &'a PropertyTypeRegistry,
-}
-
-impl<'a> MapPropertyDeserializer<'a> {
-    pub fn new(registry: &'a PropertyTypeRegistry) -> Self {
-        MapPropertyDeserializer { registry }
-    }
-}
-
-impl<'a, 'de> DeserializeSeed<'de> for MapPropertyDeserializer<'a> {
-    type Value = DynamicProperties;
-
-    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        deserializer.deserialize_map(MapPropertyVisitor {
-            registry: self.registry,
-        })
-    }
-}
-
-struct MapPropertyVisitor<'a> {
-    registry: &'a PropertyTypeRegistry,
-}
-
-impl<'a, 'de> Visitor<'de> for MapPropertyVisitor<'a> {
-    type Value = DynamicProperties;
-
-    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
-        formatter.write_str("map value")
-    }
-
-    fn visit_map<V>(self, mut map: V) -> Result<Self::Value, V::Error>
-    where
-        V: MapAccess<'de>,
-    {
-        let mut dynamic_properties = DynamicProperties::map();
-        while let Some(key) = map.next_key::<String>()? {
-            let property = map.next_value_seed(PropertyDeserializer {
-                registry: self.registry,
-                type_name: None,
-            })?;
-            dynamic_properties.set_box(&key, property);
-        }
-
-        Ok(dynamic_properties)
-    }
-}
-
-struct AnyPropVisitor<'a> {
-    registry: &'a PropertyTypeRegistry,
-}
-
-impl<'a, 'de> Visitor<'de> for AnyPropVisitor<'a> {
-    type Value = Box<dyn Property>;
-
-    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
-        formatter.write_str("property value")
-    }
-
-    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E>
-    where
-        E: de::Error,
-    {
-        Ok(Box::new(v))
-    }
-
-    fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
-    where
-        E: de::Error,
-    {
-        Ok(Box::new(v))
-    }
-
-    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
-    where
-        E: de::Error,
-    {
-        Ok(Box::new(v))
-    }
-
-    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
-    where
-        E: de::Error,
-    {
-        Ok(Box::new(v))
-    }
-
-    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
-    where
-        E: de::Error,
-    {
-        Ok(Box::new(v))
-    }
-
-    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E>
-    where
-        E: de::Error,
-    {
-        Ok(Box::new(v))
-    }
-
-    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
-    where
-        E: de::Error,
-    {
-        Ok(Box::new(v))
-    }
-
-    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
-    where
-        E: de::Error,
-    {
-        Ok(Box::new(v))
-    }
-
-    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
-    where
-        E: de::Error,
-    {
-        Ok(Box::new(v))
-    }
-
-    fn visit_f32<E>(self, v: f32) -> Result<Self::Value, E>
-    where
-        E: de::Error,
-    {
-        Ok(Box::new(v))
-    }
-
-    fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
-    where
-        E: de::Error,
-    {
-        Ok(Box::new(v))
-    }
-
-    fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
-    where
-        E: de::Error,
-    {
-        Ok(Box::new(v))
-    }
-
-    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
-    where
-        E: de::Error,
-    {
-        Ok(Box::new(v.to_string()))
-    }
-
-    fn visit_map<V>(self, map: V) -> Result<Self::Value, V::Error>
-    where
-        V: MapAccess<'de>,
-    {
-        Ok(match visit_map(map, self.registry)? {
-            DynamicPropertiesOrProperty::DynamicProperties(value) => Box::new(value),
-            DynamicPropertiesOrProperty::Property(value) => value,
-        })
-    }
-}
-
-enum DynamicPropertiesOrProperty {
-    DynamicProperties(DynamicProperties),
-    Property(Box<dyn Property>),
-}
-
-fn visit_map<'de, V>(
-    mut map: V,
-    registry: &PropertyTypeRegistry,
-) -> Result<DynamicPropertiesOrProperty, V::Error>
-where
-    V: MapAccess<'de>,
-{
-    let mut type_name: Option<String> = None;
-    while let Some(key) = map.next_key::<String>()? {
-        match key.as_str() {
-            TYPE_FIELD => {
-                type_name = Some(map.next_value()?);
-            }
-            MAP_FIELD => {
-                let type_name = type_name
-                    .take()
-                    .ok_or_else(|| de::Error::missing_field(TYPE_FIELD))?;
-                let mut dynamic_properties =
-                    map.next_value_seed(MapPropertyDeserializer { registry })?;
-                dynamic_properties.type_name = type_name;
-                return Ok(DynamicPropertiesOrProperty::DynamicProperties(
-                    dynamic_properties,
-                ));
-            }
-            SEQ_FIELD => {
-                let type_name = type_name
-                    .take()
-                    .ok_or_else(|| de::Error::missing_field(TYPE_FIELD))?;
-                let mut dynamic_properties =
-                    map.next_value_seed(SeqPropertyDeserializer { registry })?;
-                dynamic_properties.type_name = type_name;
-                return Ok(DynamicPropertiesOrProperty::DynamicProperties(
-                    dynamic_properties,
-                ));
-            }
-            VALUE_FIELD => {
-                let type_name = type_name
-                    .take()
-                    .ok_or_else(|| de::Error::missing_field(TYPE_FIELD))?;
-                return Ok(DynamicPropertiesOrProperty::Property(map.next_value_seed(
-                    PropertyDeserializer {
-                        registry,
-                        type_name: Some(&type_name),
-                    },
-                )?));
-            }
-            _ => return Err(de::Error::unknown_field(key.as_str(), &[])),
-        }
-    }
-
-    Err(de::Error::custom("Maps in this location must have the \'type\' field and one of the following fields: \'map\', \'seq\', \'value\'"))
-}
diff --git a/crates/bevy_property/src/ron.rs b/crates/bevy_property/src/ron.rs
deleted file mode 100644
index d5b472c11e33d..0000000000000
--- a/crates/bevy_property/src/ron.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-use crate::{
-    property_serde::DynamicPropertiesDeserializer, DynamicProperties, PropertyTypeRegistry,
-};
-use ron::de::Deserializer;
-use serde::de::DeserializeSeed;
-
-pub fn deserialize_dynamic_properties(
-    ron_string: &str,
-    property_type_registry: &PropertyTypeRegistry,
-) -> Result<DynamicProperties, ron::Error> {
-    let mut deserializer = Deserializer::from_str(&ron_string).unwrap();
-    let dynamic_properties_deserializer =
-        DynamicPropertiesDeserializer::new(&property_type_registry);
-    dynamic_properties_deserializer.deserialize(&mut deserializer)
-}
diff --git a/crates/bevy_property/src/type_registry.rs b/crates/bevy_property/src/type_registry.rs
deleted file mode 100644
index 19d958b533689..0000000000000
--- a/crates/bevy_property/src/type_registry.rs
+++ /dev/null
@@ -1,235 +0,0 @@
-use crate::{DeserializeProperty, Property};
-use bevy_utils::{HashMap, HashSet};
-use std::{any::TypeId, fmt};
-
-#[derive(Debug, Default)]
-pub struct PropertyTypeRegistry {
-    registrations: HashMap<String, PropertyTypeRegistration>,
-    short_names: HashMap<String, String>,
-    ambiguous_names: HashSet<String>,
-}
-
-impl PropertyTypeRegistry {
-    pub fn register<T>(&mut self)
-    where
-        T: Property + DeserializeProperty,
-    {
-        let registration = PropertyTypeRegistration::of::<T>();
-        self.add_registration(registration);
-    }
-
-    fn add_registration(&mut self, registration: PropertyTypeRegistration) {
-        let short_name = registration.short_name.to_string();
-        if self.short_names.contains_key(&short_name) || self.ambiguous_names.contains(&short_name)
-        {
-            // name is ambiguous. fall back to long names for all ambiguous types
-            self.short_names.remove(&short_name);
-            self.ambiguous_names.insert(short_name);
-        } else {
-            self.short_names
-                .insert(short_name, registration.name.to_string());
-        }
-        self.registrations
-            .insert(registration.name.to_string(), registration);
-    }
-
-    pub fn get(&self, type_name: &str) -> Option<&PropertyTypeRegistration> {
-        if let Some(long_name) = self.short_names.get(type_name) {
-            self.registrations.get(long_name)
-        } else {
-            self.registrations.get(type_name)
-        }
-    }
-
-    pub fn format_type_name(&self, type_name: &str) -> Option<&str> {
-        self.get(type_name).map(|registration| {
-            if self.short_names.contains_key(&registration.short_name) {
-                &registration.short_name
-            } else {
-                registration.name
-            }
-        })
-    }
-
-    pub fn get_with_short_name(&self, short_type_name: &str) -> Option<&PropertyTypeRegistration> {
-        self.short_names
-            .get(short_type_name)
-            .and_then(|name| self.registrations.get(name))
-    }
-
-    pub fn get_with_full_name(&self, type_name: &str) -> Option<&PropertyTypeRegistration> {
-        self.registrations.get(type_name)
-    }
-}
-
-#[derive(Clone)]
-pub struct PropertyTypeRegistration {
-    pub ty: TypeId,
-    deserialize_fn: fn(
-        deserializer: &mut dyn erased_serde::Deserializer,
-        property_type_registry: &PropertyTypeRegistry,
-    ) -> Result<Box<dyn Property>, erased_serde::Error>,
-    pub short_name: String,
-    pub name: &'static str,
-}
-
-impl fmt::Debug for PropertyTypeRegistration {
-    fn fmt<'a>(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_struct("PropertyTypeRegistration")
-            .field("ty", &self.ty)
-            .field(
-                "deserialize_fn",
-                &(self.deserialize_fn
-                    as fn(
-                        deserializer: &'a mut dyn erased_serde::Deserializer<'a>,
-                        property_type_registry: &'a PropertyTypeRegistry,
-                    ) -> Result<Box<dyn Property>, erased_serde::Error>),
-            )
-            .field("short_name", &self.short_name)
-            .field("name", &self.name)
-            .finish()
-    }
-}
-
-impl PropertyTypeRegistration {
-    pub fn of<T: Property + DeserializeProperty>() -> Self {
-        let ty = TypeId::of::<T>();
-        let type_name = std::any::type_name::<T>();
-        Self {
-            ty,
-            deserialize_fn:
-                |deserializer: &mut dyn erased_serde::Deserializer,
-                 property_type_registry: &PropertyTypeRegistry| {
-                    T::deserialize(deserializer, property_type_registry)
-                },
-            name: type_name,
-            short_name: Self::get_short_name(type_name),
-        }
-    }
-
-    pub fn get_short_name(full_name: &str) -> String {
-        let mut short_name = String::new();
-
-        {
-            // A typename may be a composition of several other type names (e.g. generic parameters)
-            // separated by the characters that we try to find below.
-            // Then, each individual typename is shortened to its last path component.
-            //
-            // Note: Instead of `find`, `split_inclusive` would be nice but it's still unstable...
-            let mut remainder = full_name;
-            while let Some(index) = remainder.find(&['<', '>', '(', ')', '[', ']', ',', ';'][..]) {
-                let (path, new_remainder) = remainder.split_at(index);
-                // Push the shortened path in front of the found character
-                short_name.push_str(path.rsplit(':').next().unwrap());
-                // Push the character that was found
-                let character = new_remainder.chars().next().unwrap();
-                short_name.push(character);
-                // Advance the remainder
-                if character == ',' || character == ';' {
-                    // A comma or semicolon is always followed by a space
-                    short_name.push(' ');
-                    remainder = &new_remainder[2..];
-                } else {
-                    remainder = &new_remainder[1..];
-                }
-            }
-
-            // The remainder will only be non-empty if there were no matches at all
-            if !remainder.is_empty() {
-                // Then, the full typename is a path that has to be shortened
-                short_name.push_str(remainder.rsplit(':').next().unwrap());
-            }
-        }
-
-        short_name
-    }
-
-    pub fn deserialize<'de, D>(
-        &self,
-        deserializer: D,
-        registry: &PropertyTypeRegistry,
-    ) -> Result<Box<dyn Property>, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        let mut erased = erased_serde::Deserializer::erase(deserializer);
-        (self.deserialize_fn)(&mut erased, registry)
-            .map_err(<<D as serde::Deserializer<'de>>::Error as serde::de::Error>::custom)
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use crate::PropertyTypeRegistration;
-    use std::collections::HashMap;
-
-    #[test]
-    fn test_get_short_name() {
-        assert_eq!(
-            PropertyTypeRegistration::get_short_name(std::any::type_name::<f64>()),
-            "f64"
-        );
-        assert_eq!(
-            PropertyTypeRegistration::get_short_name(std::any::type_name::<String>()),
-            "String"
-        );
-        assert_eq!(
-            PropertyTypeRegistration::get_short_name(std::any::type_name::<(u32, f64)>()),
-            "(u32, f64)"
-        );
-        assert_eq!(
-            PropertyTypeRegistration::get_short_name(std::any::type_name::<(String, String)>()),
-            "(String, String)"
-        );
-        assert_eq!(
-            PropertyTypeRegistration::get_short_name(std::any::type_name::<[f64]>()),
-            "[f64]"
-        );
-        assert_eq!(
-            PropertyTypeRegistration::get_short_name(std::any::type_name::<[String]>()),
-            "[String]"
-        );
-        assert_eq!(
-            PropertyTypeRegistration::get_short_name(std::any::type_name::<[f64; 16]>()),
-            "[f64; 16]"
-        );
-        assert_eq!(
-            PropertyTypeRegistration::get_short_name(std::any::type_name::<[String; 16]>()),
-            "[String; 16]"
-        );
-    }
-
-    #[test]
-    fn test_property_type_registration() {
-        assert_eq!(
-            PropertyTypeRegistration::of::<Option<f64>>().short_name,
-            "Option<f64>"
-        );
-        assert_eq!(
-            PropertyTypeRegistration::of::<HashMap<u32, String>>().short_name,
-            "HashMap<u32, String>"
-        );
-        assert_eq!(
-            PropertyTypeRegistration::of::<Option<HashMap<u32, String>>>().short_name,
-            "Option<HashMap<u32, String>>"
-        );
-        assert_eq!(
-            PropertyTypeRegistration::of::<Option<HashMap<u32, Option<String>>>>().short_name,
-            "Option<HashMap<u32, Option<String>>>"
-        );
-        assert_eq!(
-            PropertyTypeRegistration::of::<Option<HashMap<String, Option<String>>>>().short_name,
-            "Option<HashMap<String, Option<String>>>"
-        );
-        assert_eq!(
-            PropertyTypeRegistration::of::<Option<HashMap<Option<String>, Option<String>>>>()
-                .short_name,
-            "Option<HashMap<Option<String>, Option<String>>>"
-        );
-        assert_eq!(
-            PropertyTypeRegistration::of::<Option<HashMap<Option<String>, (String, Option<String>)>>>()
-                .short_name,
-            "Option<HashMap<Option<String>, (String, Option<String>)>>"
-        );
-    }
-}
diff --git a/crates/bevy_reflect/Cargo.toml b/crates/bevy_reflect/Cargo.toml
new file mode 100644
index 0000000000000..35ca0f69fcffc
--- /dev/null
+++ b/crates/bevy_reflect/Cargo.toml
@@ -0,0 +1,36 @@
+[package]
+name = "bevy_reflect"
+version = "0.4.0"
+edition = "2018"
+authors = [
+    "Bevy Contributors <bevyengine@gmail.com>",
+    "Carter Anderson <mcanders1@gmail.com>",
+]
+description = "Dynamically interact with rust types"
+homepage = "https://bevyengine.org"
+repository = "https://github.com/bevyengine/bevy"
+license = "MIT"
+keywords = ["bevy"]
+readme = "README.md"
+
+[features]
+bevy = ["bevy_ecs", "bevy_app", "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"
+downcast-rs = "1.2"
+parking_lot = "0.11.0"
+thiserror = "1.0"
+serde = "1"
+smallvec = { version = "1.4", features = ["serde"], optional = true }
+glam = { version = "0.11.0", features = ["serde"], optional = true }
+
+[dev-dependencies]
+ron = "0.6.2"
diff --git a/crates/bevy_reflect/README.md b/crates/bevy_reflect/README.md
new file mode 100644
index 0000000000000..39c9048205021
--- /dev/null
+++ b/crates/bevy_reflect/README.md
@@ -0,0 +1,166 @@
+# Bevy Reflect
+
+This crate enables you to dynamically interact with Rust types:
+
+* Derive the Reflect traits
+* Interact with fields using their names (for named structs) or indices (for tuple structs)
+* "Patch" your types with new values
+* Look up nested fields using "path strings"
+* Iterate over struct fields
+* Automatically serialize and deserialize via Serde (without explicit serde impls)
+* Trait "reflection" 
+
+## Features
+
+### Derive the Reflect traits
+
+```rust
+// this will automatically implement the Reflect trait and the Struct trait (because the type is a struct)
+#[derive(Reflect)]
+struct Foo {
+    a: u32,
+    b: Bar,
+    c: Vec<i32>,
+    d: Vec<Bar>,
+}
+
+// this will automatically implement the Reflect trait and the TupleStruct trait (because the type is a tuple struct)
+#[derive(Reflect)]
+struct Bar(String);
+
+#[derive(Reflect)]
+struct Baz {
+    value: f32,
+}
+
+// We will use this value to illustrate `bevy_reflect` features
+let mut foo = Foo {
+    a: 1,
+    b: Bar("hello".to_string()),
+    c: vec![1, 2],
+    d: vec![Baz { value: 3.14 }],
+};
+```
+
+### Interact with fields using their names
+
+```rust
+assert_eq!(*foo.get_field::<u32>("a").unwrap(), 1);
+
+*foo.get_field_mut::<u32>("a").unwrap() = 2;
+
+assert_eq!(foo.a, 2);
+```
+
+### "Patch" your types with new values
+
+```rust
+let mut dynamic_struct = DynamicStruct::default();
+dynamic_struct.insert("a", 42u32);
+dynamic_struct.insert("c", vec![3, 4, 5]);
+
+foo.apply(&dynamic_struct);
+
+assert_eq!(foo.a, 42);
+assert_eq!(foo.c, vec![3, 4, 5]);
+```
+
+### Look up nested fields using "path strings"
+
+```rust
+let value = *foo.get_path::<f32>("d[0].value").unwrap();
+assert_eq!(value, 3.14);
+```
+
+### Iterate over struct fields
+
+```rust
+for (i, value: &Reflect) in foo.iter_fields().enumerate() {
+    let field_name = foo.name_at(i).unwrap();
+    if let Ok(value) = value.downcast_ref::<u32>() {
+        println!("{} is a u32 with the value: {}", field_name, *value);
+    } 
+}
+```
+
+### Automatically serialize and deserialize via Serde (without explicit serde impls)
+
+```rust
+let mut registry = TypeRegistry::default();
+registry.register::<u32>();
+registry.register::<i32>();
+registry.register::<f32>();
+registry.register::<String>();
+registry.register::<Bar>();
+registry.register::<Baz>();
+
+let serializer = ReflectSerializer::new(&foo, &registry);
+let serialized = ron::ser::to_string_pretty(&serializer, ron::ser::PrettyConfig::default()).unwrap();
+
+let mut deserializer = ron::de::Deserializer::from_str(&serialized).unwrap();
+let reflect_deserializer = ReflectDeserializer::new(&registry);
+let value = reflect_deserializer.deserialize(&mut deserializer).unwrap();
+let dynamic_struct = value.take::<DynamicStruct>().unwrap();
+
+assert!(foo.reflect_partial_eq(&dynamic_struct).unwrap());
+```
+
+### Trait "reflection"
+
+Call a trait on a given &dyn Reflect reference without knowing the underlying type!
+
+```rust
+#[derive(Reflect)]
+#[reflect(DoThing)]
+struct MyType {
+    value: String,
+}
+
+impl DoThing for MyType {
+    fn do_thing(&self) -> String {
+        format!("{} World!", self.value)
+    }
+}
+
+#[reflect_trait]
+pub trait DoThing {
+    fn do_thing(&self) -> String;
+}
+
+// First, lets box our type as a Box<dyn Reflect>
+let reflect_value: Box<dyn Reflect> = Box::new(MyType {
+    value: "Hello".to_string(),
+});
+
+// This means we no longer have direct access to MyType or its methods. We can only call Reflect methods on reflect_value.
+// What if we want to call `do_thing` on our type? We could downcast using reflect_value.downcast_ref::<MyType>(), but what if we
+// don't know the type at compile time?
+
+// Normally in rust we would be out of luck at this point. Lets use our new reflection powers to do something cool!
+let mut type_registry = TypeRegistry::default()
+type_registry.register::<MyType>();
+
+// The #[reflect] attribute we put on our DoThing trait generated a new `ReflectDoThing` struct, which implements TypeData.
+// This was added to MyType's TypeRegistration.
+let reflect_do_thing = type_registry
+    .get_type_data::<ReflectDoThing>(reflect_value.type_id())
+    .unwrap();
+
+// We can use this generated type to convert our `&dyn Reflect` reference to a `&dyn DoThing` reference
+let my_trait: &dyn DoThing = reflect_do_thing.get(&*reflect_value).unwrap();
+
+// Which means we can now call do_thing(). Magic!
+println!("{}", my_trait.do_thing());
+
+// This works because the #[reflect(MyTrait)] we put on MyType informed the Reflect derive to insert a new instance
+// of ReflectDoThing into MyType's registration. The instance knows how to cast &dyn Reflect to &dyn MyType, because it
+// knows that &dyn Reflect should first be downcasted to &MyType, which can then be safely casted to &dyn MyType
+```
+
+## Why make this?
+
+The whole point of Rust is static safety! Why build something that makes it easy to throw it all away?
+
+* Some problems are inherently dynamic (scripting, some types of serialization / deserialization)
+* Sometimes the dynamic way is easier
+* Sometimes the dynamic way puts less burden on your users to derive a bunch of traits (this was a big motivator for the Bevy project)
diff --git a/crates/bevy_property/bevy_property_derive/Cargo.toml b/crates/bevy_reflect/bevy_reflect_derive/Cargo.toml
similarity index 65%
rename from crates/bevy_property/bevy_property_derive/Cargo.toml
rename to crates/bevy_reflect/bevy_reflect_derive/Cargo.toml
index 0468aea134eca..d9e338082c96e 100644
--- a/crates/bevy_property/bevy_property_derive/Cargo.toml
+++ b/crates/bevy_reflect/bevy_reflect_derive/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
-name = "bevy_property_derive"
-version = "0.3.0"
+name = "bevy_reflect_derive"
+version = "0.4.0"
 edition = "2018"
 authors = [
     "Bevy Contributors <bevyengine@gmail.com>",
     "Carter Anderson <mcanders1@gmail.com>",
 ]
-description = "Derive implementations for bevy_property"
+description = "Derive implementations for bevy_reflect"
 homepage = "https://bevyengine.org"
 repository = "https://github.com/bevyengine/bevy"
 license = "MIT"
@@ -19,4 +19,5 @@ proc-macro = true
 syn = "1.0"
 proc-macro2 = "1.0"
 quote = "1.0"
-find-crate = "0.5"
+find-crate = "0.6"
+uuid = { version = "0.8", features = ["v4", "serde"] }
diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
new file mode 100644
index 0000000000000..73371602f1b6a
--- /dev/null
+++ b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
@@ -0,0 +1,751 @@
+extern crate proc_macro;
+
+mod modules;
+mod reflect_trait;
+mod type_uuid;
+
+use find_crate::Manifest;
+use modules::{get_modules, get_path};
+use proc_macro::TokenStream;
+use proc_macro2::Span;
+use quote::quote;
+use syn::{
+    parenthesized,
+    parse::{Parse, ParseStream},
+    parse_macro_input,
+    punctuated::Punctuated,
+    token::{Comma, Paren, Where},
+    Data, DataStruct, DeriveInput, Field, Fields, Generics, Ident, Index, Member, Meta, NestedMeta,
+    Path,
+};
+
+#[derive(Default)]
+struct PropAttributeArgs {
+    pub ignore: Option<bool>,
+}
+
+#[derive(Clone)]
+enum TraitImpl {
+    NotImplemented,
+    Implemented,
+    Custom(Ident),
+}
+
+impl Default for TraitImpl {
+    fn default() -> Self {
+        Self::NotImplemented
+    }
+}
+
+enum DeriveType {
+    Struct,
+    TupleStruct,
+    UnitStruct,
+    Value,
+}
+
+static REFLECT_ATTRIBUTE_NAME: &str = "reflect";
+static REFLECT_VALUE_ATTRIBUTE_NAME: &str = "reflect_value";
+
+#[proc_macro_derive(Reflect, attributes(reflect, reflect_value, module))]
+pub fn derive_reflect(input: TokenStream) -> TokenStream {
+    let ast = parse_macro_input!(input as DeriveInput);
+    let unit_struct_punctuated = Punctuated::new();
+    let (fields, mut derive_type) = match &ast.data {
+        Data::Struct(DataStruct {
+            fields: Fields::Named(fields),
+            ..
+        }) => (&fields.named, DeriveType::Struct),
+        Data::Struct(DataStruct {
+            fields: Fields::Unnamed(fields),
+            ..
+        }) => (&fields.unnamed, DeriveType::TupleStruct),
+        Data::Struct(DataStruct {
+            fields: Fields::Unit,
+            ..
+        }) => (&unit_struct_punctuated, DeriveType::UnitStruct),
+        _ => (&unit_struct_punctuated, DeriveType::Value),
+    };
+
+    let fields_and_args = fields
+        .iter()
+        .enumerate()
+        .map(|(i, f)| {
+            (
+                f,
+                f.attrs
+                    .iter()
+                    .find(|a| *a.path.get_ident().as_ref().unwrap() == REFLECT_ATTRIBUTE_NAME)
+                    .map(|a| {
+                        syn::custom_keyword!(ignore);
+                        let mut attribute_args = PropAttributeArgs { ignore: None };
+                        a.parse_args_with(|input: ParseStream| {
+                            if input.parse::<Option<ignore>>()?.is_some() {
+                                attribute_args.ignore = Some(true);
+                                return Ok(());
+                            }
+                            Ok(())
+                        })
+                        .expect("Invalid 'property' attribute format.");
+
+                        attribute_args
+                    }),
+                i,
+            )
+        })
+        .collect::<Vec<(&Field, Option<PropAttributeArgs>, usize)>>();
+    let active_fields = fields_and_args
+        .iter()
+        .filter(|(_field, attrs, _i)| {
+            attrs.is_none()
+                || match attrs.as_ref().unwrap().ignore {
+                    Some(ignore) => !ignore,
+                    None => true,
+                }
+        })
+        .map(|(f, _attr, i)| (*f, *i))
+        .collect::<Vec<(&Field, usize)>>();
+
+    let modules = get_modules();
+    let bevy_reflect_path = get_path(&modules.bevy_reflect);
+    let type_name = &ast.ident;
+
+    let mut reflect_attrs = ReflectAttrs::default();
+    for attribute in ast.attrs.iter().filter_map(|attr| attr.parse_meta().ok()) {
+        let meta_list = if let Meta::List(meta_list) = attribute {
+            meta_list
+        } else {
+            continue;
+        };
+
+        if let Some(ident) = meta_list.path.get_ident() {
+            if ident == REFLECT_ATTRIBUTE_NAME {
+                reflect_attrs = ReflectAttrs::from_nested_metas(&meta_list.nested);
+            } else if ident == REFLECT_VALUE_ATTRIBUTE_NAME {
+                derive_type = DeriveType::Value;
+                reflect_attrs = ReflectAttrs::from_nested_metas(&meta_list.nested);
+            }
+        }
+    }
+
+    let registration_data = &reflect_attrs.data;
+    let get_type_registration_impl = impl_get_type_registration(
+        type_name,
+        &bevy_reflect_path,
+        registration_data,
+        &ast.generics,
+    );
+
+    match derive_type {
+        DeriveType::Struct | DeriveType::UnitStruct => impl_struct(
+            type_name,
+            &ast.generics,
+            get_type_registration_impl,
+            &bevy_reflect_path,
+            &reflect_attrs,
+            &active_fields,
+        ),
+        DeriveType::TupleStruct => impl_tuple_struct(
+            type_name,
+            &ast.generics,
+            get_type_registration_impl,
+            &bevy_reflect_path,
+            &reflect_attrs,
+            &active_fields,
+        ),
+        DeriveType::Value => impl_value(
+            type_name,
+            &ast.generics,
+            get_type_registration_impl,
+            &bevy_reflect_path,
+            &reflect_attrs,
+        ),
+    }
+}
+
+fn impl_struct(
+    struct_name: &Ident,
+    generics: &Generics,
+    get_type_registration_impl: proc_macro2::TokenStream,
+    bevy_reflect_path: &Path,
+    reflect_attrs: &ReflectAttrs,
+    active_fields: &[(&Field, usize)],
+) -> TokenStream {
+    let field_names = active_fields
+        .iter()
+        .map(|(field, index)| {
+            field
+                .ident
+                .as_ref()
+                .map(|i| i.to_string())
+                .unwrap_or_else(|| index.to_string())
+        })
+        .collect::<Vec<String>>();
+    let field_idents = active_fields
+        .iter()
+        .map(|(field, index)| {
+            field
+                .ident
+                .as_ref()
+                .map(|ident| Member::Named(ident.clone()))
+                .unwrap_or_else(|| Member::Unnamed(Index::from(*index)))
+        })
+        .collect::<Vec<_>>();
+    let field_count = active_fields.len();
+    let field_indices = (0..field_count).collect::<Vec<usize>>();
+
+    let hash_fn = reflect_attrs.get_hash_impl(&bevy_reflect_path);
+    let serialize_fn = reflect_attrs.get_serialize_impl(&bevy_reflect_path);
+    let partial_eq_fn = match reflect_attrs.reflect_partial_eq {
+        TraitImpl::NotImplemented => quote! {
+            use #bevy_reflect_path::Struct;
+            #bevy_reflect_path::struct_partial_eq(self, value)
+        },
+        TraitImpl::Implemented | TraitImpl::Custom(_) => reflect_attrs.get_partial_eq_impl(),
+    };
+
+    let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
+
+    TokenStream::from(quote! {
+        #get_type_registration_impl
+
+        impl #impl_generics #bevy_reflect_path::Struct for #struct_name#ty_generics #where_clause {
+            fn field(&self, name: &str) -> Option<&dyn #bevy_reflect_path::Reflect> {
+                match name {
+                    #(#field_names => Some(&self.#field_idents),)*
+                    _ => None,
+                }
+            }
+
+            fn field_mut(&mut self, name: &str) -> Option<&mut dyn #bevy_reflect_path::Reflect> {
+                match name {
+                    #(#field_names => Some(&mut self.#field_idents),)*
+                    _ => None,
+                }
+            }
+
+            fn field_at(&self, index: usize) -> Option<&dyn #bevy_reflect_path::Reflect> {
+                match index {
+                    #(#field_indices => Some(&self.#field_idents),)*
+                    _ => None,
+                }
+            }
+
+            fn field_at_mut(&mut self, index: usize) -> Option<&mut dyn #bevy_reflect_path::Reflect> {
+                match index {
+                    #(#field_indices => Some(&mut self.#field_idents),)*
+                    _ => None,
+                }
+            }
+
+            fn name_at(&self, index: usize) -> Option<&str> {
+                match index {
+                    #(#field_indices => Some(#field_names),)*
+                    _ => None,
+                }
+            }
+
+            fn field_len(&self) -> usize {
+                #field_count
+            }
+
+            fn iter_fields(&self) -> #bevy_reflect_path::FieldIter {
+                #bevy_reflect_path::FieldIter::new(self)
+            }
+
+            fn clone_dynamic(&self) -> #bevy_reflect_path::DynamicStruct {
+                let mut dynamic = #bevy_reflect_path::DynamicStruct::default();
+                dynamic.set_name(self.type_name().to_string());
+                #(dynamic.insert_boxed(#field_names, self.#field_idents.clone_value());)*
+                dynamic
+            }
+        }
+
+        impl #impl_generics #bevy_reflect_path::Reflect for #struct_name#ty_generics #where_clause {
+            #[inline]
+            fn type_name(&self) -> &str {
+                std::any::type_name::<Self>()
+            }
+
+            #[inline]
+            fn any(&self) -> &dyn std::any::Any {
+                self
+            }
+            #[inline]
+            fn any_mut(&mut self) -> &mut dyn std::any::Any {
+                self
+            }
+            #[inline]
+            fn clone_value(&self) -> Box<dyn #bevy_reflect_path::Reflect> {
+                use #bevy_reflect_path::Struct;
+                Box::new(self.clone_dynamic())
+            }
+            #[inline]
+            fn set(&mut self, value: Box<dyn #bevy_reflect_path::Reflect>) -> Result<(), Box<dyn #bevy_reflect_path::Reflect>> {
+                *self = value.take()?;
+                Ok(())
+            }
+
+            #[inline]
+            fn apply(&mut self, value: &dyn #bevy_reflect_path::Reflect) {
+                use #bevy_reflect_path::Struct;
+                if let #bevy_reflect_path::ReflectRef::Struct(struct_value) = value.reflect_ref() {
+                    for (i, value) in struct_value.iter_fields().enumerate() {
+                        let name = struct_value.name_at(i).unwrap();
+                        self.field_mut(name).map(|v| v.apply(value));
+                    }
+                } else {
+                    panic!("Attempted to apply non-struct type to struct type.");
+                }
+            }
+
+            fn reflect_ref(&self) -> #bevy_reflect_path::ReflectRef {
+                #bevy_reflect_path::ReflectRef::Struct(self)
+            }
+
+            fn reflect_mut(&mut self) -> #bevy_reflect_path::ReflectMut {
+                #bevy_reflect_path::ReflectMut::Struct(self)
+            }
+
+            fn serializable(&self) -> Option<#bevy_reflect_path::serde::Serializable> {
+                #serialize_fn
+            }
+
+            fn reflect_hash(&self) -> Option<u64> {
+                #hash_fn
+            }
+
+            fn reflect_partial_eq(&self, value: &dyn #bevy_reflect_path::Reflect) -> Option<bool> {
+                #partial_eq_fn
+            }
+        }
+    })
+}
+
+fn impl_tuple_struct(
+    struct_name: &Ident,
+    generics: &Generics,
+    get_type_registration_impl: proc_macro2::TokenStream,
+    bevy_reflect_path: &Path,
+    reflect_attrs: &ReflectAttrs,
+    active_fields: &[(&Field, usize)],
+) -> TokenStream {
+    let field_idents = active_fields
+        .iter()
+        .map(|(_field, index)| Member::Unnamed(Index::from(*index)))
+        .collect::<Vec<_>>();
+    let field_count = active_fields.len();
+    let field_indices = (0..field_count).collect::<Vec<usize>>();
+
+    let hash_fn = reflect_attrs.get_hash_impl(&bevy_reflect_path);
+    let serialize_fn = reflect_attrs.get_serialize_impl(&bevy_reflect_path);
+    let partial_eq_fn = match reflect_attrs.reflect_partial_eq {
+        TraitImpl::NotImplemented => quote! {
+            use #bevy_reflect_path::TupleStruct;
+            #bevy_reflect_path::tuple_struct_partial_eq(self, value)
+        },
+        TraitImpl::Implemented | TraitImpl::Custom(_) => reflect_attrs.get_partial_eq_impl(),
+    };
+
+    let (impl_generics, ty_generics, _where_clause) = generics.split_for_impl();
+    TokenStream::from(quote! {
+        #get_type_registration_impl
+
+        impl #impl_generics #bevy_reflect_path::TupleStruct for #struct_name#ty_generics {
+            fn field(&self, index: usize) -> Option<&dyn #bevy_reflect_path::Reflect> {
+                match index {
+                    #(#field_indices => Some(&self.#field_idents),)*
+                    _ => None,
+                }
+            }
+
+            fn field_mut(&mut self, index: usize) -> Option<&mut dyn #bevy_reflect_path::Reflect> {
+                match index {
+                    #(#field_indices => Some(&mut self.#field_idents),)*
+                    _ => None,
+                }
+            }
+
+            fn field_len(&self) -> usize {
+                #field_count
+            }
+
+            fn iter_fields(&self) -> #bevy_reflect_path::TupleStructFieldIter {
+                #bevy_reflect_path::TupleStructFieldIter::new(self)
+            }
+
+            fn clone_dynamic(&self) -> #bevy_reflect_path::DynamicTupleStruct {
+                let mut dynamic = #bevy_reflect_path::DynamicTupleStruct::default();
+                #(dynamic.insert_boxed(self.#field_idents.clone_value());)*
+                dynamic
+            }
+        }
+
+        impl #impl_generics #bevy_reflect_path::Reflect for #struct_name#ty_generics {
+            #[inline]
+            fn type_name(&self) -> &str {
+                std::any::type_name::<Self>()
+            }
+
+            #[inline]
+            fn any(&self) -> &dyn std::any::Any {
+                self
+            }
+            #[inline]
+            fn any_mut(&mut self) -> &mut dyn std::any::Any {
+                self
+            }
+            #[inline]
+            fn clone_value(&self) -> Box<dyn #bevy_reflect_path::Reflect> {
+                use #bevy_reflect_path::TupleStruct;
+                Box::new(self.clone_dynamic())
+            }
+            #[inline]
+            fn set(&mut self, value: Box<dyn #bevy_reflect_path::Reflect>) -> Result<(), Box<dyn #bevy_reflect_path::Reflect>> {
+                *self = value.take()?;
+                Ok(())
+            }
+
+            #[inline]
+            fn apply(&mut self, value: &dyn #bevy_reflect_path::Reflect) {
+                use #bevy_reflect_path::TupleStruct;
+                if let #bevy_reflect_path::ReflectRef::TupleStruct(struct_value) = value.reflect_ref() {
+                    for (i, value) in struct_value.iter_fields().enumerate() {
+                        self.field_mut(i).map(|v| v.apply(value));
+                    }
+                } else {
+                    panic!("Attempted to apply non-TupleStruct type to TupleStruct type.");
+                }
+            }
+
+            fn reflect_ref(&self) -> #bevy_reflect_path::ReflectRef {
+                #bevy_reflect_path::ReflectRef::TupleStruct(self)
+            }
+
+            fn reflect_mut(&mut self) -> #bevy_reflect_path::ReflectMut {
+                #bevy_reflect_path::ReflectMut::TupleStruct(self)
+            }
+
+            fn serializable(&self) -> Option<#bevy_reflect_path::serde::Serializable> {
+                #serialize_fn
+            }
+
+            fn reflect_hash(&self) -> Option<u64> {
+                #hash_fn
+            }
+
+            fn reflect_partial_eq(&self, value: &dyn #bevy_reflect_path::Reflect) -> Option<bool> {
+                #partial_eq_fn
+            }
+        }
+    })
+}
+
+fn impl_value(
+    type_name: &Ident,
+    generics: &Generics,
+    get_type_registration_impl: proc_macro2::TokenStream,
+    bevy_reflect_path: &Path,
+    reflect_attrs: &ReflectAttrs,
+) -> TokenStream {
+    let hash_fn = reflect_attrs.get_hash_impl(&bevy_reflect_path);
+    let partial_eq_fn = reflect_attrs.get_partial_eq_impl();
+    let serialize_fn = reflect_attrs.get_serialize_impl(&bevy_reflect_path);
+
+    let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
+    TokenStream::from(quote! {
+        #get_type_registration_impl
+
+        impl #impl_generics #bevy_reflect_path::Reflect for #type_name#ty_generics #where_clause  {
+            #[inline]
+            fn type_name(&self) -> &str {
+                std::any::type_name::<Self>()
+            }
+
+            #[inline]
+            fn any(&self) -> &dyn std::any::Any {
+                self
+            }
+
+            #[inline]
+            fn any_mut(&mut self) -> &mut dyn std::any::Any {
+                self
+            }
+
+            #[inline]
+            fn clone_value(&self) -> Box<dyn #bevy_reflect_path::Reflect> {
+                Box::new(self.clone())
+            }
+
+            #[inline]
+            fn apply(&mut self, value: &dyn #bevy_reflect_path::Reflect) {
+                let value = value.any();
+                if let Some(value) = value.downcast_ref::<Self>() {
+                    *self = value.clone();
+                } else {
+                    panic!("Value is not {}.", std::any::type_name::<Self>());
+                }
+            }
+
+            #[inline]
+            fn set(&mut self, value: Box<dyn #bevy_reflect_path::Reflect>) -> Result<(), Box<dyn #bevy_reflect_path::Reflect>> {
+                *self = value.take()?;
+                Ok(())
+            }
+
+            fn reflect_ref(&self) -> #bevy_reflect_path::ReflectRef {
+                #bevy_reflect_path::ReflectRef::Value(self)
+            }
+
+            fn reflect_mut(&mut self) -> #bevy_reflect_path::ReflectMut {
+                #bevy_reflect_path::ReflectMut::Value(self)
+            }
+
+            fn reflect_hash(&self) -> Option<u64> {
+                #hash_fn
+            }
+
+            fn reflect_partial_eq(&self, value: &dyn #bevy_reflect_path::Reflect) -> Option<bool> {
+                #partial_eq_fn
+            }
+
+            fn serializable(&self) -> Option<#bevy_reflect_path::serde::Serializable> {
+                #serialize_fn
+            }
+        }
+    })
+}
+struct ReflectDef {
+    type_name: Ident,
+    generics: Generics,
+    attrs: Option<ReflectAttrs>,
+}
+
+impl Parse for ReflectDef {
+    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+        let type_ident = input.parse::<Ident>()?;
+        let generics = input.parse::<Generics>()?;
+        let mut lookahead = input.lookahead1();
+        let mut where_clause = None;
+        if lookahead.peek(Where) {
+            where_clause = Some(input.parse()?);
+            lookahead = input.lookahead1();
+        }
+
+        let mut attrs = None;
+        if lookahead.peek(Paren) {
+            let content;
+            parenthesized!(content in input);
+            attrs = Some(content.parse::<ReflectAttrs>()?);
+        }
+
+        Ok(ReflectDef {
+            type_name: type_ident,
+            generics: Generics {
+                where_clause,
+                ..generics
+            },
+            attrs,
+        })
+    }
+}
+
+#[proc_macro]
+pub fn impl_reflect_value(input: TokenStream) -> TokenStream {
+    let reflect_value_def = parse_macro_input!(input as ReflectDef);
+
+    let manifest = Manifest::new().unwrap();
+    let crate_path = if let Some(package) = manifest.find(|name| name == "bevy") {
+        format!("{}::reflect", package.name)
+    } else if let Some(package) = manifest.find(|name| name == "bevy_reflect") {
+        package.name
+    } else {
+        "crate".to_string()
+    };
+    let bevy_reflect_path = get_path(&crate_path);
+    let ty = &reflect_value_def.type_name;
+    let reflect_attrs = reflect_value_def
+        .attrs
+        .unwrap_or_else(ReflectAttrs::default);
+    let registration_data = &reflect_attrs.data;
+    let get_type_registration_impl = impl_get_type_registration(
+        ty,
+        &bevy_reflect_path,
+        registration_data,
+        &reflect_value_def.generics,
+    );
+    impl_value(
+        ty,
+        &reflect_value_def.generics,
+        get_type_registration_impl,
+        &bevy_reflect_path,
+        &reflect_attrs,
+    )
+}
+
+#[derive(Default)]
+struct ReflectAttrs {
+    reflect_hash: TraitImpl,
+    reflect_partial_eq: TraitImpl,
+    serialize: TraitImpl,
+    data: Vec<Ident>,
+}
+
+impl ReflectAttrs {
+    fn from_nested_metas(nested_metas: &Punctuated<NestedMeta, Comma>) -> Self {
+        let mut attrs = ReflectAttrs::default();
+        for nested_meta in nested_metas.iter() {
+            match nested_meta {
+                NestedMeta::Lit(_) => {}
+                NestedMeta::Meta(meta) => match meta {
+                    Meta::Path(path) => {
+                        if let Some(segment) = path.segments.iter().next() {
+                            let ident = segment.ident.to_string();
+                            match ident.as_str() {
+                                "PartialEq" => attrs.reflect_partial_eq = TraitImpl::Implemented,
+                                "Hash" => attrs.reflect_hash = TraitImpl::Implemented,
+                                "Serialize" => attrs.serialize = TraitImpl::Implemented,
+                                _ => attrs.data.push(Ident::new(
+                                    &format!("Reflect{}", segment.ident),
+                                    Span::call_site(),
+                                )),
+                            }
+                        }
+                    }
+                    Meta::List(list) => {
+                        let ident = if let Some(segment) = list.path.segments.iter().next() {
+                            segment.ident.to_string()
+                        } else {
+                            continue;
+                        };
+
+                        if let Some(list_nested) = list.nested.iter().next() {
+                            match list_nested {
+                                NestedMeta::Meta(list_nested_meta) => match list_nested_meta {
+                                    Meta::Path(path) => {
+                                        if let Some(segment) = path.segments.iter().next() {
+                                            match ident.as_str() {
+                                                "PartialEq" => {
+                                                    attrs.reflect_partial_eq =
+                                                        TraitImpl::Custom(segment.ident.clone())
+                                                }
+                                                "Hash" => {
+                                                    attrs.reflect_hash =
+                                                        TraitImpl::Custom(segment.ident.clone())
+                                                }
+                                                "Serialize" => {
+                                                    attrs.serialize =
+                                                        TraitImpl::Custom(segment.ident.clone())
+                                                }
+                                                _ => {}
+                                            }
+                                        }
+                                    }
+                                    Meta::List(_) => {}
+                                    Meta::NameValue(_) => {}
+                                },
+                                NestedMeta::Lit(_) => {}
+                            }
+                        }
+                    }
+                    Meta::NameValue(_) => {}
+                },
+            }
+        }
+
+        attrs
+    }
+
+    fn get_hash_impl(&self, path: &Path) -> proc_macro2::TokenStream {
+        match &self.reflect_hash {
+            TraitImpl::Implemented => quote! {
+                use std::hash::{Hash, Hasher};
+                let mut hasher = #path::ReflectHasher::default();
+                Hash::hash(&std::any::Any::type_id(self), &mut hasher);
+                Hash::hash(self, &mut hasher);
+                Some(hasher.finish())
+            },
+            TraitImpl::Custom(impl_fn) => quote! {
+                Some(#impl_fn(self))
+            },
+            TraitImpl::NotImplemented => quote! {
+                None
+            },
+        }
+    }
+
+    fn get_partial_eq_impl(&self) -> proc_macro2::TokenStream {
+        match &self.reflect_partial_eq {
+            TraitImpl::Implemented => quote! {
+                let value = value.any();
+                if let Some(value) = value.downcast_ref::<Self>() {
+                    Some(std::cmp::PartialEq::eq(self, value))
+                } else {
+                    Some(false)
+                }
+            },
+            TraitImpl::Custom(impl_fn) => quote! {
+                Some(#impl_fn(self, value))
+            },
+            TraitImpl::NotImplemented => quote! {
+                None
+            },
+        }
+    }
+
+    fn get_serialize_impl(&self, path: &Path) -> proc_macro2::TokenStream {
+        match &self.serialize {
+            TraitImpl::Implemented => quote! {
+                Some(#path::serde::Serializable::Borrowed(self))
+            },
+            TraitImpl::Custom(impl_fn) => quote! {
+                Some(#impl_fn(self))
+            },
+            TraitImpl::NotImplemented => quote! {
+                None
+            },
+        }
+    }
+}
+
+impl Parse for ReflectAttrs {
+    fn parse(input: ParseStream) -> syn::Result<Self> {
+        let result = Punctuated::<NestedMeta, Comma>::parse_terminated(input)?;
+        Ok(ReflectAttrs::from_nested_metas(&result))
+    }
+}
+
+fn impl_get_type_registration(
+    type_name: &Ident,
+    bevy_reflect_path: &Path,
+    registration_data: &[Ident],
+    generics: &Generics,
+) -> proc_macro2::TokenStream {
+    let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
+    quote! {
+        #[allow(unused_mut)]
+        impl #impl_generics #bevy_reflect_path::GetTypeRegistration for #type_name#ty_generics #where_clause {
+            fn get_type_registration() -> #bevy_reflect_path::TypeRegistration {
+                let mut registration = #bevy_reflect_path::TypeRegistration::of::<#type_name#ty_generics>();
+                #(registration.insert::<#registration_data>(#bevy_reflect_path::FromType::<#type_name#ty_generics>::from_type());)*
+                registration
+            }
+        }
+    }
+}
+
+// From https://github.com/randomPoison/type-uuid
+#[proc_macro_derive(TypeUuid, attributes(uuid))]
+pub fn type_uuid_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    type_uuid::type_uuid_derive(input)
+}
+
+#[proc_macro]
+pub fn external_type_uuid(tokens: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    type_uuid::external_type_uuid(tokens)
+}
+
+#[proc_macro_attribute]
+pub fn reflect_trait(args: TokenStream, input: TokenStream) -> TokenStream {
+    reflect_trait::reflect_trait(args, input)
+}
diff --git a/crates/bevy_property/bevy_property_derive/src/modules.rs b/crates/bevy_reflect/bevy_reflect_derive/src/modules.rs
similarity index 57%
rename from crates/bevy_property/bevy_property_derive/src/modules.rs
rename to crates/bevy_reflect/bevy_reflect_derive/src/modules.rs
index a549f9b90a2b9..e0a5109124c2a 100644
--- a/crates/bevy_property/bevy_property_derive/src/modules.rs
+++ b/crates/bevy_reflect/bevy_reflect_derive/src/modules.rs
@@ -4,38 +4,42 @@ use syn::Path;
 
 #[derive(Debug)]
 pub struct Modules {
-    pub bevy_property: String,
+    pub bevy_reflect: String,
 }
 
 impl Modules {
     pub fn meta(name: &str) -> Modules {
         Modules {
-            bevy_property: format!("{}::property", name),
+            bevy_reflect: format!("{}::reflect", name),
         }
     }
 
     pub fn external() -> Modules {
         Modules {
-            bevy_property: "bevy_property".to_string(),
+            bevy_reflect: "bevy_reflect".to_string(),
+        }
+    }
+
+    pub fn internal() -> Modules {
+        Modules {
+            bevy_reflect: "crate".to_string(),
         }
     }
 }
 
-fn get_meta() -> Option<Modules> {
+pub fn get_modules() -> Modules {
     let manifest = Manifest::new().unwrap();
     if let Some(package) = manifest.find(|name| name == "bevy") {
-        Some(Modules::meta(&package.name))
+        Modules::meta(&package.name)
     } else if let Some(package) = manifest.find(|name| name == "bevy_internal") {
-        Some(Modules::meta(&package.name))
+        Modules::meta(&package.name)
+    } else if let Some(_package) = manifest.find(|name| name == "bevy_reflect") {
+        Modules::external()
     } else {
-        None
+        Modules::internal()
     }
 }
 
-pub fn get_modules() -> Modules {
-    get_meta().unwrap_or_else(Modules::external)
-}
-
 pub fn get_path(path_str: &str) -> Path {
     syn::parse(path_str.parse::<TokenStream>().unwrap()).unwrap()
 }
diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/reflect_trait.rs b/crates/bevy_reflect/bevy_reflect_derive/src/reflect_trait.rs
new file mode 100644
index 0000000000000..d4378d664d874
--- /dev/null
+++ b/crates/bevy_reflect/bevy_reflect_derive/src/reflect_trait.rs
@@ -0,0 +1,66 @@
+use proc_macro::TokenStream;
+use proc_macro2::Span;
+use quote::quote;
+use syn::{parse::Parse, parse_macro_input, Attribute, Ident, ItemTrait, Token};
+
+use crate::modules::{get_modules, get_path};
+
+pub struct TraitInfo {
+    item_trait: ItemTrait,
+}
+
+impl Parse for TraitInfo {
+    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+        let attrs = input.call(Attribute::parse_outer)?;
+        let lookahead = input.lookahead1();
+        if lookahead.peek(Token![pub]) || lookahead.peek(Token![trait]) {
+            let mut item_trait: ItemTrait = input.parse()?;
+            item_trait.attrs = attrs;
+            Ok(TraitInfo { item_trait })
+        } else {
+            Err(lookahead.error())
+        }
+    }
+}
+
+pub fn reflect_trait(_args: TokenStream, input: TokenStream) -> TokenStream {
+    let trait_info = parse_macro_input!(input as TraitInfo);
+    let item_trait = &trait_info.item_trait;
+    let trait_ident = &item_trait.ident;
+    let reflect_trait_ident =
+        Ident::new(&format!("Reflect{}", item_trait.ident), Span::call_site());
+    let modules = get_modules();
+    let bevy_reflect_path = get_path(&modules.bevy_reflect);
+    TokenStream::from(quote! {
+        #item_trait
+
+        #[derive(Clone)]
+        pub struct #reflect_trait_ident {
+            get_func: fn(&dyn #bevy_reflect_path::Reflect) -> Option<&dyn #trait_ident>,
+            get_mut_func: fn(&mut dyn #bevy_reflect_path::Reflect) -> Option<&mut dyn #trait_ident>,
+        }
+
+        impl #reflect_trait_ident {
+            fn get<'a>(&self, reflect_value: &'a dyn #bevy_reflect_path::Reflect) -> Option<&'a dyn #trait_ident> {
+                (self.get_func)(reflect_value)
+            }
+
+            fn get_mut<'a>(&self, reflect_value: &'a mut dyn #bevy_reflect_path::Reflect) -> Option<&'a mut dyn #trait_ident> {
+                (self.get_mut_func)(reflect_value)
+            }
+        }
+
+        impl<T: #trait_ident + #bevy_reflect_path::Reflect> #bevy_reflect_path::FromType<T> for #reflect_trait_ident {
+            fn from_type() -> Self {
+                Self {
+                    get_func: |reflect_value| {
+                        reflect_value.downcast_ref::<T>().map(|value| value as &dyn #trait_ident)
+                    },
+                    get_mut_func: |reflect_value| {
+                        reflect_value.downcast_mut::<T>().map(|value| value as &mut dyn #trait_ident)
+                    }
+                }
+            }
+        }
+    })
+}
diff --git a/crates/bevy_derive/src/type_uuid.rs b/crates/bevy_reflect/bevy_reflect_derive/src/type_uuid.rs
similarity index 83%
rename from crates/bevy_derive/src/type_uuid.rs
rename to crates/bevy_reflect/bevy_reflect_derive/src/type_uuid.rs
index 9078ff3be1353..800de584f7107 100644
--- a/crates/bevy_derive/src/type_uuid.rs
+++ b/crates/bevy_reflect/bevy_reflect_derive/src/type_uuid.rs
@@ -10,8 +10,8 @@ pub fn type_uuid_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStre
     // Construct a representation of Rust code as a syntax tree
     // that we can manipulate
     let ast: DeriveInput = syn::parse(input).unwrap();
-    let modules = get_modules(&ast.attrs);
-    let bevy_type_registry_path: Path = get_path(&modules.bevy_type_registry);
+    let modules = get_modules();
+    let bevy_reflect_path: Path = get_path(&modules.bevy_reflect);
 
     // Build the trait implementation
     let name = &ast.ident;
@@ -35,17 +35,17 @@ pub fn type_uuid_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStre
 
         let uuid_str = match name_value.lit {
             Lit::Str(lit_str) => lit_str,
-            _ => panic!("uuid attribute must take the form `#[uuid = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"`"),
+            _ => panic!("`uuid` attribute must take the form `#[uuid = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"`."),
         };
 
         uuid = Some(
             Uuid::parse_str(&uuid_str.value())
-                .expect("Value specified to `#[uuid]` attribute is not a valid UUID"),
+                .expect("Value specified to `#[uuid]` attribute is not a valid UUID."),
         );
     }
 
     let uuid =
-        uuid.expect("No `#[uuid = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"` attribute found");
+        uuid.expect("No `#[uuid = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"` attribute found.");
     let bytes = uuid
         .as_bytes()
         .iter()
@@ -53,8 +53,8 @@ pub fn type_uuid_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStre
         .map(|byte_str| syn::parse_str::<LitInt>(&byte_str).unwrap());
 
     let gen = quote! {
-        impl #bevy_type_registry_path::TypeUuid for #name {
-            const TYPE_UUID: #bevy_type_registry_path::Uuid = #bevy_type_registry_path::Uuid::from_bytes([
+        impl #bevy_reflect_path::TypeUuid for #name {
+            const TYPE_UUID: #bevy_reflect_path::Uuid = #bevy_reflect_path::Uuid::from_bytes([
                 #( #bytes ),*
             ]);
         }
@@ -79,7 +79,7 @@ impl Parse for ExternalDeriveInput {
 pub fn external_type_uuid(tokens: proc_macro::TokenStream) -> proc_macro::TokenStream {
     let ExternalDeriveInput { path, uuid_str } = parse_macro_input!(tokens as ExternalDeriveInput);
 
-    let uuid = Uuid::parse_str(&uuid_str.value()).expect("Value was not a valid UUID");
+    let uuid = Uuid::parse_str(&uuid_str.value()).expect("Value was not a valid UUID.");
 
     let bytes = uuid
         .as_bytes()
diff --git a/crates/bevy_reflect/src/impls/bevy_app.rs b/crates/bevy_reflect/src/impls/bevy_app.rs
new file mode 100644
index 0000000000000..8c142783a0ecf
--- /dev/null
+++ b/crates/bevy_reflect/src/impls/bevy_app.rs
@@ -0,0 +1,57 @@
+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::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
new file mode 100644
index 0000000000000..4be4a77bacb62
--- /dev/null
+++ b/crates/bevy_reflect/src/impls/bevy_ecs.rs
@@ -0,0 +1,219 @@
+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,
+    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)
+    }
+
+    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()
+                }
+            },
+        }
+    }
+}
+
+#[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.into_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.into_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(())
+            },
+        }
+    }
+}
+
+pub trait IntoComponent<ToComponent: Component> {
+    fn into_component(&self, resources: &Resources) -> ToComponent;
+}
diff --git a/crates/bevy_reflect/src/impls/glam.rs b/crates/bevy_reflect/src/impls/glam.rs
new file mode 100644
index 0000000000000..f7fd83fe70808
--- /dev/null
+++ b/crates/bevy_reflect/src/impls/glam.rs
@@ -0,0 +1,10 @@
+use crate::ReflectDeserialize;
+use bevy_reflect_derive::impl_reflect_value;
+use glam::{Mat3, Mat4, Quat, Vec2, Vec3, Vec4};
+
+impl_reflect_value!(Vec2(PartialEq, Serialize, Deserialize));
+impl_reflect_value!(Vec3(PartialEq, Serialize, Deserialize));
+impl_reflect_value!(Vec4(PartialEq, Serialize, Deserialize));
+impl_reflect_value!(Mat3(PartialEq, Serialize, Deserialize));
+impl_reflect_value!(Mat4(PartialEq, Serialize, Deserialize));
+impl_reflect_value!(Quat(PartialEq, Serialize, Deserialize));
diff --git a/crates/bevy_reflect/src/impls/smallvec.rs b/crates/bevy_reflect/src/impls/smallvec.rs
new file mode 100644
index 0000000000000..589bd4c0b1327
--- /dev/null
+++ b/crates/bevy_reflect/src/impls/smallvec.rs
@@ -0,0 +1,96 @@
+use smallvec::{Array, SmallVec};
+use std::any::Any;
+
+use crate::{serde::Serializable, List, ListIter, Reflect, ReflectMut, ReflectRef};
+
+impl<T: Array + Send + Sync + 'static> List for SmallVec<T>
+where
+    T::Item: Reflect + Clone,
+{
+    fn get(&self, index: usize) -> Option<&dyn Reflect> {
+        if index < SmallVec::len(self) {
+            Some(&self[index] as &dyn Reflect)
+        } else {
+            None
+        }
+    }
+
+    fn get_mut(&mut self, index: usize) -> Option<&mut dyn Reflect> {
+        if index < SmallVec::len(self) {
+            Some(&mut self[index] as &mut dyn Reflect)
+        } else {
+            None
+        }
+    }
+
+    fn len(&self) -> usize {
+        <SmallVec<T>>::len(self)
+    }
+
+    fn push(&mut self, value: Box<dyn Reflect>) {
+        let value = value.take::<T::Item>().unwrap_or_else(|value| {
+            panic!(
+                "Attempted to push invalid value of type {}.",
+                value.type_name()
+            )
+        });
+        SmallVec::push(self, value);
+    }
+
+    fn iter(&self) -> ListIter {
+        ListIter {
+            list: self,
+            index: 0,
+        }
+    }
+}
+
+impl<T: Array + Send + Sync + 'static> Reflect for SmallVec<T>
+where
+    T::Item: Reflect + Clone,
+{
+    fn type_name(&self) -> &str {
+        std::any::type_name::<Self>()
+    }
+
+    fn any(&self) -> &dyn Any {
+        self
+    }
+
+    fn any_mut(&mut self) -> &mut dyn Any {
+        self
+    }
+
+    fn apply(&mut self, value: &dyn Reflect) {
+        crate::list_apply(self, value);
+    }
+
+    fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>> {
+        *self = value.take()?;
+        Ok(())
+    }
+
+    fn reflect_ref(&self) -> ReflectRef {
+        ReflectRef::List(self)
+    }
+
+    fn reflect_mut(&mut self) -> ReflectMut {
+        ReflectMut::List(self)
+    }
+
+    fn clone_value(&self) -> Box<dyn Reflect> {
+        Box::new(self.clone_dynamic())
+    }
+
+    fn reflect_hash(&self) -> Option<u64> {
+        None
+    }
+
+    fn reflect_partial_eq(&self, value: &dyn Reflect) -> Option<bool> {
+        crate::list_partial_eq(self, value)
+    }
+
+    fn serializable(&self) -> Option<Serializable> {
+        None
+    }
+}
diff --git a/crates/bevy_reflect/src/impls/std.rs b/crates/bevy_reflect/src/impls/std.rs
new file mode 100644
index 0000000000000..0af5cead11d11
--- /dev/null
+++ b/crates/bevy_reflect/src/impls/std.rs
@@ -0,0 +1,201 @@
+use crate::{
+    map_partial_eq, serde::Serializable, DynamicMap, List, ListIter, Map, MapIter, Reflect,
+    ReflectDeserialize, ReflectMut, ReflectRef,
+};
+
+use bevy_reflect_derive::impl_reflect_value;
+use bevy_utils::{HashMap, HashSet};
+use serde::{Deserialize, Serialize};
+use std::{any::Any, hash::Hash, ops::Range};
+
+impl_reflect_value!(bool(Hash, PartialEq, Serialize, Deserialize));
+impl_reflect_value!(u8(Hash, PartialEq, Serialize, Deserialize));
+impl_reflect_value!(u16(Hash, PartialEq, Serialize, Deserialize));
+impl_reflect_value!(u32(Hash, PartialEq, Serialize, Deserialize));
+impl_reflect_value!(u64(Hash, PartialEq, Serialize, Deserialize));
+impl_reflect_value!(u128(Hash, PartialEq, Serialize, Deserialize));
+impl_reflect_value!(usize(Hash, PartialEq, Serialize, Deserialize));
+impl_reflect_value!(i8(Hash, PartialEq, Serialize, Deserialize));
+impl_reflect_value!(i16(Hash, PartialEq, Serialize, Deserialize));
+impl_reflect_value!(i32(Hash, PartialEq, Serialize, Deserialize));
+impl_reflect_value!(i64(Hash, PartialEq, Serialize, Deserialize));
+impl_reflect_value!(i128(Hash, PartialEq, Serialize, Deserialize));
+impl_reflect_value!(isize(Hash, PartialEq, Serialize, Deserialize));
+impl_reflect_value!(f32(Serialize, Deserialize));
+impl_reflect_value!(f64(Serialize, Deserialize));
+impl_reflect_value!(String(Hash, PartialEq, Serialize, Deserialize));
+impl_reflect_value!(Option<T: Serialize + Clone + for<'de> Deserialize<'de> + Reflect + 'static>(Serialize, Deserialize));
+impl_reflect_value!(HashSet<T: Serialize + Hash + Eq + Clone + for<'de> Deserialize<'de> + Send + Sync + 'static>(Serialize, Deserialize));
+impl_reflect_value!(Range<T: Serialize + Clone + for<'de> Deserialize<'de> + Send + Sync + 'static>(Serialize, Deserialize));
+
+impl<T: Reflect> List for Vec<T> {
+    fn get(&self, index: usize) -> Option<&dyn Reflect> {
+        <[T]>::get(self, index).map(|value| value as &dyn Reflect)
+    }
+
+    fn get_mut(&mut self, index: usize) -> Option<&mut dyn Reflect> {
+        <[T]>::get_mut(self, index).map(|value| value as &mut dyn Reflect)
+    }
+
+    fn len(&self) -> usize {
+        <[T]>::len(self)
+    }
+
+    fn iter(&self) -> ListIter {
+        ListIter {
+            list: self,
+            index: 0,
+        }
+    }
+
+    fn push(&mut self, value: Box<dyn Reflect>) {
+        let value = value.take::<T>().unwrap_or_else(|value| {
+            panic!(
+                "Attempted to push invalid value of type {}.",
+                value.type_name()
+            )
+        });
+        Vec::push(self, value);
+    }
+}
+
+impl<T: Reflect> Reflect for Vec<T> {
+    fn type_name(&self) -> &str {
+        std::any::type_name::<Self>()
+    }
+
+    fn any(&self) -> &dyn Any {
+        self
+    }
+
+    fn any_mut(&mut self) -> &mut dyn Any {
+        self
+    }
+
+    fn apply(&mut self, value: &dyn Reflect) {
+        crate::list_apply(self, value);
+    }
+
+    fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>> {
+        *self = value.take()?;
+        Ok(())
+    }
+
+    fn reflect_ref(&self) -> ReflectRef {
+        ReflectRef::List(self)
+    }
+
+    fn reflect_mut(&mut self) -> ReflectMut {
+        ReflectMut::List(self)
+    }
+
+    fn clone_value(&self) -> Box<dyn Reflect> {
+        Box::new(self.clone_dynamic())
+    }
+
+    fn reflect_hash(&self) -> Option<u64> {
+        None
+    }
+
+    fn reflect_partial_eq(&self, value: &dyn Reflect) -> Option<bool> {
+        crate::list_partial_eq(self, value)
+    }
+
+    fn serializable(&self) -> Option<Serializable> {
+        None
+    }
+}
+
+impl<K: Reflect + Clone + Eq + Hash, V: Reflect + Clone> Map for HashMap<K, V> {
+    fn get(&self, key: &dyn Reflect) -> Option<&dyn Reflect> {
+        key.downcast_ref::<K>()
+            .and_then(|key| HashMap::get(self, key))
+            .map(|value| value as &dyn Reflect)
+    }
+
+    fn get_mut(&mut self, key: &dyn Reflect) -> Option<&mut dyn Reflect> {
+        key.downcast_ref::<K>()
+            .and_then(move |key| HashMap::get_mut(self, key))
+            .map(|value| value as &mut dyn Reflect)
+    }
+
+    fn get_at(&self, index: usize) -> Option<(&dyn Reflect, &dyn Reflect)> {
+        self.iter()
+            .nth(index)
+            .map(|(key, value)| (key as &dyn Reflect, value as &dyn Reflect))
+    }
+
+    fn len(&self) -> usize {
+        HashMap::len(self)
+    }
+
+    fn iter(&self) -> MapIter {
+        MapIter {
+            map: self,
+            index: 0,
+        }
+    }
+
+    fn clone_dynamic(&self) -> DynamicMap {
+        let mut dynamic_map = DynamicMap::default();
+        for (k, v) in HashMap::iter(self) {
+            dynamic_map.insert_boxed(k.clone_value(), v.clone_value());
+        }
+        dynamic_map
+    }
+}
+
+impl<K: Reflect + Clone + Eq + Hash, V: Reflect + Clone> Reflect for HashMap<K, V> {
+    fn type_name(&self) -> &str {
+        std::any::type_name::<Self>()
+    }
+
+    fn any(&self) -> &dyn Any {
+        self
+    }
+
+    fn any_mut(&mut self) -> &mut dyn Any {
+        self
+    }
+
+    fn apply(&mut self, value: &dyn Reflect) {
+        if let ReflectRef::Map(map_value) = value.reflect_ref() {
+            for (key, value) in map_value.iter() {
+                if let Some(v) = Map::get_mut(self, key) {
+                    v.apply(value)
+                }
+            }
+        } else {
+            panic!("Attempted to apply a non-map type to a map type.");
+        }
+    }
+
+    fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>> {
+        *self = value.take()?;
+        Ok(())
+    }
+
+    fn reflect_ref(&self) -> ReflectRef {
+        ReflectRef::Map(self)
+    }
+
+    fn reflect_mut(&mut self) -> ReflectMut {
+        ReflectMut::Map(self)
+    }
+
+    fn clone_value(&self) -> Box<dyn Reflect> {
+        Box::new(self.clone_dynamic())
+    }
+
+    fn reflect_hash(&self) -> Option<u64> {
+        None
+    }
+
+    fn reflect_partial_eq(&self, value: &dyn Reflect) -> Option<bool> {
+        map_partial_eq(self, value)
+    }
+
+    fn serializable(&self) -> Option<Serializable> {
+        None
+    }
+}
diff --git a/crates/bevy_reflect/src/lib.rs b/crates/bevy_reflect/src/lib.rs
new file mode 100644
index 0000000000000..8b5bdeb67d42a
--- /dev/null
+++ b/crates/bevy_reflect/src/lib.rs
@@ -0,0 +1,323 @@
+mod list;
+mod map;
+mod path;
+mod reflect;
+mod struct_trait;
+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")]
+    pub use self::smallvec::*;
+    pub use self::std::*;
+}
+
+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,
+    };
+}
+
+pub use impls::*;
+pub use list::*;
+pub use map::*;
+pub use path::*;
+pub use reflect::*;
+pub use struct_trait::*;
+pub use tuple_struct::*;
+pub use type_registry::*;
+pub use type_uuid::*;
+
+pub use bevy_reflect_derive::*;
+pub use erased_serde;
+
+#[cfg(test)]
+mod tests {
+    use ::serde::de::DeserializeSeed;
+    use bevy_utils::HashMap;
+    use ron::{
+        ser::{to_string_pretty, PrettyConfig},
+        Deserializer,
+    };
+
+    use crate::serde::{ReflectDeserializer, ReflectSerializer};
+
+    use super::*;
+    #[test]
+    fn reflect_struct() {
+        #[derive(Reflect)]
+        struct Foo {
+            a: u32,
+            b: f32,
+            c: Bar,
+        }
+        #[derive(Reflect)]
+        struct Bar {
+            x: u32,
+        }
+
+        let mut foo = Foo {
+            a: 42,
+            b: 3.14,
+            c: Bar { x: 1 },
+        };
+
+        let a = *foo.get_field::<u32>("a").unwrap();
+        assert_eq!(a, 42);
+
+        *foo.get_field_mut::<u32>("a").unwrap() += 1;
+        assert_eq!(foo.a, 43);
+
+        let bar = foo.get_field::<Bar>("c").unwrap();
+        assert_eq!(bar.x, 1);
+
+        // nested retrieval
+        let c = foo.field("c").unwrap();
+        if let ReflectRef::Struct(value) = c.reflect_ref() {
+            assert_eq!(*value.get_field::<u32>("x").unwrap(), 1);
+        } else {
+            panic!("Expected a struct.");
+        }
+
+        // patch Foo with a dynamic struct
+        let mut dynamic_struct = DynamicStruct::default();
+        dynamic_struct.insert("a", 123u32);
+        dynamic_struct.insert("should_be_ignored", 456);
+
+        foo.apply(&dynamic_struct);
+        assert_eq!(foo.a, 123);
+    }
+
+    #[test]
+    fn reflect_map() {
+        #[derive(Reflect, Hash)]
+        #[reflect(Hash)]
+        struct Foo {
+            a: u32,
+            b: String,
+        }
+
+        let key_a = Foo {
+            a: 1,
+            b: "k1".to_string(),
+        };
+
+        let key_b = Foo {
+            a: 1,
+            b: "k1".to_string(),
+        };
+
+        let key_c = Foo {
+            a: 3,
+            b: "k3".to_string(),
+        };
+
+        let mut map = DynamicMap::default();
+        map.insert(key_a, 10u32);
+        assert_eq!(10, *map.get(&key_b).unwrap().downcast_ref::<u32>().unwrap());
+        assert!(map.get(&key_c).is_none());
+        *map.get_mut(&key_b).unwrap().downcast_mut::<u32>().unwrap() = 20;
+        assert_eq!(20, *map.get(&key_b).unwrap().downcast_ref::<u32>().unwrap());
+    }
+
+    #[test]
+    fn reflect_unit_struct() {
+        #[derive(Reflect)]
+        struct Foo(u32, u64);
+
+        let mut foo = Foo(1, 2);
+        assert_eq!(1, *foo.get_field::<u32>(0).unwrap());
+        assert_eq!(2, *foo.get_field::<u64>(1).unwrap());
+
+        let mut patch = DynamicTupleStruct::default();
+        patch.insert(3u32);
+        patch.insert(4u64);
+        assert_eq!(3, *patch.field(0).unwrap().downcast_ref::<u32>().unwrap());
+        assert_eq!(4, *patch.field(1).unwrap().downcast_ref::<u64>().unwrap());
+
+        foo.apply(&patch);
+        assert_eq!(3, foo.0);
+        assert_eq!(4, foo.1);
+
+        let mut iter = patch.iter_fields();
+        assert_eq!(3, *iter.next().unwrap().downcast_ref::<u32>().unwrap());
+        assert_eq!(4, *iter.next().unwrap().downcast_ref::<u64>().unwrap());
+    }
+
+    #[test]
+    #[should_panic(expected = "the given key does not support hashing")]
+    fn reflect_map_no_hash() {
+        #[derive(Reflect)]
+        struct Foo {
+            a: u32,
+        }
+
+        let foo = Foo { a: 1 };
+
+        let mut map = DynamicMap::default();
+        map.insert(foo, 10u32);
+    }
+
+    #[test]
+    fn reflect_ignore() {
+        #[derive(Reflect)]
+        struct Foo {
+            a: u32,
+            #[reflect(ignore)]
+            _b: u32,
+        }
+
+        let foo = Foo { a: 1, _b: 2 };
+
+        let values: Vec<u32> = foo
+            .iter_fields()
+            .map(|value| *value.downcast_ref::<u32>().unwrap())
+            .collect();
+        assert_eq!(values, vec![1]);
+    }
+
+    #[test]
+    fn reflect_complex_patch() {
+        #[derive(Reflect, Eq, PartialEq, Debug)]
+        struct Foo {
+            a: u32,
+            #[reflect(ignore)]
+            _b: u32,
+            c: Vec<isize>,
+            d: HashMap<usize, i8>,
+            e: Bar,
+        }
+
+        #[derive(Reflect, Eq, PartialEq, Debug)]
+        struct Bar {
+            x: u32,
+        }
+
+        let mut hash_map = HashMap::default();
+        hash_map.insert(1, 1);
+        hash_map.insert(2, 2);
+        let mut foo = Foo {
+            a: 1,
+            _b: 1,
+            c: vec![1, 2],
+            d: hash_map,
+            e: Bar { x: 1 },
+        };
+
+        let mut foo_patch = DynamicStruct::default();
+        foo_patch.insert("a", 2u32);
+        foo_patch.insert("b", 2u32); // this should be ignored
+
+        let mut list = DynamicList::default();
+        list.push(3isize);
+        list.push(4isize);
+        list.push(5isize);
+        foo_patch.insert("c", list);
+
+        let mut map = DynamicMap::default();
+        map.insert(2usize, 3i8);
+        foo_patch.insert("d", map);
+
+        let mut bar_patch = DynamicStruct::default();
+        bar_patch.insert("x", 2u32);
+        foo_patch.insert("e", bar_patch);
+
+        foo.apply(&foo_patch);
+
+        let mut hash_map = HashMap::default();
+        hash_map.insert(1, 1);
+        hash_map.insert(2, 3);
+        let expected_foo = Foo {
+            a: 2,
+            _b: 1,
+            c: vec![3, 4, 5],
+            d: hash_map,
+            e: Bar { x: 2 },
+        };
+
+        assert_eq!(foo, expected_foo);
+    }
+
+    #[test]
+    fn reflect_serialize() {
+        #[derive(Reflect)]
+        struct Foo {
+            a: u32,
+            #[reflect(ignore)]
+            _b: u32,
+            c: Vec<isize>,
+            d: HashMap<usize, i8>,
+            e: Bar,
+            f: String,
+        }
+
+        #[derive(Reflect)]
+        struct Bar {
+            x: u32,
+        }
+
+        let mut hash_map = HashMap::default();
+        hash_map.insert(1, 1);
+        hash_map.insert(2, 2);
+        let foo = Foo {
+            a: 1,
+            _b: 1,
+            c: vec![1, 2],
+            d: hash_map,
+            e: Bar { x: 1 },
+            f: "hi".to_string(),
+        };
+
+        let mut registry = TypeRegistry::default();
+        registry.register::<u32>();
+        registry.register::<isize>();
+        registry.register::<usize>();
+        registry.register::<Bar>();
+        registry.register::<String>();
+        registry.register::<i8>();
+
+        let serializer = ReflectSerializer::new(&foo, &registry);
+        let serialized = to_string_pretty(&serializer, PrettyConfig::default()).unwrap();
+
+        let mut deserializer = Deserializer::from_str(&serialized).unwrap();
+        let reflect_deserializer = ReflectDeserializer::new(&registry);
+        let value = reflect_deserializer.deserialize(&mut deserializer).unwrap();
+        let dynamic_struct = value.take::<DynamicStruct>().unwrap();
+
+        assert!(foo.reflect_partial_eq(&dynamic_struct).unwrap());
+    }
+
+    #[test]
+    fn reflect_take() {
+        #[derive(Reflect, Debug, PartialEq)]
+        struct Bar {
+            x: u32,
+        }
+
+        let x: Box<dyn Reflect> = Box::new(Bar { x: 2 });
+        let y = x.take::<Bar>().unwrap();
+        assert_eq!(y, Bar { x: 2 });
+    }
+}
diff --git a/crates/bevy_reflect/src/list.rs b/crates/bevy_reflect/src/list.rs
new file mode 100644
index 0000000000000..4506bb3ba0be8
--- /dev/null
+++ b/crates/bevy_reflect/src/list.rs
@@ -0,0 +1,178 @@
+use std::any::Any;
+
+use crate::{serde::Serializable, Reflect, ReflectMut, ReflectRef};
+
+/// An ordered, mutable list of [ReflectValue] items. This corresponds to types like [std::vec::Vec].
+pub trait List: Reflect {
+    fn get(&self, index: usize) -> Option<&dyn Reflect>;
+    fn get_mut(&mut self, index: usize) -> Option<&mut dyn Reflect>;
+    fn push(&mut self, value: Box<dyn Reflect>);
+    fn len(&self) -> usize;
+    fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+    fn iter(&self) -> ListIter;
+    fn clone_dynamic(&self) -> DynamicList {
+        DynamicList {
+            values: self.iter().map(|value| value.clone_value()).collect(),
+        }
+    }
+}
+
+#[derive(Default)]
+pub struct DynamicList {
+    pub(crate) values: Vec<Box<dyn Reflect>>,
+}
+
+impl DynamicList {
+    pub fn push<T: Reflect>(&mut self, value: T) {
+        self.values.push(Box::new(value));
+    }
+
+    pub fn push_box(&mut self, value: Box<dyn Reflect>) {
+        self.values.push(value);
+    }
+}
+
+impl List for DynamicList {
+    fn get(&self, index: usize) -> Option<&dyn Reflect> {
+        self.values.get(index).map(|value| &**value)
+    }
+
+    fn get_mut(&mut self, index: usize) -> Option<&mut dyn Reflect> {
+        self.values.get_mut(index).map(|value| &mut **value)
+    }
+
+    fn len(&self) -> usize {
+        self.values.len()
+    }
+
+    fn clone_dynamic(&self) -> DynamicList {
+        DynamicList {
+            values: self
+                .values
+                .iter()
+                .map(|value| value.clone_value())
+                .collect(),
+        }
+    }
+
+    fn iter(&self) -> ListIter {
+        ListIter {
+            list: self,
+            index: 0,
+        }
+    }
+
+    fn push(&mut self, value: Box<dyn Reflect>) {
+        DynamicList::push_box(self, value);
+    }
+}
+
+impl Reflect for DynamicList {
+    #[inline]
+    fn type_name(&self) -> &str {
+        std::any::type_name::<Self>()
+    }
+
+    #[inline]
+    fn any(&self) -> &dyn Any {
+        self
+    }
+
+    #[inline]
+    fn any_mut(&mut self) -> &mut dyn Any {
+        self
+    }
+
+    fn apply(&mut self, value: &dyn Reflect) {
+        list_apply(self, value);
+    }
+
+    #[inline]
+    fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>> {
+        *self = value.take()?;
+        Ok(())
+    }
+
+    #[inline]
+    fn reflect_ref(&self) -> ReflectRef {
+        ReflectRef::List(self)
+    }
+
+    #[inline]
+    fn reflect_mut(&mut self) -> ReflectMut {
+        ReflectMut::List(self)
+    }
+
+    #[inline]
+    fn clone_value(&self) -> Box<dyn Reflect> {
+        Box::new(self.clone_dynamic())
+    }
+
+    #[inline]
+    fn reflect_hash(&self) -> Option<u64> {
+        None
+    }
+
+    fn reflect_partial_eq(&self, value: &dyn Reflect) -> Option<bool> {
+        list_partial_eq(self, value)
+    }
+
+    fn serializable(&self) -> Option<Serializable> {
+        None
+    }
+}
+
+pub struct ListIter<'a> {
+    pub(crate) list: &'a dyn List,
+    pub(crate) index: usize,
+}
+
+impl<'a> Iterator for ListIter<'a> {
+    type Item = &'a dyn Reflect;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let value = self.list.get(self.index);
+        self.index += 1;
+        value
+    }
+}
+
+#[inline]
+pub fn list_apply<L: List>(a: &mut L, b: &dyn Reflect) {
+    if let ReflectRef::List(list_value) = b.reflect_ref() {
+        for (i, value) in list_value.iter().enumerate() {
+            if i < a.len() {
+                if let Some(v) = a.get_mut(i) {
+                    v.apply(value);
+                }
+            } else {
+                List::push(a, value.clone_value());
+            }
+        }
+    } else {
+        panic!("Attempted to apply a non-list type to a list type.");
+    }
+}
+
+#[inline]
+pub fn list_partial_eq<L: List>(a: &L, b: &dyn Reflect) -> Option<bool> {
+    let list = if let ReflectRef::List(list) = b.reflect_ref() {
+        list
+    } else {
+        return Some(false);
+    };
+
+    if a.len() != list.len() {
+        return Some(false);
+    }
+
+    for (a_value, b_value) in a.iter().zip(list.iter()) {
+        if let Some(false) | None = a_value.reflect_partial_eq(b_value) {
+            return Some(false);
+        }
+    }
+
+    Some(true)
+}
diff --git a/crates/bevy_reflect/src/map.rs b/crates/bevy_reflect/src/map.rs
new file mode 100644
index 0000000000000..eb5a89467f299
--- /dev/null
+++ b/crates/bevy_reflect/src/map.rs
@@ -0,0 +1,184 @@
+use std::{any::Any, collections::hash_map::Entry};
+
+use bevy_utils::HashMap;
+
+use crate::{serde::Serializable, Reflect, ReflectMut, ReflectRef};
+
+/// An ordered ReflectValue->ReflectValue mapping. ReflectValue Keys are assumed to return a non-None hash.  
+/// Ideally the ordering is stable across runs, but this is not required.
+/// This corresponds to types like [std::collections::HashMap].
+pub trait Map: Reflect {
+    fn get(&self, key: &dyn Reflect) -> Option<&dyn Reflect>;
+    fn get_mut(&mut self, key: &dyn Reflect) -> Option<&mut dyn Reflect>;
+    fn get_at(&self, index: usize) -> Option<(&dyn Reflect, &dyn Reflect)>;
+    fn len(&self) -> usize;
+    fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+    fn iter(&self) -> MapIter;
+    fn clone_dynamic(&self) -> DynamicMap;
+}
+
+const HASH_ERROR: &str = "the given key does not support hashing";
+
+#[derive(Default)]
+pub struct DynamicMap {
+    pub values: Vec<(Box<dyn Reflect>, Box<dyn Reflect>)>,
+    pub indices: HashMap<u64, usize>,
+}
+
+impl DynamicMap {
+    pub fn insert<K: Reflect, V: Reflect>(&mut self, key: K, value: V) {
+        self.insert_boxed(Box::new(key), Box::new(value));
+    }
+
+    pub fn insert_boxed(&mut self, key: Box<dyn Reflect>, value: Box<dyn Reflect>) {
+        match self.indices.entry(key.reflect_hash().expect(HASH_ERROR)) {
+            Entry::Occupied(entry) => {
+                self.values[*entry.get()] = (key, value);
+            }
+            Entry::Vacant(entry) => {
+                entry.insert(self.values.len());
+                self.values.push((key, value));
+            }
+        }
+    }
+}
+
+impl Map for DynamicMap {
+    fn get(&self, key: &dyn Reflect) -> Option<&dyn Reflect> {
+        self.indices
+            .get(&key.reflect_hash().expect(HASH_ERROR))
+            .map(|index| &*self.values.get(*index).unwrap().1)
+    }
+
+    fn get_mut(&mut self, key: &dyn Reflect) -> Option<&mut dyn Reflect> {
+        self.indices
+            .get(&key.reflect_hash().expect(HASH_ERROR))
+            .cloned()
+            .map(move |index| &mut *self.values.get_mut(index).unwrap().1)
+    }
+
+    fn len(&self) -> usize {
+        self.values.len()
+    }
+
+    fn clone_dynamic(&self) -> DynamicMap {
+        DynamicMap {
+            values: self
+                .values
+                .iter()
+                .map(|(key, value)| (key.clone_value(), value.clone_value()))
+                .collect(),
+            indices: self.indices.clone(),
+        }
+    }
+
+    fn iter(&self) -> MapIter {
+        MapIter {
+            map: self,
+            index: 0,
+        }
+    }
+
+    fn get_at(&self, index: usize) -> Option<(&dyn Reflect, &dyn Reflect)> {
+        self.values
+            .get(index)
+            .map(|(key, value)| (&**key, &**value))
+    }
+}
+
+impl Reflect for DynamicMap {
+    fn type_name(&self) -> &str {
+        std::any::type_name::<Self>()
+    }
+
+    fn any(&self) -> &dyn Any {
+        self
+    }
+
+    fn any_mut(&mut self) -> &mut dyn Any {
+        self
+    }
+
+    fn apply(&mut self, value: &dyn Reflect) {
+        if let ReflectRef::Map(map_value) = value.reflect_ref() {
+            for (key, value) in map_value.iter() {
+                if let Some(v) = self.get_mut(key) {
+                    v.apply(value)
+                }
+            }
+        } else {
+            panic!("Attempted to apply a non-map type to a map type.");
+        }
+    }
+
+    fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>> {
+        *self = value.take()?;
+        Ok(())
+    }
+
+    fn reflect_ref(&self) -> ReflectRef {
+        ReflectRef::Map(self)
+    }
+
+    fn reflect_mut(&mut self) -> ReflectMut {
+        ReflectMut::Map(self)
+    }
+
+    fn clone_value(&self) -> Box<dyn Reflect> {
+        Box::new(self.clone_dynamic())
+    }
+
+    fn reflect_hash(&self) -> Option<u64> {
+        None
+    }
+
+    fn reflect_partial_eq(&self, value: &dyn Reflect) -> Option<bool> {
+        map_partial_eq(self, value)
+    }
+
+    fn serializable(&self) -> Option<Serializable> {
+        None
+    }
+}
+
+pub struct MapIter<'a> {
+    pub(crate) map: &'a dyn Map,
+    pub(crate) index: usize,
+}
+
+impl<'a> Iterator for MapIter<'a> {
+    type Item = (&'a dyn Reflect, &'a dyn Reflect);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let value = self.map.get_at(self.index);
+        self.index += 1;
+        value
+    }
+}
+
+#[inline]
+pub fn map_partial_eq<M: Map>(a: &M, b: &dyn Reflect) -> Option<bool> {
+    let map = if let ReflectRef::Map(map) = b.reflect_ref() {
+        map
+    } else {
+        return Some(false);
+    };
+
+    if a.len() != map.len() {
+        return Some(false);
+    }
+
+    for (key, value) in a.iter() {
+        if let Some(map_value) = map.get(key) {
+            if let Some(false) | None = value.reflect_partial_eq(map_value) {
+                return Some(false);
+            }
+        } else {
+            return Some(false);
+        }
+    }
+
+    Some(true)
+}
diff --git a/crates/bevy_reflect/src/path.rs b/crates/bevy_reflect/src/path.rs
new file mode 100644
index 0000000000000..a8232f7c594f6
--- /dev/null
+++ b/crates/bevy_reflect/src/path.rs
@@ -0,0 +1,385 @@
+use std::num::ParseIntError;
+
+use crate::{Reflect, ReflectMut, ReflectRef};
+use thiserror::Error;
+
+#[derive(Debug, PartialEq, Eq, Error)]
+pub enum ReflectPathError<'a> {
+    #[error("expected an identifier at the given index")]
+    ExpectedIdent { index: usize },
+    #[error("the current struct doesn't have a field with the given name")]
+    InvalidField { index: usize, field: &'a str },
+    #[error("the current tuple struct doesn't have a field with the given index")]
+    InvalidTupleStructIndex {
+        index: usize,
+        tuple_struct_index: usize,
+    },
+    #[error("the current list doesn't have a value at the given index")]
+    InvalidListIndex { index: usize, list_index: usize },
+    #[error("encountered an unexpected token")]
+    UnexpectedToken { index: usize, token: &'a str },
+    #[error("expected a token, but it wasn't there.")]
+    ExpectedToken { index: usize, token: &'a str },
+    #[error("expected a struct, but found a different reflect value")]
+    ExpectedStruct { index: usize },
+    #[error("expected a list, but found a different reflect value")]
+    ExpectedList { index: usize },
+    #[error("failed to parse a usize")]
+    IndexParseError(#[from] ParseIntError),
+    #[error("failed to downcast to the path result to the given type")]
+    InvalidDowncast,
+}
+
+pub trait GetPath {
+    fn path<'r, 'p>(&'r self, path: &'p str) -> Result<&'r dyn Reflect, ReflectPathError<'p>>;
+    fn path_mut<'r, 'p>(
+        &'r mut self,
+        path: &'p str,
+    ) -> Result<&'r mut dyn Reflect, ReflectPathError<'p>>;
+
+    fn get_path<'r, 'p, T: Reflect>(
+        &'r self,
+        path: &'p str,
+    ) -> Result<&'r T, ReflectPathError<'p>> {
+        self.path(path).and_then(|p| {
+            p.downcast_ref::<T>()
+                .ok_or(ReflectPathError::InvalidDowncast)
+        })
+    }
+
+    fn get_path_mut<'r, 'p, T: Reflect>(
+        &'r mut self,
+        path: &'p str,
+    ) -> Result<&'r mut T, ReflectPathError<'p>> {
+        self.path_mut(path).and_then(|p| {
+            p.downcast_mut::<T>()
+                .ok_or(ReflectPathError::InvalidDowncast)
+        })
+    }
+}
+
+impl<T: Reflect> GetPath for T {
+    fn path<'r, 'p>(&'r self, path: &'p str) -> Result<&'r dyn Reflect, ReflectPathError<'p>> {
+        (self as &dyn Reflect).path(path)
+    }
+
+    fn path_mut<'r, 'p>(
+        &'r mut self,
+        path: &'p str,
+    ) -> Result<&'r mut dyn Reflect, ReflectPathError<'p>> {
+        (self as &mut dyn Reflect).path_mut(path)
+    }
+}
+
+impl GetPath for dyn Reflect {
+    fn path<'r, 'p>(&'r self, path: &'p str) -> Result<&'r dyn Reflect, ReflectPathError<'p>> {
+        let mut index = 0;
+        let mut current: &dyn Reflect = self;
+        while let Some(token) = next_token(path, &mut index) {
+            let current_index = index;
+            match token {
+                Token::Dot => {
+                    if let Some(Token::Ident(value)) = next_token(path, &mut index) {
+                        current = read_field(current, value, current_index)?;
+                    } else {
+                        return Err(ReflectPathError::ExpectedIdent {
+                            index: current_index,
+                        });
+                    }
+                }
+                Token::OpenBracket => {
+                    if let Some(Token::Ident(value)) = next_token(path, &mut index) {
+                        match current.reflect_ref() {
+                            ReflectRef::List(reflect_list) => {
+                                let list_index = value.parse::<usize>()?;
+                                let list_item = reflect_list.get(list_index).ok_or(
+                                    ReflectPathError::InvalidListIndex {
+                                        index: current_index,
+                                        list_index,
+                                    },
+                                )?;
+                                current = list_item;
+                            }
+                            _ => {
+                                return Err(ReflectPathError::ExpectedList {
+                                    index: current_index,
+                                })
+                            }
+                        }
+                    } else {
+                        return Err(ReflectPathError::ExpectedIdent {
+                            index: current_index,
+                        });
+                    }
+
+                    if let Some(Token::CloseBracket) = next_token(path, &mut index) {
+                    } else {
+                        return Err(ReflectPathError::ExpectedToken {
+                            index: current_index,
+                            token: "]",
+                        });
+                    }
+                }
+                Token::CloseBracket => {
+                    return Err(ReflectPathError::UnexpectedToken {
+                        index: current_index,
+                        token: "]",
+                    })
+                }
+                Token::Ident(value) => {
+                    current = read_field(current, value, current_index)?;
+                }
+            }
+        }
+
+        Ok(current)
+    }
+
+    fn path_mut<'r, 'p>(
+        &'r mut self,
+        path: &'p str,
+    ) -> Result<&'r mut dyn Reflect, ReflectPathError<'p>> {
+        let mut index = 0;
+        let mut current: &mut dyn Reflect = self;
+        while let Some(token) = next_token(path, &mut index) {
+            let current_index = index;
+            match token {
+                Token::Dot => {
+                    if let Some(Token::Ident(value)) = next_token(path, &mut index) {
+                        current = read_field_mut(current, value, current_index)?;
+                    } else {
+                        return Err(ReflectPathError::ExpectedIdent {
+                            index: current_index,
+                        });
+                    }
+                }
+                Token::OpenBracket => {
+                    if let Some(Token::Ident(value)) = next_token(path, &mut index) {
+                        match current.reflect_mut() {
+                            ReflectMut::List(reflect_list) => {
+                                let list_index = value.parse::<usize>()?;
+                                let list_item = reflect_list.get_mut(list_index).ok_or(
+                                    ReflectPathError::InvalidListIndex {
+                                        index: current_index,
+                                        list_index,
+                                    },
+                                )?;
+                                current = list_item;
+                            }
+                            _ => {
+                                return Err(ReflectPathError::ExpectedStruct {
+                                    index: current_index,
+                                })
+                            }
+                        }
+                    } else {
+                        return Err(ReflectPathError::ExpectedIdent {
+                            index: current_index,
+                        });
+                    }
+
+                    if let Some(Token::CloseBracket) = next_token(path, &mut index) {
+                    } else {
+                        return Err(ReflectPathError::ExpectedToken {
+                            index: current_index,
+                            token: "]",
+                        });
+                    }
+                }
+                Token::CloseBracket => {
+                    return Err(ReflectPathError::UnexpectedToken {
+                        index: current_index,
+                        token: "]",
+                    })
+                }
+                Token::Ident(value) => {
+                    current = read_field_mut(current, value, current_index)?;
+                }
+            }
+        }
+
+        Ok(current)
+    }
+}
+
+fn read_field<'r, 'p>(
+    current: &'r dyn Reflect,
+    field: &'p str,
+    current_index: usize,
+) -> Result<&'r dyn Reflect, ReflectPathError<'p>> {
+    match current.reflect_ref() {
+        ReflectRef::Struct(reflect_struct) => {
+            Ok(reflect_struct
+                .field(field)
+                .ok_or(ReflectPathError::InvalidField {
+                    index: current_index,
+                    field,
+                })?)
+        }
+        ReflectRef::TupleStruct(reflect_struct) => {
+            let tuple_index = field.parse::<usize>()?;
+            Ok(reflect_struct.field(tuple_index).ok_or(
+                ReflectPathError::InvalidTupleStructIndex {
+                    index: current_index,
+                    tuple_struct_index: tuple_index,
+                },
+            )?)
+        }
+        _ => Err(ReflectPathError::ExpectedStruct {
+            index: current_index,
+        }),
+    }
+}
+
+fn read_field_mut<'r, 'p>(
+    current: &'r mut dyn Reflect,
+    field: &'p str,
+    current_index: usize,
+) -> Result<&'r mut dyn Reflect, ReflectPathError<'p>> {
+    match current.reflect_mut() {
+        ReflectMut::Struct(reflect_struct) => {
+            Ok(reflect_struct
+                .field_mut(field)
+                .ok_or(ReflectPathError::InvalidField {
+                    index: current_index,
+                    field,
+                })?)
+        }
+        ReflectMut::TupleStruct(reflect_struct) => {
+            let tuple_index = field.parse::<usize>()?;
+            Ok(reflect_struct.field_mut(tuple_index).ok_or(
+                ReflectPathError::InvalidTupleStructIndex {
+                    index: current_index,
+                    tuple_struct_index: tuple_index,
+                },
+            )?)
+        }
+        _ => Err(ReflectPathError::ExpectedStruct {
+            index: current_index,
+        }),
+    }
+}
+
+enum Token<'a> {
+    Dot,
+    OpenBracket,
+    CloseBracket,
+    Ident(&'a str),
+}
+
+fn next_token<'a>(path: &'a str, index: &mut usize) -> Option<Token<'a>> {
+    if *index >= path.len() {
+        return None;
+    }
+
+    match path[*index..].chars().next().unwrap() {
+        '.' => {
+            *index += 1;
+            return Some(Token::Dot);
+        }
+        '[' => {
+            *index += 1;
+            return Some(Token::OpenBracket);
+        }
+        ']' => {
+            *index += 1;
+            return Some(Token::CloseBracket);
+        }
+        _ => {}
+    }
+
+    // we can assume we are parsing an ident now
+    for (char_index, character) in path[*index..].chars().enumerate() {
+        match character {
+            '.' | '[' | ']' => {
+                let ident = Token::Ident(&path[*index..*index + char_index]);
+                *index += char_index;
+                return Some(ident);
+            }
+            _ => {}
+        }
+    }
+    let ident = Token::Ident(&path[*index..]);
+    *index = path.len();
+    Some(ident)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::GetPath;
+    use crate::*;
+    #[test]
+    fn reflect_path() {
+        #[derive(Reflect)]
+        struct A {
+            w: usize,
+            x: B,
+            y: Vec<C>,
+            z: D,
+        }
+
+        #[derive(Reflect)]
+        struct B {
+            foo: usize,
+            bar: C,
+        }
+
+        #[derive(Reflect)]
+        struct C {
+            baz: f32,
+        }
+
+        #[derive(Reflect)]
+        struct D(E);
+
+        #[derive(Reflect)]
+        struct E(f32, usize);
+
+        let mut a = A {
+            w: 1,
+            x: B {
+                foo: 10,
+                bar: C { baz: 3.14 },
+            },
+            y: vec![C { baz: 1.0 }, C { baz: 2.0 }],
+            z: D(E(10.0, 42)),
+        };
+
+        assert_eq!(*a.get_path::<usize>("w").unwrap(), 1);
+        assert_eq!(*a.get_path::<usize>("x.foo").unwrap(), 10);
+        assert_eq!(*a.get_path::<f32>("x.bar.baz").unwrap(), 3.14);
+        assert_eq!(*a.get_path::<f32>("y[1].baz").unwrap(), 2.0);
+        assert_eq!(*a.get_path::<usize>("z.0.1").unwrap(), 42);
+
+        *a.get_path_mut::<f32>("y[1].baz").unwrap() = 3.0;
+        assert_eq!(a.y[1].baz, 3.0);
+
+        assert_eq!(
+            a.path("x.notreal").err().unwrap(),
+            ReflectPathError::InvalidField {
+                index: 2,
+                field: "notreal"
+            }
+        );
+
+        assert_eq!(
+            a.path("x..").err().unwrap(),
+            ReflectPathError::ExpectedIdent { index: 2 }
+        );
+
+        assert_eq!(
+            a.path("x[0]").err().unwrap(),
+            ReflectPathError::ExpectedList { index: 2 }
+        );
+
+        assert_eq!(
+            a.path("y.x").err().unwrap(),
+            ReflectPathError::ExpectedStruct { index: 2 }
+        );
+
+        assert!(matches!(
+            a.path("y[badindex]"),
+            Err(ReflectPathError::IndexParseError(_))
+        ));
+    }
+}
diff --git a/crates/bevy_reflect/src/reflect.rs b/crates/bevy_reflect/src/reflect.rs
new file mode 100644
index 0000000000000..ee7a1caca2988
--- /dev/null
+++ b/crates/bevy_reflect/src/reflect.rs
@@ -0,0 +1,77 @@
+use crate::{serde::Serializable, List, Map, Struct, TupleStruct};
+use std::{any::Any, fmt::Debug};
+
+pub use bevy_utils::AHasher as ReflectHasher;
+
+pub enum ReflectRef<'a> {
+    Struct(&'a dyn Struct),
+    TupleStruct(&'a dyn TupleStruct),
+    List(&'a dyn List),
+    Map(&'a dyn Map),
+    Value(&'a dyn Reflect),
+}
+
+pub enum ReflectMut<'a> {
+    Struct(&'a mut dyn Struct),
+    TupleStruct(&'a mut dyn TupleStruct),
+    List(&'a mut dyn List),
+    Map(&'a mut dyn Map),
+    Value(&'a mut dyn Reflect),
+}
+
+/// A reflected rust type.
+pub trait Reflect: Any + Send + Sync {
+    fn type_name(&self) -> &str;
+    fn any(&self) -> &dyn Any;
+    fn any_mut(&mut self) -> &mut dyn Any;
+    fn apply(&mut self, value: &dyn Reflect);
+    fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>;
+    fn reflect_ref(&self) -> ReflectRef;
+    fn reflect_mut(&mut self) -> ReflectMut;
+    fn clone_value(&self) -> Box<dyn Reflect>;
+    /// Returns a hash of the value (which includes the type) if hashing is supported. Otherwise `None` will be returned.
+    fn reflect_hash(&self) -> Option<u64>;
+    /// Returns a "partial equal" comparison result if comparison is supported. Otherwise `None` will be returned.
+    fn reflect_partial_eq(&self, _value: &dyn Reflect) -> Option<bool>;
+    /// Returns a serializable value, if serialization is supported. Otherwise `None` will be returned.
+    fn serializable(&self) -> Option<Serializable>;
+}
+
+impl Debug for dyn Reflect {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(&format!("Reflect({})", self.type_name()))
+    }
+}
+
+impl dyn Reflect {
+    pub fn downcast<T: Reflect>(self: Box<dyn Reflect>) -> Result<Box<T>, Box<dyn Reflect>> {
+        // SAFE?: Same approach used by std::any::Box::downcast. ReflectValue is always Any and type has been checked.
+        if self.is::<T>() {
+            unsafe {
+                let raw: *mut dyn Reflect = Box::into_raw(self);
+                Ok(Box::from_raw(raw as *mut T))
+            }
+        } else {
+            Err(self)
+        }
+    }
+
+    pub fn take<T: Reflect>(self: Box<dyn Reflect>) -> Result<T, Box<dyn Reflect>> {
+        self.downcast::<T>().map(|value| *value)
+    }
+
+    #[inline]
+    pub fn is<T: Reflect>(&self) -> bool {
+        self.any().is::<T>()
+    }
+
+    #[inline]
+    pub fn downcast_ref<T: Reflect>(&self) -> Option<&T> {
+        self.any().downcast_ref::<T>()
+    }
+
+    #[inline]
+    pub fn downcast_mut<T: Reflect>(&mut self) -> Option<&mut T> {
+        self.any_mut().downcast_mut::<T>()
+    }
+}
diff --git a/crates/bevy_reflect/src/serde/de.rs b/crates/bevy_reflect/src/serde/de.rs
new file mode 100644
index 0000000000000..29203b065f3e5
--- /dev/null
+++ b/crates/bevy_reflect/src/serde/de.rs
@@ -0,0 +1,403 @@
+use crate::{
+    serde::type_fields, DynamicList, DynamicMap, DynamicStruct, DynamicTupleStruct, Reflect,
+    ReflectDeserialize, TypeRegistry,
+};
+use erased_serde::Deserializer;
+use serde::de::{self, DeserializeSeed, MapAccess, SeqAccess, Visitor};
+
+pub trait DeserializeValue {
+    fn deserialize(
+        deserializer: &mut dyn Deserializer,
+        type_registry: &TypeRegistry,
+    ) -> Result<Box<dyn Reflect>, erased_serde::Error>;
+}
+
+pub struct ReflectDeserializer<'a> {
+    registry: &'a TypeRegistry,
+}
+
+impl<'a> ReflectDeserializer<'a> {
+    pub fn new(registry: &'a TypeRegistry) -> Self {
+        ReflectDeserializer { registry }
+    }
+}
+
+impl<'a, 'de> DeserializeSeed<'de> for ReflectDeserializer<'a> {
+    type Value = Box<dyn Reflect>;
+
+    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        deserializer.deserialize_any(ReflectVisitor {
+            registry: self.registry,
+        })
+    }
+}
+
+struct ReflectVisitor<'a> {
+    registry: &'a TypeRegistry,
+}
+
+impl<'a, 'de> Visitor<'de> for ReflectVisitor<'a> {
+    type Value = Box<dyn Reflect>;
+
+    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+        formatter.write_str("reflect value")
+    }
+
+    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        Ok(Box::new(v))
+    }
+
+    fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        Ok(Box::new(v))
+    }
+
+    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        Ok(Box::new(v))
+    }
+
+    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        Ok(Box::new(v))
+    }
+
+    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        Ok(Box::new(v))
+    }
+
+    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        Ok(Box::new(v))
+    }
+
+    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        Ok(Box::new(v))
+    }
+
+    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        Ok(Box::new(v))
+    }
+
+    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        Ok(Box::new(v))
+    }
+
+    fn visit_f32<E>(self, v: f32) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        Ok(Box::new(v))
+    }
+
+    fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        Ok(Box::new(v))
+    }
+
+    fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        Ok(Box::new(v))
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        Ok(Box::new(v.to_string()))
+    }
+
+    fn visit_map<V>(self, mut map: V) -> Result<Self::Value, V::Error>
+    where
+        V: MapAccess<'de>,
+    {
+        let mut type_name: Option<String> = None;
+        while let Some(key) = map.next_key::<String>()? {
+            match key.as_str() {
+                type_fields::TYPE => {
+                    type_name = Some(map.next_value()?);
+                }
+                type_fields::MAP => {
+                    let _type_name = type_name
+                        .take()
+                        .ok_or_else(|| de::Error::missing_field(type_fields::TYPE))?;
+                    let map = map.next_value_seed(MapDeserializer {
+                        registry: self.registry,
+                    })?;
+                    return Ok(Box::new(map));
+                }
+                type_fields::STRUCT => {
+                    let type_name = type_name
+                        .take()
+                        .ok_or_else(|| de::Error::missing_field(type_fields::TYPE))?;
+                    let mut dynamic_struct = map.next_value_seed(StructDeserializer {
+                        registry: self.registry,
+                    })?;
+                    dynamic_struct.set_name(type_name);
+                    return Ok(Box::new(dynamic_struct));
+                }
+                type_fields::TUPLE_STRUCT => {
+                    let type_name = type_name
+                        .take()
+                        .ok_or_else(|| de::Error::missing_field(type_fields::TYPE))?;
+                    let mut tuple_struct = map.next_value_seed(TupleStructDeserializer {
+                        registry: self.registry,
+                    })?;
+                    tuple_struct.set_name(type_name);
+                    return Ok(Box::new(tuple_struct));
+                }
+                type_fields::LIST => {
+                    let _type_name = type_name
+                        .take()
+                        .ok_or_else(|| de::Error::missing_field(type_fields::TYPE))?;
+                    let list = map.next_value_seed(ListDeserializer {
+                        registry: self.registry,
+                    })?;
+                    return Ok(Box::new(list));
+                }
+                type_fields::VALUE => {
+                    let type_name = type_name
+                        .take()
+                        .ok_or_else(|| de::Error::missing_field(type_fields::TYPE))?;
+                    let registration =
+                        self.registry.get_with_name(&type_name).ok_or_else(|| {
+                            de::Error::custom(format!("No registration found for {}", type_name))
+                        })?;
+                    let deserialize_reflect =
+                        registration.data::<ReflectDeserialize>().ok_or_else(|| {
+                            de::Error::custom(format!(
+                                "The TypeRegistration for {} doesn't have DeserializeReflect",
+                                type_name
+                            ))
+                        })?;
+                    let value = map.next_value_seed(DeserializeReflectDeserializer {
+                        reflect_deserialize: deserialize_reflect,
+                    })?;
+                    return Ok(value);
+                }
+                _ => return Err(de::Error::unknown_field(key.as_str(), &[])),
+            }
+        }
+
+        Err(de::Error::custom("Maps in this location must have the \'type\' field and one of the following fields: \'map\', \'seq\', \'value\'"))
+    }
+}
+
+struct DeserializeReflectDeserializer<'a> {
+    reflect_deserialize: &'a ReflectDeserialize,
+}
+
+impl<'a, 'de> DeserializeSeed<'de> for DeserializeReflectDeserializer<'a> {
+    type Value = Box<dyn Reflect>;
+
+    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        self.reflect_deserialize.deserialize(deserializer)
+    }
+}
+
+struct ListDeserializer<'a> {
+    registry: &'a TypeRegistry,
+}
+
+impl<'a, 'de> DeserializeSeed<'de> for ListDeserializer<'a> {
+    type Value = DynamicList;
+
+    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        deserializer.deserialize_seq(ListVisitor {
+            registry: self.registry,
+        })
+    }
+}
+
+struct ListVisitor<'a> {
+    registry: &'a TypeRegistry,
+}
+
+impl<'a, 'de> Visitor<'de> for ListVisitor<'a> {
+    type Value = DynamicList;
+
+    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+        formatter.write_str("list value")
+    }
+
+    fn visit_seq<V>(self, mut seq: V) -> Result<Self::Value, V::Error>
+    where
+        V: SeqAccess<'de>,
+    {
+        let mut list = DynamicList::default();
+        while let Some(value) = seq.next_element_seed(ReflectDeserializer {
+            registry: self.registry,
+        })? {
+            list.push_box(value);
+        }
+        Ok(list)
+    }
+}
+
+struct MapDeserializer<'a> {
+    registry: &'a TypeRegistry,
+}
+
+impl<'a, 'de> DeserializeSeed<'de> for MapDeserializer<'a> {
+    type Value = DynamicMap;
+
+    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        deserializer.deserialize_map(MapVisitor {
+            registry: self.registry,
+        })
+    }
+}
+
+struct MapVisitor<'a> {
+    registry: &'a TypeRegistry,
+}
+
+impl<'a, 'de> Visitor<'de> for MapVisitor<'a> {
+    type Value = DynamicMap;
+
+    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+        formatter.write_str("map value")
+    }
+
+    fn visit_map<V>(self, mut map: V) -> Result<Self::Value, V::Error>
+    where
+        V: MapAccess<'de>,
+    {
+        let mut dynamic_map = DynamicMap::default();
+        while let Some(key) = map.next_key_seed(ReflectDeserializer {
+            registry: self.registry,
+        })? {
+            let value = map.next_value_seed(ReflectDeserializer {
+                registry: self.registry,
+            })?;
+            dynamic_map.insert_boxed(key, value);
+        }
+
+        Ok(dynamic_map)
+    }
+}
+
+struct StructDeserializer<'a> {
+    registry: &'a TypeRegistry,
+}
+
+impl<'a, 'de> DeserializeSeed<'de> for StructDeserializer<'a> {
+    type Value = DynamicStruct;
+
+    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        deserializer.deserialize_map(StructVisitor {
+            registry: self.registry,
+        })
+    }
+}
+
+struct StructVisitor<'a> {
+    registry: &'a TypeRegistry,
+}
+
+impl<'a, 'de> Visitor<'de> for StructVisitor<'a> {
+    type Value = DynamicStruct;
+
+    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+        formatter.write_str("struct value")
+    }
+
+    fn visit_map<V>(self, mut map: V) -> Result<Self::Value, V::Error>
+    where
+        V: MapAccess<'de>,
+    {
+        let mut dynamic_struct = DynamicStruct::default();
+        while let Some(key) = map.next_key::<String>()? {
+            let value = map.next_value_seed(ReflectDeserializer {
+                registry: self.registry,
+            })?;
+            dynamic_struct.insert_boxed(&key, value);
+        }
+
+        Ok(dynamic_struct)
+    }
+}
+
+struct TupleStructDeserializer<'a> {
+    registry: &'a TypeRegistry,
+}
+
+impl<'a, 'de> DeserializeSeed<'de> for TupleStructDeserializer<'a> {
+    type Value = DynamicTupleStruct;
+
+    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        deserializer.deserialize_seq(TupleStructVisitor {
+            registry: self.registry,
+        })
+    }
+}
+
+struct TupleStructVisitor<'a> {
+    registry: &'a TypeRegistry,
+}
+
+impl<'a, 'de> Visitor<'de> for TupleStructVisitor<'a> {
+    type Value = DynamicTupleStruct;
+
+    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+        formatter.write_str("tuple struct value")
+    }
+
+    fn visit_seq<V>(self, mut seq: V) -> Result<Self::Value, V::Error>
+    where
+        V: SeqAccess<'de>,
+    {
+        let mut tuple_struct = DynamicTupleStruct::default();
+        while let Some(value) = seq.next_element_seed(ReflectDeserializer {
+            registry: self.registry,
+        })? {
+            tuple_struct.insert_boxed(value);
+        }
+        Ok(tuple_struct)
+    }
+}
diff --git a/crates/bevy_reflect/src/serde/mod.rs b/crates/bevy_reflect/src/serde/mod.rs
new file mode 100644
index 0000000000000..9f89cda3954c7
--- /dev/null
+++ b/crates/bevy_reflect/src/serde/mod.rs
@@ -0,0 +1,14 @@
+mod de;
+mod ser;
+
+pub use de::*;
+pub use ser::*;
+
+pub(crate) mod type_fields {
+    pub const TYPE: &str = "type";
+    pub const MAP: &str = "map";
+    pub const STRUCT: &str = "struct";
+    pub const TUPLE_STRUCT: &str = "tuple_struct";
+    pub const LIST: &str = "list";
+    pub const VALUE: &str = "value";
+}
diff --git a/crates/bevy_reflect/src/serde/ser.rs b/crates/bevy_reflect/src/serde/ser.rs
new file mode 100644
index 0000000000000..778b0fb658bc0
--- /dev/null
+++ b/crates/bevy_reflect/src/serde/ser.rs
@@ -0,0 +1,268 @@
+use crate::{
+    serde::type_fields, List, Map, Reflect, ReflectRef, Struct, TupleStruct, TypeRegistry,
+};
+use serde::{
+    ser::{SerializeMap, SerializeSeq},
+    Serialize,
+};
+
+pub enum Serializable<'a> {
+    Owned(Box<dyn erased_serde::Serialize + 'a>),
+    Borrowed(&'a dyn erased_serde::Serialize),
+}
+
+impl<'a> Serializable<'a> {
+    #[allow(clippy::should_implement_trait)]
+    pub fn borrow(&self) -> &dyn erased_serde::Serialize {
+        match self {
+            Serializable::Borrowed(serialize) => serialize,
+            Serializable::Owned(serialize) => serialize,
+        }
+    }
+}
+
+fn get_serializable<E: serde::ser::Error>(reflect_value: &dyn Reflect) -> Result<Serializable, E> {
+    reflect_value.serializable().ok_or_else(|| {
+        serde::ser::Error::custom(&format!(
+            "Type '{}' does not support ReflectValue serialization",
+            reflect_value.type_name()
+        ))
+    })
+}
+
+pub struct ReflectSerializer<'a> {
+    pub value: &'a dyn Reflect,
+    pub registry: &'a TypeRegistry,
+}
+
+impl<'a> ReflectSerializer<'a> {
+    pub fn new(value: &'a dyn Reflect, registry: &'a TypeRegistry) -> Self {
+        ReflectSerializer { value, registry }
+    }
+}
+
+impl<'a> Serialize for ReflectSerializer<'a> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        match self.value.reflect_ref() {
+            ReflectRef::Struct(value) => StructSerializer {
+                struct_value: value,
+                registry: self.registry,
+            }
+            .serialize(serializer),
+            ReflectRef::TupleStruct(value) => TupleStructSerializer {
+                tuple_struct: value,
+                registry: self.registry,
+            }
+            .serialize(serializer),
+            ReflectRef::List(value) => ListSerializer {
+                list: value,
+                registry: self.registry,
+            }
+            .serialize(serializer),
+            ReflectRef::Map(value) => MapSerializer {
+                map: value,
+                registry: self.registry,
+            }
+            .serialize(serializer),
+            ReflectRef::Value(value) => ReflectValueSerializer {
+                registry: self.registry,
+                value,
+            }
+            .serialize(serializer),
+        }
+    }
+}
+
+pub struct ReflectValueSerializer<'a> {
+    pub registry: &'a TypeRegistry,
+    pub value: &'a dyn Reflect,
+}
+
+impl<'a> Serialize for ReflectValueSerializer<'a> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let mut state = serializer.serialize_map(Some(2))?;
+        state.serialize_entry(type_fields::TYPE, self.value.type_name())?;
+        state.serialize_entry(
+            type_fields::VALUE,
+            get_serializable::<S::Error>(self.value)?.borrow(),
+        )?;
+        state.end()
+    }
+}
+
+pub struct StructSerializer<'a> {
+    pub struct_value: &'a dyn Struct,
+    pub registry: &'a TypeRegistry,
+}
+
+impl<'a> Serialize for StructSerializer<'a> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let mut state = serializer.serialize_map(Some(2))?;
+
+        state.serialize_entry(type_fields::TYPE, self.struct_value.type_name())?;
+        state.serialize_entry(
+            type_fields::STRUCT,
+            &StructValueSerializer {
+                struct_value: self.struct_value,
+                registry: self.registry,
+            },
+        )?;
+        state.end()
+    }
+}
+
+pub struct StructValueSerializer<'a> {
+    pub struct_value: &'a dyn Struct,
+    pub registry: &'a TypeRegistry,
+}
+
+impl<'a> Serialize for StructValueSerializer<'a> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let mut state = serializer.serialize_map(Some(self.struct_value.field_len()))?;
+        for (index, value) in self.struct_value.iter_fields().enumerate() {
+            let key = self.struct_value.name_at(index).unwrap();
+            state.serialize_entry(key, &ReflectSerializer::new(value, self.registry))?;
+        }
+        state.end()
+    }
+}
+
+pub struct TupleStructSerializer<'a> {
+    pub tuple_struct: &'a dyn TupleStruct,
+    pub registry: &'a TypeRegistry,
+}
+
+impl<'a> Serialize for TupleStructSerializer<'a> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let mut state = serializer.serialize_map(Some(2))?;
+
+        state.serialize_entry(type_fields::TYPE, self.tuple_struct.type_name())?;
+        state.serialize_entry(
+            type_fields::TUPLE_STRUCT,
+            &TupleStructValueSerializer {
+                tuple_struct: self.tuple_struct,
+                registry: self.registry,
+            },
+        )?;
+        state.end()
+    }
+}
+
+pub struct TupleStructValueSerializer<'a> {
+    pub tuple_struct: &'a dyn TupleStruct,
+    pub registry: &'a TypeRegistry,
+}
+
+impl<'a> Serialize for TupleStructValueSerializer<'a> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let mut state = serializer.serialize_seq(Some(self.tuple_struct.field_len()))?;
+        for value in self.tuple_struct.iter_fields() {
+            state.serialize_element(&ReflectSerializer::new(value, self.registry))?;
+        }
+        state.end()
+    }
+}
+
+pub struct MapSerializer<'a> {
+    pub map: &'a dyn Map,
+    pub registry: &'a TypeRegistry,
+}
+
+impl<'a> Serialize for MapSerializer<'a> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let mut state = serializer.serialize_map(Some(2))?;
+
+        state.serialize_entry(type_fields::TYPE, self.map.type_name())?;
+        state.serialize_entry(
+            type_fields::MAP,
+            &MapValueSerializer {
+                map: self.map,
+                registry: self.registry,
+            },
+        )?;
+        state.end()
+    }
+}
+
+pub struct MapValueSerializer<'a> {
+    pub map: &'a dyn Map,
+    pub registry: &'a TypeRegistry,
+}
+
+impl<'a> Serialize for MapValueSerializer<'a> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let mut state = serializer.serialize_map(Some(self.map.len()))?;
+        for (key, value) in self.map.iter() {
+            state.serialize_entry(
+                &ReflectSerializer::new(key, self.registry),
+                &ReflectSerializer::new(value, self.registry),
+            )?;
+        }
+        state.end()
+    }
+}
+
+pub struct ListSerializer<'a> {
+    pub list: &'a dyn List,
+    pub registry: &'a TypeRegistry,
+}
+
+impl<'a> Serialize for ListSerializer<'a> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let mut state = serializer.serialize_map(Some(2))?;
+        state.serialize_entry(type_fields::TYPE, self.list.type_name())?;
+        state.serialize_entry(
+            type_fields::LIST,
+            &ListValueSerializer {
+                list: self.list,
+                registry: self.registry,
+            },
+        )?;
+        state.end()
+    }
+}
+
+pub struct ListValueSerializer<'a> {
+    pub list: &'a dyn List,
+    pub registry: &'a TypeRegistry,
+}
+
+impl<'a> Serialize for ListValueSerializer<'a> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let mut state = serializer.serialize_seq(Some(self.list.len()))?;
+        for value in self.list.iter() {
+            state.serialize_element(&ReflectSerializer::new(value, self.registry))?;
+        }
+        state.end()
+    }
+}
diff --git a/crates/bevy_reflect/src/struct_trait.rs b/crates/bevy_reflect/src/struct_trait.rs
new file mode 100644
index 0000000000000..764d36a336cb8
--- /dev/null
+++ b/crates/bevy_reflect/src/struct_trait.rs
@@ -0,0 +1,256 @@
+use crate::{serde::Serializable, Reflect, ReflectMut, ReflectRef};
+use bevy_utils::HashMap;
+use std::{any::Any, borrow::Cow, collections::hash_map::Entry};
+
+/// An ordered &str->ReflectValue mapping where &str is a "field".
+/// This corresponds to rust struct types.
+pub trait Struct: Reflect {
+    fn field(&self, name: &str) -> Option<&dyn Reflect>;
+    fn field_mut(&mut self, name: &str) -> Option<&mut dyn Reflect>;
+    fn field_at(&self, index: usize) -> Option<&dyn Reflect>;
+    fn field_at_mut(&mut self, index: usize) -> Option<&mut dyn Reflect>;
+    fn name_at(&self, index: usize) -> Option<&str>;
+    fn field_len(&self) -> usize;
+    fn iter_fields(&self) -> FieldIter;
+    fn clone_dynamic(&self) -> DynamicStruct;
+}
+
+pub struct FieldIter<'a> {
+    pub(crate) struct_val: &'a dyn Struct,
+    pub(crate) index: usize,
+}
+
+impl<'a> FieldIter<'a> {
+    pub fn new(value: &'a dyn Struct) -> Self {
+        FieldIter {
+            struct_val: value,
+            index: 0,
+        }
+    }
+}
+
+impl<'a> Iterator for FieldIter<'a> {
+    type Item = &'a dyn Reflect;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let value = self.struct_val.field_at(self.index);
+        self.index += 1;
+        value
+    }
+}
+
+pub trait GetField {
+    fn get_field<T: Reflect>(&self, name: &str) -> Option<&T>;
+    fn get_field_mut<T: Reflect>(&mut self, name: &str) -> Option<&mut T>;
+}
+
+impl<S: Struct> GetField for S {
+    fn get_field<T: Reflect>(&self, name: &str) -> Option<&T> {
+        self.field(name).and_then(|value| value.downcast_ref::<T>())
+    }
+
+    fn get_field_mut<T: Reflect>(&mut self, name: &str) -> Option<&mut T> {
+        self.field_mut(name)
+            .and_then(|value| value.downcast_mut::<T>())
+    }
+}
+
+impl GetField for dyn Struct {
+    fn get_field<T: Reflect>(&self, name: &str) -> Option<&T> {
+        self.field(name).and_then(|value| value.downcast_ref::<T>())
+    }
+
+    fn get_field_mut<T: Reflect>(&mut self, name: &str) -> Option<&mut T> {
+        self.field_mut(name)
+            .and_then(|value| value.downcast_mut::<T>())
+    }
+}
+
+#[derive(Default)]
+pub struct DynamicStruct {
+    name: String,
+    fields: Vec<Box<dyn Reflect>>,
+    field_names: Vec<Cow<'static, str>>,
+    field_indices: HashMap<Cow<'static, str>, usize>,
+}
+
+impl DynamicStruct {
+    pub fn name(&self) -> &str {
+        &self.name
+    }
+
+    pub fn set_name(&mut self, name: String) {
+        self.name = name;
+    }
+
+    pub fn insert_boxed(&mut self, name: &str, value: Box<dyn Reflect>) {
+        let name = Cow::Owned(name.to_string());
+        match self.field_indices.entry(name) {
+            Entry::Occupied(entry) => {
+                self.fields[*entry.get()] = value;
+            }
+            Entry::Vacant(entry) => {
+                self.fields.push(value);
+                self.field_names.push(entry.key().clone());
+                entry.insert(self.fields.len() - 1);
+            }
+        }
+    }
+
+    pub fn insert<T: Reflect>(&mut self, name: &str, value: T) {
+        if let Some(index) = self.field_indices.get(name) {
+            self.fields[*index] = Box::new(value);
+        } else {
+            self.insert_boxed(name, Box::new(value));
+        }
+    }
+}
+
+impl Struct for DynamicStruct {
+    #[inline]
+    fn field(&self, name: &str) -> Option<&dyn Reflect> {
+        if let Some(index) = self.field_indices.get(name) {
+            Some(&*self.fields[*index])
+        } else {
+            None
+        }
+    }
+
+    #[inline]
+    fn field_mut(&mut self, name: &str) -> Option<&mut dyn Reflect> {
+        if let Some(index) = self.field_indices.get(name) {
+            Some(&mut *self.fields[*index])
+        } else {
+            None
+        }
+    }
+
+    #[inline]
+    fn field_at(&self, index: usize) -> Option<&dyn Reflect> {
+        self.fields.get(index).map(|value| &**value)
+    }
+
+    #[inline]
+    fn field_at_mut(&mut self, index: usize) -> Option<&mut dyn Reflect> {
+        self.fields.get_mut(index).map(|value| &mut **value)
+    }
+
+    #[inline]
+    fn name_at(&self, index: usize) -> Option<&str> {
+        self.field_names.get(index).map(|name| name.as_ref())
+    }
+
+    #[inline]
+    fn field_len(&self) -> usize {
+        self.fields.len()
+    }
+
+    #[inline]
+    fn iter_fields(&self) -> FieldIter {
+        FieldIter {
+            struct_val: self,
+            index: 0,
+        }
+    }
+
+    fn clone_dynamic(&self) -> DynamicStruct {
+        DynamicStruct {
+            name: self.name.clone(),
+            field_names: self.field_names.clone(),
+            field_indices: self.field_indices.clone(),
+            fields: self
+                .fields
+                .iter()
+                .map(|value| value.clone_value())
+                .collect(),
+        }
+    }
+}
+
+impl Reflect for DynamicStruct {
+    #[inline]
+    fn type_name(&self) -> &str {
+        &self.name
+    }
+
+    #[inline]
+    fn any(&self) -> &dyn Any {
+        self
+    }
+
+    #[inline]
+    fn any_mut(&mut self) -> &mut dyn Any {
+        self
+    }
+
+    #[inline]
+    fn clone_value(&self) -> Box<dyn Reflect> {
+        Box::new(self.clone_dynamic())
+    }
+
+    #[inline]
+    fn reflect_ref(&self) -> ReflectRef {
+        ReflectRef::Struct(self)
+    }
+
+    #[inline]
+    fn reflect_mut(&mut self) -> ReflectMut {
+        ReflectMut::Struct(self)
+    }
+
+    fn apply(&mut self, value: &dyn Reflect) {
+        if let ReflectRef::Struct(struct_value) = value.reflect_ref() {
+            for (i, value) in struct_value.iter_fields().enumerate() {
+                let name = struct_value.name_at(i).unwrap();
+                if let Some(v) = self.field_mut(name) {
+                    v.apply(value)
+                }
+            }
+        } else {
+            panic!("Attempted to apply non-struct type to struct type.");
+        }
+    }
+
+    fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>> {
+        *self = value.take()?;
+        Ok(())
+    }
+
+    fn reflect_hash(&self) -> Option<u64> {
+        None
+    }
+
+    fn reflect_partial_eq(&self, value: &dyn Reflect) -> Option<bool> {
+        struct_partial_eq(self, value)
+    }
+
+    fn serializable(&self) -> Option<Serializable> {
+        None
+    }
+}
+
+#[inline]
+pub fn struct_partial_eq<S: Struct>(a: &S, b: &dyn Reflect) -> Option<bool> {
+    let struct_value = if let ReflectRef::Struct(struct_value) = b.reflect_ref() {
+        struct_value
+    } else {
+        return Some(false);
+    };
+
+    if a.field_len() != struct_value.field_len() {
+        return Some(false);
+    }
+
+    for (i, value) in struct_value.iter_fields().enumerate() {
+        let name = struct_value.name_at(i).unwrap();
+        if let Some(field_value) = a.field(name) {
+            if let Some(false) | None = field_value.reflect_partial_eq(value) {
+                return Some(false);
+            }
+        } else {
+            return Some(false);
+        }
+    }
+
+    Some(true)
+}
diff --git a/crates/bevy_reflect/src/tuple_struct.rs b/crates/bevy_reflect/src/tuple_struct.rs
new file mode 100644
index 0000000000000..502d836f1c4e8
--- /dev/null
+++ b/crates/bevy_reflect/src/tuple_struct.rs
@@ -0,0 +1,210 @@
+use crate::{serde::Serializable, Reflect, ReflectMut, ReflectRef};
+use std::any::Any;
+
+/// A rust "tuple struct" reflection
+pub trait TupleStruct: Reflect {
+    fn field(&self, index: usize) -> Option<&dyn Reflect>;
+    fn field_mut(&mut self, index: usize) -> Option<&mut dyn Reflect>;
+    fn field_len(&self) -> usize;
+    fn iter_fields(&self) -> TupleStructFieldIter;
+    fn clone_dynamic(&self) -> DynamicTupleStruct;
+}
+
+pub struct TupleStructFieldIter<'a> {
+    pub(crate) tuple_struct: &'a dyn TupleStruct,
+    pub(crate) index: usize,
+}
+
+impl<'a> TupleStructFieldIter<'a> {
+    pub fn new(value: &'a dyn TupleStruct) -> Self {
+        TupleStructFieldIter {
+            tuple_struct: value,
+            index: 0,
+        }
+    }
+}
+
+impl<'a> Iterator for TupleStructFieldIter<'a> {
+    type Item = &'a dyn Reflect;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let value = self.tuple_struct.field(self.index);
+        self.index += 1;
+        value
+    }
+}
+
+pub trait GetTupleStructField {
+    fn get_field<T: Reflect>(&self, index: usize) -> Option<&T>;
+    fn get_field_mut<T: Reflect>(&mut self, index: usize) -> Option<&mut T>;
+}
+
+impl<S: TupleStruct> GetTupleStructField for S {
+    fn get_field<T: Reflect>(&self, index: usize) -> Option<&T> {
+        self.field(index)
+            .and_then(|value| value.downcast_ref::<T>())
+    }
+
+    fn get_field_mut<T: Reflect>(&mut self, index: usize) -> Option<&mut T> {
+        self.field_mut(index)
+            .and_then(|value| value.downcast_mut::<T>())
+    }
+}
+
+impl GetTupleStructField for dyn TupleStruct {
+    fn get_field<T: Reflect>(&self, index: usize) -> Option<&T> {
+        self.field(index)
+            .and_then(|value| value.downcast_ref::<T>())
+    }
+
+    fn get_field_mut<T: Reflect>(&mut self, index: usize) -> Option<&mut T> {
+        self.field_mut(index)
+            .and_then(|value| value.downcast_mut::<T>())
+    }
+}
+
+#[derive(Default)]
+pub struct DynamicTupleStruct {
+    name: String,
+    fields: Vec<Box<dyn Reflect>>,
+}
+
+impl DynamicTupleStruct {
+    pub fn name(&self) -> &str {
+        &self.name
+    }
+
+    pub fn set_name(&mut self, name: String) {
+        self.name = name;
+    }
+
+    pub fn insert_boxed(&mut self, value: Box<dyn Reflect>) {
+        self.fields.push(value);
+    }
+
+    pub fn insert<T: Reflect>(&mut self, value: T) {
+        self.insert_boxed(Box::new(value));
+    }
+}
+
+impl TupleStruct for DynamicTupleStruct {
+    #[inline]
+    fn field(&self, index: usize) -> Option<&dyn Reflect> {
+        self.fields.get(index).map(|field| &**field)
+    }
+
+    #[inline]
+    fn field_mut(&mut self, index: usize) -> Option<&mut dyn Reflect> {
+        self.fields.get_mut(index).map(|field| &mut **field)
+    }
+
+    #[inline]
+    fn field_len(&self) -> usize {
+        self.fields.len()
+    }
+
+    #[inline]
+    fn iter_fields(&self) -> TupleStructFieldIter {
+        TupleStructFieldIter {
+            tuple_struct: self,
+            index: 0,
+        }
+    }
+
+    fn clone_dynamic(&self) -> DynamicTupleStruct {
+        DynamicTupleStruct {
+            name: self.name.clone(),
+            fields: self
+                .fields
+                .iter()
+                .map(|value| value.clone_value())
+                .collect(),
+        }
+    }
+}
+
+impl Reflect for DynamicTupleStruct {
+    #[inline]
+    fn type_name(&self) -> &str {
+        std::any::type_name::<Self>()
+    }
+
+    #[inline]
+    fn any(&self) -> &dyn Any {
+        self
+    }
+
+    #[inline]
+    fn any_mut(&mut self) -> &mut dyn Any {
+        self
+    }
+
+    #[inline]
+    fn clone_value(&self) -> Box<dyn Reflect> {
+        Box::new(self.clone_dynamic())
+    }
+
+    #[inline]
+    fn reflect_ref(&self) -> ReflectRef {
+        ReflectRef::TupleStruct(self)
+    }
+
+    #[inline]
+    fn reflect_mut(&mut self) -> ReflectMut {
+        ReflectMut::TupleStruct(self)
+    }
+
+    fn apply(&mut self, value: &dyn Reflect) {
+        if let ReflectRef::TupleStruct(tuple_struct) = value.reflect_ref() {
+            for (i, value) in tuple_struct.iter_fields().enumerate() {
+                if let Some(v) = self.field_mut(i) {
+                    v.apply(value)
+                }
+            }
+        } else {
+            panic!("Attempted to apply non-TupleStruct type to TupleStruct type.");
+        }
+    }
+
+    fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>> {
+        *self = value.take()?;
+        Ok(())
+    }
+
+    fn reflect_hash(&self) -> Option<u64> {
+        None
+    }
+
+    fn reflect_partial_eq(&self, value: &dyn Reflect) -> Option<bool> {
+        tuple_struct_partial_eq(self, value)
+    }
+
+    fn serializable(&self) -> Option<Serializable> {
+        None
+    }
+}
+
+#[inline]
+pub fn tuple_struct_partial_eq<S: TupleStruct>(a: &S, b: &dyn Reflect) -> Option<bool> {
+    let tuple_struct = if let ReflectRef::TupleStruct(tuple_struct) = b.reflect_ref() {
+        tuple_struct
+    } else {
+        return Some(false);
+    };
+
+    if a.field_len() != tuple_struct.field_len() {
+        return Some(false);
+    }
+
+    for (i, value) in tuple_struct.iter_fields().enumerate() {
+        if let Some(field_value) = a.field(i) {
+            if let Some(false) | None = field_value.reflect_partial_eq(value) {
+                return Some(false);
+            }
+        } else {
+            return Some(false);
+        }
+    }
+
+    Some(true)
+}
diff --git a/crates/bevy_reflect/src/type_registry.rs b/crates/bevy_reflect/src/type_registry.rs
new file mode 100644
index 0000000000000..6fa39145b3540
--- /dev/null
+++ b/crates/bevy_reflect/src/type_registry.rs
@@ -0,0 +1,324 @@
+use crate::Reflect;
+use bevy_utils::{HashMap, HashSet};
+use downcast_rs::{impl_downcast, Downcast};
+use parking_lot::{RwLock, RwLockReadGuard, RwLockWriteGuard};
+use serde::Deserialize;
+use std::{any::TypeId, fmt::Debug, sync::Arc};
+
+#[derive(Default)]
+pub struct TypeRegistry {
+    registrations: HashMap<TypeId, TypeRegistration>,
+    short_name_to_id: HashMap<String, TypeId>,
+    full_name_to_id: HashMap<String, TypeId>,
+    ambiguous_names: HashSet<String>,
+}
+
+// TODO:  remove this wrapper once we migrate to Atelier Assets and the Scene AssetLoader doesn't need a TypeRegistry ref
+#[derive(Clone, Default)]
+pub struct TypeRegistryArc {
+    pub internal: Arc<RwLock<TypeRegistry>>,
+}
+
+impl Debug for TypeRegistryArc {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.internal.read().full_name_to_id.keys().fmt(f)
+    }
+}
+
+pub trait GetTypeRegistration {
+    fn get_type_registration() -> TypeRegistration;
+}
+
+impl TypeRegistry {
+    pub fn register<T>(&mut self)
+    where
+        T: GetTypeRegistration,
+    {
+        self.add_registration(T::get_type_registration());
+    }
+
+    pub fn add_registration(&mut self, registration: TypeRegistration) {
+        let short_name = registration.short_name.to_string();
+        if self.short_name_to_id.contains_key(&short_name)
+            || self.ambiguous_names.contains(&short_name)
+        {
+            // name is ambiguous. fall back to long names for all ambiguous types
+            self.short_name_to_id.remove(&short_name);
+            self.ambiguous_names.insert(short_name);
+        } else {
+            self.short_name_to_id
+                .insert(short_name, registration.type_id);
+        }
+        self.full_name_to_id
+            .insert(registration.name.to_string(), registration.type_id);
+        self.registrations
+            .insert(registration.type_id, registration);
+    }
+
+    pub fn get(&self, type_id: TypeId) -> Option<&TypeRegistration> {
+        self.registrations.get(&type_id)
+    }
+
+    pub fn get_mut(&mut self, type_id: TypeId) -> Option<&mut TypeRegistration> {
+        self.registrations.get_mut(&type_id)
+    }
+
+    pub fn get_with_name(&self, type_name: &str) -> Option<&TypeRegistration> {
+        self.full_name_to_id
+            .get(type_name)
+            .and_then(|id| self.get(*id))
+    }
+
+    pub fn get_with_name_mut(&mut self, type_name: &str) -> Option<&mut TypeRegistration> {
+        self.full_name_to_id
+            .get(type_name)
+            .cloned()
+            .and_then(move |id| self.get_mut(id))
+    }
+
+    pub fn get_with_short_name(&self, short_type_name: &str) -> Option<&TypeRegistration> {
+        self.short_name_to_id
+            .get(short_type_name)
+            .and_then(|id| self.registrations.get(id))
+    }
+
+    pub fn get_type_data<T: TypeData>(&self, type_id: TypeId) -> Option<&T> {
+        self.get(type_id)
+            .and_then(|registration| registration.data::<T>())
+    }
+
+    pub fn iter(&self) -> impl Iterator<Item = &TypeRegistration> {
+        self.registrations.values()
+    }
+}
+
+impl TypeRegistryArc {
+    pub fn read(&self) -> RwLockReadGuard<'_, TypeRegistry> {
+        self.internal.read()
+    }
+
+    pub fn write(&self) -> RwLockWriteGuard<'_, TypeRegistry> {
+        self.internal.write()
+    }
+}
+
+pub struct TypeRegistration {
+    type_id: TypeId,
+    short_name: String,
+    name: &'static str,
+    data: HashMap<TypeId, Box<dyn TypeData>>,
+}
+
+impl TypeRegistration {
+    #[inline]
+    pub fn type_id(&self) -> TypeId {
+        self.type_id
+    }
+
+    pub fn data<T: TypeData>(&self) -> Option<&T> {
+        self.data
+            .get(&TypeId::of::<T>())
+            .and_then(|value| value.downcast_ref())
+    }
+
+    pub fn data_mut<T: TypeData>(&mut self) -> Option<&mut T> {
+        self.data
+            .get_mut(&TypeId::of::<T>())
+            .and_then(|value| value.downcast_mut())
+    }
+
+    pub fn insert<T: TypeData>(&mut self, data: T) {
+        self.data.insert(TypeId::of::<T>(), Box::new(data));
+    }
+
+    pub fn of<T: Reflect>() -> Self {
+        let ty = TypeId::of::<T>();
+        let type_name = std::any::type_name::<T>();
+        Self {
+            type_id: ty,
+            data: HashMap::default(),
+            name: type_name,
+            short_name: Self::get_short_name(type_name),
+        }
+    }
+
+    pub fn short_name(&self) -> &str {
+        &self.short_name
+    }
+
+    pub fn name(&self) -> &'static str {
+        self.name
+    }
+
+    fn get_short_name(full_name: &str) -> String {
+        let mut short_name = String::new();
+
+        {
+            // A typename may be a composition of several other type names (e.g. generic parameters)
+            // separated by the characters that we try to find below.
+            // Then, each individual typename is shortened to its last path component.
+            //
+            // Note: Instead of `find`, `split_inclusive` would be nice but it's still unstable...
+            let mut remainder = full_name;
+            while let Some(index) = remainder.find(&['<', '>', '(', ')', '[', ']', ',', ';'][..]) {
+                let (path, new_remainder) = remainder.split_at(index);
+                // Push the shortened path in front of the found character
+                short_name.push_str(path.rsplit(':').next().unwrap());
+                // Push the character that was found
+                let character = new_remainder.chars().next().unwrap();
+                short_name.push(character);
+                // Advance the remainder
+                if character == ',' || character == ';' {
+                    // A comma or semicolon is always followed by a space
+                    short_name.push(' ');
+                    remainder = &new_remainder[2..];
+                } else {
+                    remainder = &new_remainder[1..];
+                }
+            }
+
+            // The remainder will only be non-empty if there were no matches at all
+            if !remainder.is_empty() {
+                // Then, the full typename is a path that has to be shortened
+                short_name.push_str(remainder.rsplit(':').next().unwrap());
+            }
+        }
+
+        short_name
+    }
+}
+
+impl Clone for TypeRegistration {
+    fn clone(&self) -> Self {
+        let mut data = HashMap::default();
+        for (id, type_data) in self.data.iter() {
+            data.insert(*id, (*type_data).clone_type_data());
+        }
+
+        TypeRegistration {
+            data,
+            name: self.name,
+            short_name: self.short_name.clone(),
+            type_id: self.type_id,
+        }
+    }
+}
+
+pub trait TypeData: Downcast + Send + Sync {
+    fn clone_type_data(&self) -> Box<dyn TypeData>;
+}
+impl_downcast!(TypeData);
+
+impl<T: 'static + Send + Sync> TypeData for T
+where
+    T: Clone,
+{
+    fn clone_type_data(&self) -> Box<dyn TypeData> {
+        Box::new(self.clone())
+    }
+}
+
+pub trait FromType<T> {
+    fn from_type() -> Self;
+}
+
+#[derive(Clone)]
+pub struct ReflectDeserialize {
+    pub func: fn(
+        deserializer: &mut dyn erased_serde::Deserializer,
+    ) -> Result<Box<dyn Reflect>, erased_serde::Error>,
+}
+
+impl ReflectDeserialize {
+    pub fn deserialize<'de, D>(&self, deserializer: D) -> Result<Box<dyn Reflect>, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let mut erased = erased_serde::Deserializer::erase(deserializer);
+        (self.func)(&mut erased)
+            .map_err(<<D as serde::Deserializer<'de>>::Error as serde::de::Error>::custom)
+    }
+}
+
+impl<T: for<'a> Deserialize<'a> + Reflect> FromType<T> for ReflectDeserialize {
+    fn from_type() -> Self {
+        ReflectDeserialize {
+            func: |deserializer| Ok(Box::new(T::deserialize(deserializer)?)),
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::TypeRegistration;
+
+    #[test]
+    fn test_get_short_name() {
+        assert_eq!(
+            TypeRegistration::get_short_name(std::any::type_name::<f64>()),
+            "f64"
+        );
+        assert_eq!(
+            TypeRegistration::get_short_name(std::any::type_name::<String>()),
+            "String"
+        );
+        assert_eq!(
+            TypeRegistration::get_short_name(std::any::type_name::<(u32, f64)>()),
+            "(u32, f64)"
+        );
+        assert_eq!(
+            TypeRegistration::get_short_name(std::any::type_name::<(String, String)>()),
+            "(String, String)"
+        );
+        assert_eq!(
+            TypeRegistration::get_short_name(std::any::type_name::<[f64]>()),
+            "[f64]"
+        );
+        assert_eq!(
+            TypeRegistration::get_short_name(std::any::type_name::<[String]>()),
+            "[String]"
+        );
+        assert_eq!(
+            TypeRegistration::get_short_name(std::any::type_name::<[f64; 16]>()),
+            "[f64; 16]"
+        );
+        assert_eq!(
+            TypeRegistration::get_short_name(std::any::type_name::<[String; 16]>()),
+            "[String; 16]"
+        );
+    }
+
+    // TODO: re-enable
+    // #[test]
+    // fn test_property_type_registration() {
+    //     assert_eq!(
+    //         TypeRegistration::of::<Option<f64>>().short_name,
+    //         "Option<f64>"
+    //     );
+    //     assert_eq!(
+    //         TypeRegistration::of::<HashMap<u32, String>>().short_name,
+    //         "HashMap<u32, String>"
+    //     );
+    //     assert_eq!(
+    //         TypeRegistration::of::<Option<HashMap<u32, String>>>().short_name,
+    //         "Option<HashMap<u32, String>>"
+    //     );
+    //     assert_eq!(
+    //         TypeRegistration::of::<Option<HashMap<u32, Option<String>>>>().short_name,
+    //         "Option<HashMap<u32, Option<String>>>"
+    //     );
+    //     assert_eq!(
+    //         TypeRegistration::of::<Option<HashMap<String, Option<String>>>>().short_name,
+    //         "Option<HashMap<String, Option<String>>>"
+    //     );
+    //     assert_eq!(
+    //         TypeRegistration::of::<Option<HashMap<Option<String>, Option<String>>>>().short_name,
+    //         "Option<HashMap<Option<String>, Option<String>>>"
+    //     );
+    //     assert_eq!(
+    //         TypeRegistration::of::<Option<HashMap<Option<String>, (String, Option<String>)>>>()
+    //             .short_name,
+    //         "Option<HashMap<Option<String>, (String, Option<String>)>>"
+    //     );
+    // }
+}
diff --git a/crates/bevy_type_registry/src/type_uuid.rs b/crates/bevy_reflect/src/type_uuid.rs
similarity index 78%
rename from crates/bevy_type_registry/src/type_uuid.rs
rename to crates/bevy_reflect/src/type_uuid.rs
index 28d53c3a34e28..e786b51467239 100644
--- a/crates/bevy_type_registry/src/type_uuid.rs
+++ b/crates/bevy_reflect/src/type_uuid.rs
@@ -1,5 +1,5 @@
-pub use bevy_derive::TypeUuid;
-use uuid::Uuid;
+pub use bevy_reflect_derive::TypeUuid;
+pub use bevy_utils::Uuid;
 
 pub trait TypeUuid {
     const TYPE_UUID: Uuid;
diff --git a/crates/bevy_render/Cargo.toml b/crates/bevy_render/Cargo.toml
index ceb74c1cd4e13..6321bee69f814 100644
--- a/crates/bevy_render/Cargo.toml
+++ b/crates/bevy_render/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_render"
-version = "0.3.0"
+version = "0.4.0"
 edition = "2018"
 authors = [
     "Bevy Contributors <bevyengine@gmail.com>",
@@ -14,23 +14,21 @@ keywords = ["bevy"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.3.0" }
-bevy_asset = { path = "../bevy_asset", version = "0.3.0" }
-bevy_core = { path = "../bevy_core", version = "0.3.0" }
-bevy_derive = { path = "../bevy_derive", version = "0.3.0" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.3.0" }
-bevy_math = { path = "../bevy_math", version = "0.3.0" }
-bevy_property = { path = "../bevy_property", version = "0.3.0" }
-bevy_transform = { path = "../bevy_transform", version = "0.3.0" }
-bevy_type_registry = { path = "../bevy_type_registry", version = "0.3.0" }
-bevy_window = { path = "../bevy_window", version = "0.3.0" }
-bevy_utils = { path = "../bevy_utils", version = "0.3.0" }
+bevy_app = { path = "../bevy_app", version = "0.4.0" }
+bevy_asset = { path = "../bevy_asset", version = "0.4.0" }
+bevy_core = { path = "../bevy_core", version = "0.4.0" }
+bevy_derive = { path = "../bevy_derive", version = "0.4.0" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.4.0" }
+bevy_math = { path = "../bevy_math", version = "0.4.0" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.4.0", features = ["bevy"] }
+bevy_transform = { path = "../bevy_transform", version = "0.4.0" }
+bevy_window = { path = "../bevy_window", version = "0.4.0" }
+bevy_utils = { path = "../bevy_utils", version = "0.4.0" }
 
 # rendering
 image = { version = "0.23.12", default-features = false }
 
 # misc
-uuid = { version = "0.8", features = ["v4", "serde"] }
 serde = { version = "1", features = ["derive"] }
 bitflags = "1.2.1"
 smallvec = "1.4.2"
@@ -40,18 +38,21 @@ downcast-rs = "1.2.0"
 thiserror = "1.0"
 anyhow = "1.0"
 hex = "0.4.2"
-hexasphere = "2.0.0"
+hexasphere = "3.1"
 parking_lot = "0.11.0"
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 spirv-reflect = "0.2.3"
 
-[target.'cfg(all(not(target_os = "ios"), not(target_arch = "wasm32")))'.dependencies]
+[target.'cfg(all(not(target_os = "ios"), not(target_arch = "wasm32"), not(all(target_arch = "aarch64", target_os = "macos"))))'.dependencies]
 bevy-glsl-to-spirv = "0.2.0"
 
-[target.'cfg(target_os = "ios")'.dependencies]
-shaderc = "0.6.3"
+[target.'cfg(any(target_os = "ios", all(target_arch = "aarch64", target_os = "macos")))'.dependencies]
+shaderc = "0.7.0"
 
 [features]
 png = ["image/png"]
 hdr = ["image/hdr"]
+dds = ["image/dds"]
+tga = ["image/tga"]
+jpeg = ["image/jpeg"]
diff --git a/crates/bevy_render/src/camera/camera.rs b/crates/bevy_render/src/camera/camera.rs
index becec6b88cc3f..22fd64a960b74 100644
--- a/crates/bevy_render/src/camera/camera.rs
+++ b/crates/bevy_render/src/camera/camera.rs
@@ -2,16 +2,17 @@ use super::CameraProjection;
 use bevy_app::prelude::{EventReader, Events};
 use bevy_ecs::{Added, Component, Entity, Local, Query, QuerySet, Res};
 use bevy_math::Mat4;
-use bevy_property::Properties;
+use bevy_reflect::{Reflect, ReflectComponent};
 use bevy_window::{WindowCreated, WindowId, WindowResized, Windows};
 
-#[derive(Default, Debug, Properties)]
+#[derive(Default, Debug, Reflect)]
+#[reflect(Component)]
 pub struct Camera {
     pub projection_matrix: Mat4,
     pub name: Option<String>,
-    #[property(ignore)]
+    #[reflect(ignore)]
     pub window: WindowId,
-    #[property(ignore)]
+    #[reflect(ignore)]
     pub depth_calculation: DepthCalculation,
 }
 
@@ -77,7 +78,7 @@ pub fn camera_system<T: CameraProjection + Component>(
     for (entity, mut camera, mut camera_projection) in queries.q0_mut().iter_mut() {
         if let Some(window) = windows.get(camera.window) {
             if changed_window_ids.contains(&window.id()) || added_cameras.contains(&entity) {
-                camera_projection.update(window.width() as usize, window.height() as usize);
+                camera_projection.update(window.width(), window.height());
                 camera.projection_matrix = camera_projection.get_projection_matrix();
                 camera.depth_calculation = camera_projection.depth_calculation();
             }
diff --git a/crates/bevy_render/src/camera/projection.rs b/crates/bevy_render/src/camera/projection.rs
index f560045217675..7e9e8a4ab6cfa 100644
--- a/crates/bevy_render/src/camera/projection.rs
+++ b/crates/bevy_render/src/camera/projection.rs
@@ -1,15 +1,16 @@
 use super::DepthCalculation;
 use bevy_math::Mat4;
-use bevy_property::{Properties, Property};
+use bevy_reflect::{Reflect, ReflectComponent, ReflectDeserialize};
 use serde::{Deserialize, Serialize};
 
 pub trait CameraProjection {
     fn get_projection_matrix(&self) -> Mat4;
-    fn update(&mut self, width: usize, height: usize);
+    fn update(&mut self, width: f32, height: f32);
     fn depth_calculation(&self) -> DepthCalculation;
 }
 
-#[derive(Debug, Clone, Properties)]
+#[derive(Debug, Clone, Reflect)]
+#[reflect(Component)]
 pub struct PerspectiveProjection {
     pub fov: f32,
     pub aspect_ratio: f32,
@@ -22,8 +23,8 @@ impl CameraProjection for PerspectiveProjection {
         Mat4::perspective_rh(self.fov, self.aspect_ratio, self.near, self.far)
     }
 
-    fn update(&mut self, width: usize, height: usize) {
-        self.aspect_ratio = width as f32 / height as f32;
+    fn update(&mut self, width: f32, height: f32) {
+        self.aspect_ratio = width / height;
     }
 
     fn depth_calculation(&self) -> DepthCalculation {
@@ -43,13 +44,15 @@ impl Default for PerspectiveProjection {
 }
 
 // TODO: make this a component instead of a property
-#[derive(Debug, Clone, Property, Serialize, Deserialize)]
+#[derive(Debug, Clone, Reflect, Serialize, Deserialize)]
+#[reflect_value(Serialize, Deserialize)]
 pub enum WindowOrigin {
     Center,
     BottomLeft,
 }
 
-#[derive(Debug, Clone, Properties)]
+#[derive(Debug, Clone, Reflect)]
+#[reflect(Component)]
 pub struct OrthographicProjection {
     pub left: f32,
     pub right: f32,
@@ -72,11 +75,11 @@ impl CameraProjection for OrthographicProjection {
         )
     }
 
-    fn update(&mut self, width: usize, height: usize) {
+    fn update(&mut self, width: f32, height: f32) {
         match self.window_origin {
             WindowOrigin::Center => {
-                let half_width = width as f32 / 2.0;
-                let half_height = height as f32 / 2.0;
+                let half_width = width / 2.0;
+                let half_height = height / 2.0;
                 self.left = -half_width;
                 self.right = half_width;
                 self.top = half_height;
@@ -84,8 +87,8 @@ impl CameraProjection for OrthographicProjection {
             }
             WindowOrigin::BottomLeft => {
                 self.left = 0.0;
-                self.right = width as f32;
-                self.top = height as f32;
+                self.right = width;
+                self.top = height;
                 self.bottom = 0.0;
             }
         }
diff --git a/crates/bevy_render/src/camera/visible_entities.rs b/crates/bevy_render/src/camera/visible_entities.rs
index 7a79e469bb1d8..e1d54bc1c40ad 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::Draw;
+use crate::prelude::Visible;
 use bevy_core::FloatOrd;
 use bevy_ecs::{Entity, Query, With};
-use bevy_property::Properties;
+use bevy_reflect::{Reflect, ReflectComponent};
 use bevy_transform::prelude::GlobalTransform;
 
 #[derive(Debug)]
@@ -11,9 +11,10 @@ pub struct VisibleEntity {
     pub order: FloatOrd,
 }
 
-#[derive(Default, Debug, Properties)]
+#[derive(Default, Debug, Reflect)]
+#[reflect(Component)]
 pub struct VisibleEntities {
-    #[property(ignore)]
+    #[reflect(ignore)]
     pub value: Vec<VisibleEntity>,
 }
 
@@ -25,8 +26,8 @@ impl VisibleEntities {
 
 pub fn visible_entities_system(
     mut camera_query: Query<(&Camera, &GlobalTransform, &mut VisibleEntities)>,
-    draw_query: Query<(Entity, &Draw)>,
-    draw_transform_query: Query<&GlobalTransform, With<Draw>>,
+    visible_query: Query<(Entity, &Visible)>,
+    visible_transform_query: Query<&GlobalTransform, With<Visible>>,
 ) {
     for (camera, camera_global_transform, mut visible_entities) in camera_query.iter_mut() {
         visible_entities.value.clear();
@@ -34,12 +35,12 @@ pub fn visible_entities_system(
 
         let mut no_transform_order = 0.0;
         let mut transparent_entities = Vec::new();
-        for (entity, draw) in draw_query.iter() {
-            if !draw.is_visible {
+        for (entity, visible) in visible_query.iter() {
+            if !visible.is_visible {
                 continue;
             }
 
-            let order = if let Ok(global_transform) = draw_transform_query.get(entity) {
+            let order = if let Ok(global_transform) = visible_transform_query.get(entity) {
                 let position = global_transform.translation;
                 // smaller distances are sorted to lower indices by using the distance from the camera
                 FloatOrd(match camera.depth_calculation {
@@ -52,7 +53,7 @@ pub fn visible_entities_system(
                 order
             };
 
-            if draw.is_transparent {
+            if visible.is_transparent {
                 transparent_entities.push(VisibleEntity { entity, order })
             } else {
                 visible_entities.value.push(VisibleEntity { entity, order })
diff --git a/crates/bevy_render/src/color.rs b/crates/bevy_render/src/color.rs
index 640e44efe76e1..cfa52adc560f6 100644
--- a/crates/bevy_render/src/color.rs
+++ b/crates/bevy_render/src/color.rs
@@ -7,7 +7,7 @@ use crate::{
 use bevy_asset::Handle;
 use bevy_core::{Byteable, Bytes};
 use bevy_math::{Vec3, Vec4};
-use bevy_property::Property;
+use bevy_reflect::Reflect;
 use serde::{Deserialize, Serialize};
 use std::ops::{Add, AddAssign, Mul, MulAssign};
 
@@ -15,7 +15,7 @@ use std::ops::{Add, AddAssign, Mul, MulAssign};
 // see comment on bevy issue #688 https://github.com/bevyengine/bevy/pull/688#issuecomment-711414011
 /// RGBA color in the Linear sRGB colorspace (often colloquially referred to as "linear", "RGB", or "linear RGB").
 #[repr(C)]
-#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize, Property)]
+#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize, Reflect)]
 pub struct Color {
     red: f32,
     green: f32,
diff --git a/crates/bevy_render/src/colorspace.rs b/crates/bevy_render/src/colorspace.rs
index 3f789b25d4b9c..28a1a5249f95a 100644
--- a/crates/bevy_render/src/colorspace.rs
+++ b/crates/bevy_render/src/colorspace.rs
@@ -1,5 +1,3 @@
-// sRGB
-//==================================================================================================
 pub trait SrgbColorSpace {
     fn linear_to_nonlinear_srgb(self) -> Self;
     fn nonlinear_to_linear_srgb(self) -> Self;
@@ -47,4 +45,3 @@ fn test_srgb_full_roundtrip() {
         );
     }
 }
-//==================================================================================================
diff --git a/crates/bevy_render/src/draw.rs b/crates/bevy_render/src/draw.rs
index 67bb4c9e0a952..0da2b9e67cab0 100644
--- a/crates/bevy_render/src/draw.rs
+++ b/crates/bevy_render/src/draw.rs
@@ -1,14 +1,14 @@
 use crate::{
     pipeline::{PipelineCompiler, PipelineDescriptor, PipelineLayout, PipelineSpecialization},
     renderer::{
-        BindGroup, BindGroupId, BufferId, BufferUsage, RenderResource, RenderResourceBinding,
-        RenderResourceBindings, RenderResourceContext, SharedBuffers,
+        AssetRenderResourceBindings, BindGroup, BindGroupId, BufferId, RenderResource,
+        RenderResourceBinding, RenderResourceBindings, RenderResourceContext, SharedBuffers,
     },
     shader::Shader,
 };
-use bevy_asset::{Assets, Handle};
+use bevy_asset::{Asset, Assets, Handle};
 use bevy_ecs::{Query, Res, ResMut, SystemParam};
-use bevy_property::Properties;
+use bevy_reflect::{Reflect, ReflectComponent};
 use std::{ops::Range, sync::Arc};
 use thiserror::Error;
 
@@ -43,20 +43,34 @@ pub enum RenderCommand {
     },
 }
 
-/// A component that indicates how to draw an entity.
-#[derive(Debug, Properties, Clone)]
-pub struct Draw {
+#[derive(Debug, Clone, Reflect)]
+#[reflect(Component)]
+pub struct Visible {
     pub is_visible: bool,
+    // TODO: consider moving this to materials
     pub is_transparent: bool,
-    #[property(ignore)]
+}
+
+impl Default for Visible {
+    fn default() -> Self {
+        Visible {
+            is_visible: true,
+            is_transparent: false,
+        }
+    }
+}
+
+/// A component that indicates how to draw an entity.
+#[derive(Debug, Clone, Reflect)]
+#[reflect(Component)]
+pub struct Draw {
+    #[reflect(ignore)]
     pub render_commands: Vec<RenderCommand>,
 }
 
 impl Default for Draw {
     fn default() -> Self {
         Self {
-            is_visible: true,
-            is_transparent: false,
             render_commands: Default::default(),
         }
     }
@@ -109,45 +123,37 @@ impl Draw {
 
 #[derive(Debug, Error)]
 pub enum DrawError {
-    #[error("Pipeline does not exist.")]
+    #[error("pipeline does not exist")]
     NonExistentPipeline,
-    #[error("No pipeline set")]
+    #[error("no pipeline set")]
     NoPipelineSet,
-    #[error("Pipeline has no layout")]
+    #[error("pipeline has no layout")]
     PipelineHasNoLayout,
-    #[error("Failed to get a buffer for the given RenderResource.")]
+    #[error("failed to get a buffer for the given `RenderResource`")]
     BufferAllocationFailure,
+    #[error("the given asset does not have any render resources")]
+    MissingAssetRenderResources,
 }
 
 #[derive(SystemParam)]
 pub struct DrawContext<'a> {
     pub pipelines: ResMut<'a, Assets<PipelineDescriptor>>,
     pub shaders: ResMut<'a, Assets<Shader>>,
+    pub asset_render_resource_bindings: ResMut<'a, AssetRenderResourceBindings>,
     pub pipeline_compiler: ResMut<'a, PipelineCompiler>,
     pub render_resource_context: Res<'a, Box<dyn RenderResourceContext>>,
-    pub shared_buffers: Res<'a, SharedBuffers>,
+    pub shared_buffers: ResMut<'a, SharedBuffers>,
     #[system_param(ignore)]
     pub current_pipeline: Option<Handle<PipelineDescriptor>>,
 }
 
-#[derive(Debug)]
-pub struct FetchDrawContext;
-
 impl<'a> DrawContext<'a> {
     pub fn get_uniform_buffer<T: RenderResource>(
-        &self,
-        render_resource: &T,
-    ) -> Result<RenderResourceBinding, DrawError> {
-        self.get_buffer(render_resource, BufferUsage::UNIFORM)
-    }
-
-    pub fn get_buffer<T: RenderResource>(
-        &self,
+        &mut self,
         render_resource: &T,
-        buffer_usage: BufferUsage,
     ) -> Result<RenderResourceBinding, DrawError> {
         self.shared_buffers
-            .get_buffer(render_resource, buffer_usage)
+            .get_uniform_buffer(&**self.render_resource_context, render_resource)
             .ok_or(DrawError::BufferAllocationFailure)
     }
 
@@ -192,32 +198,91 @@ impl<'a> DrawContext<'a> {
         })
     }
 
+    pub fn set_asset_bind_groups<T: Asset>(
+        &mut self,
+        draw: &mut Draw,
+        asset_handle: &Handle<T>,
+    ) -> Result<(), DrawError> {
+        if let Some(asset_bindings) = self
+            .asset_render_resource_bindings
+            .get_mut_untyped(&asset_handle.clone_weak_untyped())
+        {
+            Self::set_bind_groups_from_bindings_internal(
+                &self.current_pipeline,
+                &self.pipelines,
+                &**self.render_resource_context,
+                None,
+                draw,
+                &mut [asset_bindings],
+            )
+        } else {
+            Err(DrawError::MissingAssetRenderResources)
+        }
+    }
+
     pub fn set_bind_groups_from_bindings(
-        &self,
+        &mut self,
         draw: &mut Draw,
         render_resource_bindings: &mut [&mut RenderResourceBindings],
     ) -> Result<(), DrawError> {
-        let pipeline = self
-            .current_pipeline
-            .as_ref()
-            .ok_or(DrawError::NoPipelineSet)?;
-        let pipeline_descriptor = self
-            .pipelines
+        Self::set_bind_groups_from_bindings_internal(
+            &self.current_pipeline,
+            &self.pipelines,
+            &**self.render_resource_context,
+            Some(&mut self.asset_render_resource_bindings),
+            draw,
+            render_resource_bindings,
+        )
+    }
+
+    fn set_bind_groups_from_bindings_internal(
+        current_pipeline: &Option<Handle<PipelineDescriptor>>,
+        pipelines: &Assets<PipelineDescriptor>,
+        render_resource_context: &dyn RenderResourceContext,
+        mut asset_render_resource_bindings: Option<&mut AssetRenderResourceBindings>,
+        draw: &mut Draw,
+        render_resource_bindings: &mut [&mut RenderResourceBindings],
+    ) -> Result<(), DrawError> {
+        let pipeline = current_pipeline.as_ref().ok_or(DrawError::NoPipelineSet)?;
+        let pipeline_descriptor = pipelines
             .get(pipeline)
             .ok_or(DrawError::NonExistentPipeline)?;
         let layout = pipeline_descriptor
             .get_layout()
             .ok_or(DrawError::PipelineHasNoLayout)?;
-        for bindings in render_resource_bindings.iter_mut() {
-            bindings.update_bind_groups(pipeline_descriptor, &**self.render_resource_context);
-        }
-        for bind_group_descriptor in layout.bind_groups.iter() {
+        'bind_group_descriptors: for bind_group_descriptor in layout.bind_groups.iter() {
             for bindings in render_resource_bindings.iter_mut() {
                 if let Some(bind_group) =
-                    bindings.get_descriptor_bind_group(bind_group_descriptor.id)
+                    bindings.update_bind_group(bind_group_descriptor, render_resource_context)
                 {
                     draw.set_bind_group(bind_group_descriptor.index, bind_group);
-                    break;
+                    continue 'bind_group_descriptors;
+                }
+            }
+
+            // if none of the given RenderResourceBindings have the current bind group, try their assets
+            let asset_render_resource_bindings =
+                if let Some(value) = asset_render_resource_bindings.as_mut() {
+                    value
+                } else {
+                    continue 'bind_group_descriptors;
+                };
+            for bindings in render_resource_bindings.iter_mut() {
+                for (asset_handle, _) in bindings.iter_assets() {
+                    let asset_bindings = if let Some(asset_bindings) =
+                        asset_render_resource_bindings.get_mut_untyped(asset_handle)
+                    {
+                        asset_bindings
+                    } else {
+                        continue;
+                    };
+
+                    if let Some(bind_group) = asset_bindings
+                        .update_bind_group(bind_group_descriptor, render_resource_context)
+                    {
+                        draw.set_bind_group(bind_group_descriptor.index, bind_group);
+                        continue 'bind_group_descriptors;
+                    }
                 }
             }
         }
diff --git a/crates/bevy_render/src/entity.rs b/crates/bevy_render/src/entity.rs
index efc65ca7c97ab..c8837d39c36c0 100644
--- a/crates/bevy_render/src/entity.rs
+++ b/crates/bevy_render/src/entity.rs
@@ -1,6 +1,7 @@
 use crate::{
     camera::{Camera, OrthographicProjection, PerspectiveProjection, VisibleEntities},
     pipeline::RenderPipelines,
+    prelude::Visible,
     render_graph::base,
     Draw, Mesh,
 };
@@ -15,6 +16,7 @@ use bevy_transform::components::{GlobalTransform, Transform};
 pub struct MeshBundle {
     pub mesh: Handle<Mesh>,
     pub draw: Draw,
+    pub visible: Visible,
     pub render_pipelines: RenderPipelines,
     pub main_pass: MainPass,
     pub transform: Transform,
@@ -35,7 +37,7 @@ impl Default for Camera3dBundle {
     fn default() -> Self {
         Camera3dBundle {
             camera: Camera {
-                name: Some(base::camera::CAMERA3D.to_string()),
+                name: Some(base::camera::CAMERA_3D.to_string()),
                 ..Default::default()
             },
             perspective_projection: Default::default(),
@@ -63,7 +65,7 @@ impl Default for Camera2dBundle {
         let far = 1000.0;
         Camera2dBundle {
             camera: Camera {
-                name: Some(base::camera::CAMERA2D.to_string()),
+                name: Some(base::camera::CAMERA_2D.to_string()),
                 ..Default::default()
             },
             orthographic_projection: OrthographicProjection {
diff --git a/crates/bevy_render/src/lib.rs b/crates/bevy_render/src/lib.rs
index fc3937ef448cc..c158d53824917 100644
--- a/crates/bevy_render/src/lib.rs
+++ b/crates/bevy_render/src/lib.rs
@@ -11,14 +11,16 @@ pub mod renderer;
 pub mod shader;
 pub mod texture;
 
-use bevy_type_registry::RegisterType;
+use bevy_ecs::{IntoSystem, SystemStage};
+use bevy_reflect::RegisterTypeBuilder;
+use draw::Visible;
 pub use once_cell;
 
 pub mod prelude {
     pub use crate::{
         base::Msaa,
         color::Color,
-        draw::Draw,
+        draw::{Draw, Visible},
         entity::*,
         mesh::{shape, Mesh},
         pass::ClearColor,
@@ -29,7 +31,7 @@ pub mod prelude {
 }
 
 use crate::prelude::*;
-use base::{MainPass, Msaa};
+use base::Msaa;
 use bevy_app::prelude::*;
 use bevy_asset::AddAsset;
 use camera::{
@@ -40,11 +42,11 @@ use pipeline::{
     ShaderSpecialization,
 };
 use render_graph::{
-    base::{self, BaseRenderGraphBuilder, BaseRenderGraphConfig},
+    base::{self, BaseRenderGraphBuilder, BaseRenderGraphConfig, MainPass},
     RenderGraph,
 };
 use renderer::{AssetRenderResourceBindings, RenderResourceBindings};
-use std::ops::Range;
+use shader::ShaderLoader;
 #[cfg(feature = "hdr")]
 use texture::HdrTextureLoader;
 #[cfg(feature = "png")]
@@ -88,62 +90,94 @@ 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(bevy_asset::stage::ASSET_EVENTS, stage::RENDER_RESOURCE)
-            .add_stage_after(stage::RENDER_RESOURCE, stage::RENDER_GRAPH_SYSTEMS)
-            .add_stage_after(stage::RENDER_GRAPH_SYSTEMS, stage::DRAW)
-            .add_stage_after(stage::DRAW, stage::RENDER)
-            .add_stage_after(stage::RENDER, stage::POST_RENDER)
-            .add_asset::<Mesh>()
-            .add_asset::<Texture>()
-            .add_asset::<Shader>()
-            .add_asset::<PipelineDescriptor>()
-            .register_component::<Camera>()
-            .register_component::<Draw>()
-            .register_component::<RenderPipelines>()
-            .register_component::<OrthographicProjection>()
-            .register_component::<PerspectiveProjection>()
-            .register_component::<MainPass>()
-            .register_component::<VisibleEntities>()
-            .register_property::<Color>()
-            .register_property::<Range<f32>>()
-            .register_property::<ShaderSpecialization>()
-            .register_property::<PrimitiveTopology>()
-            .register_property::<IndexFormat>()
-            .register_properties::<PipelineSpecialization>()
-            .init_resource::<RenderGraph>()
-            .init_resource::<PipelineCompiler>()
-            .init_resource::<RenderResourceBindings>()
-            .init_resource::<TextureResourceSystemState>()
-            .init_resource::<AssetRenderResourceBindings>()
-            .init_resource::<ActiveCameras>()
-            .add_system_to_stage(bevy_app::stage::PRE_UPDATE, draw::clear_draw_system)
-            .add_system_to_stage(bevy_app::stage::POST_UPDATE, camera::active_cameras_system)
-            .add_system_to_stage(
-                bevy_app::stage::POST_UPDATE,
-                camera::camera_system::<OrthographicProjection>,
-            )
-            .add_system_to_stage(
-                bevy_app::stage::POST_UPDATE,
-                camera::camera_system::<PerspectiveProjection>,
-            )
-            // registration order matters here. this must come after all camera_system::<T> systems
-            .add_system_to_stage(
-                bevy_app::stage::POST_UPDATE,
-                camera::visible_entities_system,
-            )
-            // TODO: turn these "resource systems" into graph nodes and remove the RENDER_RESOURCE stage
-            .add_system_to_stage(stage::RENDER_RESOURCE, mesh::mesh_resource_provider_system)
-            .add_system_to_stage(stage::RENDER_RESOURCE, Texture::texture_resource_system)
-            .add_system_to_stage(
-                stage::RENDER_GRAPH_SYSTEMS,
-                render_graph::render_graph_schedule_executor_system,
-            )
-            .add_system_to_stage(stage::DRAW, pipeline::draw_render_pipelines_system)
-            .add_system_to_stage(stage::POST_RENDER, shader::clear_shader_defs_system);
+        app.add_stage_after(
+            bevy_asset::stage::ASSET_EVENTS,
+            stage::RENDER_RESOURCE,
+            SystemStage::parallel(),
+        )
+        .add_stage_after(
+            stage::RENDER_RESOURCE,
+            stage::RENDER_GRAPH_SYSTEMS,
+            SystemStage::parallel(),
+        )
+        .add_stage_after(
+            stage::RENDER_GRAPH_SYSTEMS,
+            stage::DRAW,
+            SystemStage::parallel(),
+        )
+        .add_stage_after(stage::DRAW, stage::RENDER, SystemStage::parallel())
+        .add_stage_after(stage::RENDER, stage::POST_RENDER, SystemStage::parallel())
+        .add_asset::<Mesh>()
+        .add_asset::<Texture>()
+        .add_asset::<Shader>()
+        .add_asset::<PipelineDescriptor>()
+        .register_type::<Camera>()
+        .register_type::<Draw>()
+        .register_type::<Visible>()
+        .register_type::<RenderPipelines>()
+        .register_type::<OrthographicProjection>()
+        .register_type::<PerspectiveProjection>()
+        .register_type::<MainPass>()
+        .register_type::<VisibleEntities>()
+        .register_type::<Color>()
+        .register_type::<ShaderSpecialization>()
+        .register_type::<PrimitiveTopology>()
+        .register_type::<IndexFormat>()
+        .register_type::<PipelineSpecialization>()
+        .init_resource::<RenderGraph>()
+        .init_resource::<PipelineCompiler>()
+        .init_resource::<RenderResourceBindings>()
+        .init_resource::<TextureResourceSystemState>()
+        .init_resource::<AssetRenderResourceBindings>()
+        .init_resource::<ActiveCameras>()
+        .add_system_to_stage(
+            bevy_app::stage::PRE_UPDATE,
+            draw::clear_draw_system.system(),
+        )
+        .add_system_to_stage(
+            bevy_app::stage::POST_UPDATE,
+            camera::active_cameras_system.system(),
+        )
+        .add_system_to_stage(
+            bevy_app::stage::POST_UPDATE,
+            camera::camera_system::<OrthographicProjection>.system(),
+        )
+        .add_system_to_stage(
+            bevy_app::stage::POST_UPDATE,
+            camera::camera_system::<PerspectiveProjection>.system(),
+        )
+        // registration order matters here. this must come after all camera_system::<T> systems
+        .add_system_to_stage(
+            bevy_app::stage::POST_UPDATE,
+            camera::visible_entities_system.system(),
+        )
+        .add_system_to_stage(
+            stage::RENDER_RESOURCE,
+            shader::shader_update_system.system(),
+        )
+        .add_system_to_stage(
+            stage::RENDER_RESOURCE,
+            mesh::mesh_resource_provider_system.system(),
+        )
+        .add_system_to_stage(
+            stage::RENDER_RESOURCE,
+            Texture::texture_resource_system.system(),
+        )
+        .add_system_to_stage(
+            stage::RENDER_GRAPH_SYSTEMS,
+            render_graph::render_graph_schedule_executor_system.system(),
+        )
+        .add_system_to_stage(stage::DRAW, pipeline::draw_render_pipelines_system.system())
+        .add_system_to_stage(
+            stage::POST_RENDER,
+            shader::clear_shader_defs_system.system(),
+        );
 
         if app.resources().get::<Msaa>().is_none() {
             app.init_resource::<Msaa>();
@@ -156,11 +190,11 @@ impl Plugin for RenderPlugin {
             render_graph.add_base_graph(config, &msaa);
             let mut active_cameras = resources.get_mut::<ActiveCameras>().unwrap();
             if config.add_3d_camera {
-                active_cameras.add(base::camera::CAMERA3D);
+                active_cameras.add(base::camera::CAMERA_3D);
             }
 
             if config.add_2d_camera {
-                active_cameras.add(base::camera::CAMERA2D);
+                active_cameras.add(base::camera::CAMERA_2D);
             }
         }
     }
diff --git a/crates/bevy_render/src/mesh/mesh.rs b/crates/bevy_render/src/mesh/mesh.rs
index ceb001bffc053..f136dcde02f47 100644
--- a/crates/bevy_render/src/mesh/mesh.rs
+++ b/crates/bevy_render/src/mesh/mesh.rs
@@ -5,13 +5,13 @@ use crate::{
 use bevy_app::prelude::{EventReader, Events};
 use bevy_asset::{AssetEvent, Assets, Handle};
 use bevy_core::AsBytes;
-use bevy_ecs::{Local, Query, Res};
+use bevy_ecs::{Changed, Entity, Local, Mut, Query, QuerySet, Res, With};
 use bevy_math::*;
-use bevy_type_registry::TypeUuid;
+use bevy_reflect::TypeUuid;
 use std::borrow::Cow;
 
 use crate::pipeline::{InputStepMode, VertexAttributeDescriptor, VertexBufferDescriptor};
-use bevy_utils::HashMap;
+use bevy_utils::{HashMap, HashSet};
 
 pub const INDEX_BUFFER_ASSET_INDEX: u64 = 0;
 pub const VERTEX_ATTRIBUTE_BUFFER_ID: u64 = 10;
@@ -19,18 +19,34 @@ pub const VERTEX_ATTRIBUTE_BUFFER_ID: u64 = 10;
 #[derive(Clone, Debug)]
 pub enum VertexAttributeValues {
     Float(Vec<f32>),
+    Int(Vec<i32>),
+    Uint(Vec<u32>),
     Float2(Vec<[f32; 2]>),
+    Int2(Vec<[i32; 2]>),
+    Uint2(Vec<[u32; 2]>),
     Float3(Vec<[f32; 3]>),
+    Int3(Vec<[i32; 3]>),
+    Uint3(Vec<[u32; 3]>),
     Float4(Vec<[f32; 4]>),
+    Int4(Vec<[i32; 4]>),
+    Uint4(Vec<[u32; 4]>),
 }
 
 impl VertexAttributeValues {
     pub fn len(&self) -> usize {
         match *self {
             VertexAttributeValues::Float(ref values) => values.len(),
+            VertexAttributeValues::Int(ref values) => values.len(),
+            VertexAttributeValues::Uint(ref values) => values.len(),
             VertexAttributeValues::Float2(ref values) => values.len(),
+            VertexAttributeValues::Int2(ref values) => values.len(),
+            VertexAttributeValues::Uint2(ref values) => values.len(),
             VertexAttributeValues::Float3(ref values) => values.len(),
+            VertexAttributeValues::Int3(ref values) => values.len(),
+            VertexAttributeValues::Uint3(ref values) => values.len(),
             VertexAttributeValues::Float4(ref values) => values.len(),
+            VertexAttributeValues::Int4(ref values) => values.len(),
+            VertexAttributeValues::Uint4(ref values) => values.len(),
         }
     }
 
@@ -42,9 +58,17 @@ impl VertexAttributeValues {
     pub fn get_bytes(&self) -> &[u8] {
         match self {
             VertexAttributeValues::Float(values) => values.as_slice().as_bytes(),
+            VertexAttributeValues::Int(values) => values.as_slice().as_bytes(),
+            VertexAttributeValues::Uint(values) => values.as_slice().as_bytes(),
             VertexAttributeValues::Float2(values) => values.as_slice().as_bytes(),
+            VertexAttributeValues::Int2(values) => values.as_slice().as_bytes(),
+            VertexAttributeValues::Uint2(values) => values.as_slice().as_bytes(),
             VertexAttributeValues::Float3(values) => values.as_slice().as_bytes(),
+            VertexAttributeValues::Int3(values) => values.as_slice().as_bytes(),
+            VertexAttributeValues::Uint3(values) => values.as_slice().as_bytes(),
             VertexAttributeValues::Float4(values) => values.as_slice().as_bytes(),
+            VertexAttributeValues::Int4(values) => values.as_slice().as_bytes(),
+            VertexAttributeValues::Uint4(values) => values.as_slice().as_bytes(),
         }
     }
 }
@@ -53,9 +77,17 @@ impl From<&VertexAttributeValues> for VertexFormat {
     fn from(values: &VertexAttributeValues) -> Self {
         match values {
             VertexAttributeValues::Float(_) => VertexFormat::Float,
+            VertexAttributeValues::Int(_) => VertexFormat::Int,
+            VertexAttributeValues::Uint(_) => VertexFormat::Uint,
             VertexAttributeValues::Float2(_) => VertexFormat::Float2,
+            VertexAttributeValues::Int2(_) => VertexFormat::Int2,
+            VertexAttributeValues::Uint2(_) => VertexFormat::Uint2,
             VertexAttributeValues::Float3(_) => VertexFormat::Float3,
+            VertexAttributeValues::Int3(_) => VertexFormat::Int3,
+            VertexAttributeValues::Uint3(_) => VertexFormat::Uint3,
             VertexAttributeValues::Float4(_) => VertexFormat::Float4,
+            VertexAttributeValues::Int4(_) => VertexFormat::Int4,
+            VertexAttributeValues::Uint4(_) => VertexFormat::Uint4,
         }
     }
 }
@@ -66,24 +98,72 @@ impl From<Vec<f32>> for VertexAttributeValues {
     }
 }
 
+impl From<Vec<i32>> for VertexAttributeValues {
+    fn from(vec: Vec<i32>) -> Self {
+        VertexAttributeValues::Int(vec)
+    }
+}
+
+impl From<Vec<u32>> for VertexAttributeValues {
+    fn from(vec: Vec<u32>) -> Self {
+        VertexAttributeValues::Uint(vec)
+    }
+}
+
 impl From<Vec<[f32; 2]>> for VertexAttributeValues {
     fn from(vec: Vec<[f32; 2]>) -> Self {
         VertexAttributeValues::Float2(vec)
     }
 }
 
+impl From<Vec<[i32; 2]>> for VertexAttributeValues {
+    fn from(vec: Vec<[i32; 2]>) -> Self {
+        VertexAttributeValues::Int2(vec)
+    }
+}
+
+impl From<Vec<[u32; 2]>> for VertexAttributeValues {
+    fn from(vec: Vec<[u32; 2]>) -> Self {
+        VertexAttributeValues::Uint2(vec)
+    }
+}
+
 impl From<Vec<[f32; 3]>> for VertexAttributeValues {
     fn from(vec: Vec<[f32; 3]>) -> Self {
         VertexAttributeValues::Float3(vec)
     }
 }
 
+impl From<Vec<[i32; 3]>> for VertexAttributeValues {
+    fn from(vec: Vec<[i32; 3]>) -> Self {
+        VertexAttributeValues::Int3(vec)
+    }
+}
+
+impl From<Vec<[u32; 3]>> for VertexAttributeValues {
+    fn from(vec: Vec<[u32; 3]>) -> Self {
+        VertexAttributeValues::Uint3(vec)
+    }
+}
+
 impl From<Vec<[f32; 4]>> for VertexAttributeValues {
     fn from(vec: Vec<[f32; 4]>) -> Self {
         VertexAttributeValues::Float4(vec)
     }
 }
 
+impl From<Vec<[i32; 4]>> for VertexAttributeValues {
+    fn from(vec: Vec<[i32; 4]>) -> Self {
+        VertexAttributeValues::Int4(vec)
+    }
+}
+
+impl From<Vec<[u32; 4]>> for VertexAttributeValues {
+    fn from(vec: Vec<[u32; 4]>) -> Self {
+        VertexAttributeValues::Uint4(vec)
+    }
+}
+
 #[derive(Debug)]
 pub enum Indices {
     U16(Vec<u16>),
@@ -240,9 +320,15 @@ fn remove_current_mesh_resources(
     remove_resource_save(render_resource_context, handle, INDEX_BUFFER_ASSET_INDEX);
 }
 
+#[derive(Default)]
+pub struct MeshEntities {
+    entities: HashSet<Entity>,
+}
+
 #[derive(Default)]
 pub struct MeshResourceProviderState {
     mesh_event_reader: EventReader<AssetEvent<Mesh>>,
+    mesh_entities: HashMap<Handle<Mesh>, MeshEntities>,
 }
 
 pub fn mesh_resource_provider_system(
@@ -250,9 +336,12 @@ pub fn mesh_resource_provider_system(
     render_resource_context: Res<Box<dyn RenderResourceContext>>,
     meshes: Res<Assets<Mesh>>,
     mesh_events: Res<Events<AssetEvent<Mesh>>>,
-    mut query: Query<(&Handle<Mesh>, &mut RenderPipelines)>,
+    mut queries: QuerySet<(
+        Query<&mut RenderPipelines, With<Handle<Mesh>>>,
+        Query<(Entity, &Handle<Mesh>, &mut RenderPipelines), Changed<Handle<Mesh>>>,
+    )>,
 ) {
-    let mut changed_meshes = bevy_utils::HashSet::<Handle<Mesh>>::default();
+    let mut changed_meshes = HashSet::default();
     let render_resource_context = &**render_resource_context;
     for event in state.mesh_event_reader.iter(&mesh_events) {
         match event {
@@ -303,39 +392,65 @@ pub fn mesh_resource_provider_system(
                 )),
                 VERTEX_ATTRIBUTE_BUFFER_ID,
             );
+
+            if let Some(mesh_entities) = state.mesh_entities.get_mut(changed_mesh_handle) {
+                for entity in mesh_entities.entities.iter() {
+                    if let Ok(render_pipelines) = queries.q0_mut().get_mut(*entity) {
+                        update_entity_mesh(
+                            render_resource_context,
+                            mesh,
+                            changed_mesh_handle,
+                            render_pipelines,
+                        );
+                    }
+                }
+            }
         }
     }
 
     // handover buffers to pipeline
-    for (handle, mut render_pipelines) in query.iter_mut() {
+    for (entity, handle, render_pipelines) in queries.q1_mut().iter_mut() {
+        let mesh_entities = state
+            .mesh_entities
+            .entry(handle.clone_weak())
+            .or_insert_with(MeshEntities::default);
+        mesh_entities.entities.insert(entity);
         if let Some(mesh) = meshes.get(handle) {
-            for render_pipeline in render_pipelines.pipelines.iter_mut() {
-                render_pipeline.specialization.primitive_topology = mesh.primitive_topology;
-                // TODO: don't allocate a new vertex buffer descriptor for every entity
-                render_pipeline.specialization.vertex_buffer_descriptor =
-                    mesh.get_vertex_buffer_descriptor();
-                render_pipeline.specialization.index_format = mesh
-                    .indices()
-                    .map(|i| i.into())
-                    .unwrap_or(IndexFormat::Uint32);
-            }
+            update_entity_mesh(render_resource_context, mesh, handle, render_pipelines);
+        }
+    }
+}
 
-            if let Some(RenderResourceId::Buffer(index_buffer_resource)) =
-                render_resource_context.get_asset_resource(handle, INDEX_BUFFER_ASSET_INDEX)
-            {
-                // set index buffer into binding
-                render_pipelines
-                    .bindings
-                    .set_index_buffer(index_buffer_resource);
-            }
+fn update_entity_mesh(
+    render_resource_context: &dyn RenderResourceContext,
+    mesh: &Mesh,
+    handle: &Handle<Mesh>,
+    mut render_pipelines: Mut<RenderPipelines>,
+) {
+    for render_pipeline in render_pipelines.pipelines.iter_mut() {
+        render_pipeline.specialization.primitive_topology = mesh.primitive_topology;
+        // TODO: don't allocate a new vertex buffer descriptor for every entity
+        render_pipeline.specialization.vertex_buffer_descriptor =
+            mesh.get_vertex_buffer_descriptor();
+        render_pipeline.specialization.index_format = mesh
+            .indices()
+            .map(|i| i.into())
+            .unwrap_or(IndexFormat::Uint32);
+    }
 
-            if let Some(RenderResourceId::Buffer(vertex_attribute_buffer_resource)) =
-                render_resource_context.get_asset_resource(handle, VERTEX_ATTRIBUTE_BUFFER_ID)
-            {
-                // set index buffer into binding
-                render_pipelines.bindings.vertex_attribute_buffer =
-                    Some(vertex_attribute_buffer_resource);
-            }
-        }
+    if let Some(RenderResourceId::Buffer(index_buffer_resource)) =
+        render_resource_context.get_asset_resource(handle, INDEX_BUFFER_ASSET_INDEX)
+    {
+        // set index buffer into binding
+        render_pipelines
+            .bindings
+            .set_index_buffer(index_buffer_resource);
+    }
+
+    if let Some(RenderResourceId::Buffer(vertex_attribute_buffer_resource)) =
+        render_resource_context.get_asset_resource(handle, VERTEX_ATTRIBUTE_BUFFER_ID)
+    {
+        // set index buffer into binding
+        render_pipelines.bindings.vertex_attribute_buffer = Some(vertex_attribute_buffer_resource);
     }
 }
diff --git a/crates/bevy_render/src/mesh/shape.rs b/crates/bevy_render/src/mesh/shape.rs
index c29323d9979f8..72e28938d8276 100644
--- a/crates/bevy_render/src/mesh/shape.rs
+++ b/crates/bevy_render/src/mesh/shape.rs
@@ -1,7 +1,7 @@
 use super::{Indices, Mesh};
 use crate::pipeline::PrimitiveTopology;
 use bevy_math::*;
-use hexasphere::Hexasphere;
+use hexasphere::shapes::IcoSphere;
 
 pub struct Cube {
     pub size: f32,
@@ -273,15 +273,17 @@ impl Default for Icosphere {
 impl From<Icosphere> for Mesh {
     fn from(sphere: Icosphere) -> Self {
         if sphere.subdivisions >= 80 {
-            let temp_sphere = Hexasphere::new(sphere.subdivisions, |_| ());
+            // https://oeis.org/A005901
+            let subdivisions = sphere.subdivisions + 1;
+            let number_of_resulting_points = (subdivisions * subdivisions * 10) + 2;
 
             panic!(
-                "Cannot create an icosphere of {} subdivisions due to there being too many vertices being generated: {} (Limited to 65535 vertices or 79 subdivisions)",
+                "Cannot create an icosphere of {} subdivisions due to there being too many vertices being generated: {}. (Limited to 65535 vertices or 79 subdivisions)",
                 sphere.subdivisions,
-                temp_sphere.raw_points().len()
+                number_of_resulting_points
             );
         }
-        let hexasphere = Hexasphere::new(sphere.subdivisions, |point| {
+        let generated = IcoSphere::new(sphere.subdivisions, |point| {
             let inclination = point.z.acos();
             let azumith = point.y.atan2(point.x);
 
@@ -291,7 +293,7 @@ impl From<Icosphere> for Mesh {
             [norm_inclination, norm_azumith]
         });
 
-        let raw_points = hexasphere.raw_points();
+        let raw_points = generated.raw_points();
 
         let points = raw_points
             .iter()
@@ -304,12 +306,12 @@ impl From<Icosphere> for Mesh {
             .map(Into::into)
             .collect::<Vec<[f32; 3]>>();
 
-        let uvs = hexasphere.raw_data().to_owned();
+        let uvs = generated.raw_data().to_owned();
 
-        let mut indices = Vec::with_capacity(hexasphere.indices_per_main_triangle() * 20);
+        let mut indices = Vec::with_capacity(generated.indices_per_main_triangle() * 20);
 
         for i in 0..20 {
-            hexasphere.get_indices(i, &mut indices);
+            generated.get_indices(i, &mut indices);
         }
 
         let indices = Indices::U32(indices);
diff --git a/crates/bevy_render/src/pipeline/pipeline.rs b/crates/bevy_render/src/pipeline/pipeline.rs
index 3e2c6113532d1..eb8c836d05b39 100644
--- a/crates/bevy_render/src/pipeline/pipeline.rs
+++ b/crates/bevy_render/src/pipeline/pipeline.rs
@@ -7,7 +7,7 @@ use super::{
     PipelineLayout, StencilStateDescriptor,
 };
 use crate::{shader::ShaderStages, texture::TextureFormat};
-use bevy_type_registry::TypeUuid;
+use bevy_reflect::TypeUuid;
 
 #[derive(Clone, Debug, TypeUuid)]
 #[uuid = "ebfc1d11-a2a4-44cb-8f12-c49cc631146c"]
diff --git a/crates/bevy_render/src/pipeline/pipeline_compiler.rs b/crates/bevy_render/src/pipeline/pipeline_compiler.rs
index 37676ab0fa9de..1bb10a519a9b2 100644
--- a/crates/bevy_render/src/pipeline/pipeline_compiler.rs
+++ b/crates/bevy_render/src/pipeline/pipeline_compiler.rs
@@ -2,19 +2,19 @@ use super::{state_descriptors::PrimitiveTopology, IndexFormat, PipelineDescripto
 use crate::{
     pipeline::{BindType, InputStepMode, VertexBufferDescriptor},
     renderer::RenderResourceContext,
-    shader::{Shader, ShaderSource},
+    shader::{Shader, ShaderError, ShaderSource},
 };
 use bevy_asset::{Assets, Handle};
-use bevy_property::{Properties, Property};
+use bevy_reflect::Reflect;
 use bevy_utils::{HashMap, HashSet};
 use once_cell::sync::Lazy;
 use serde::{Deserialize, Serialize};
 
-#[derive(Clone, Eq, PartialEq, Debug, Properties)]
+#[derive(Clone, Eq, PartialEq, Debug, Reflect)]
 pub struct PipelineSpecialization {
     pub shader_specialization: ShaderSpecialization,
     pub primitive_topology: PrimitiveTopology,
-    pub dynamic_bindings: Vec<String>,
+    pub dynamic_bindings: HashSet<String>,
     pub index_format: IndexFormat,
     pub vertex_buffer_descriptor: VertexBufferDescriptor,
     pub sample_count: u32,
@@ -40,7 +40,7 @@ impl PipelineSpecialization {
     }
 }
 
-#[derive(Clone, Eq, PartialEq, Debug, Default, Property, Serialize, Deserialize)]
+#[derive(Clone, Eq, PartialEq, Debug, Default, Reflect, Serialize, Deserialize)]
 pub struct ShaderSpecialization {
     pub shader_defs: HashSet<String>,
 }
@@ -60,6 +60,7 @@ struct SpecializedPipeline {
 #[derive(Debug, Default)]
 pub struct PipelineCompiler {
     specialized_shaders: HashMap<Handle<Shader>, Vec<SpecializedShader>>,
+    specialized_shader_pipelines: HashMap<Handle<Shader>, Vec<Handle<PipelineDescriptor>>>,
     specialized_pipelines: HashMap<Handle<PipelineDescriptor>, Vec<SpecializedPipeline>>,
 }
 
@@ -70,7 +71,7 @@ impl PipelineCompiler {
         shaders: &mut Assets<Shader>,
         shader_handle: &Handle<Shader>,
         shader_specialization: &ShaderSpecialization,
-    ) -> Handle<Shader> {
+    ) -> Result<Handle<Shader>, ShaderError> {
         let specialized_shaders = self
             .specialized_shaders
             .entry(shader_handle.clone_weak())
@@ -80,7 +81,7 @@ impl PipelineCompiler {
 
         // don't produce new shader if the input source is already spirv
         if let ShaderSource::Spirv(_) = shader.source {
-            return shader_handle.clone_weak();
+            return Ok(shader_handle.clone_weak());
         }
 
         if let Some(specialized_shader) =
@@ -91,7 +92,7 @@ impl PipelineCompiler {
                 })
         {
             // if shader has already been compiled with current configuration, use existing shader
-            specialized_shader.shader.clone_weak()
+            Ok(specialized_shader.shader.clone_weak())
         } else {
             // if no shader exists with the current configuration, create new shader and compile
             let shader_def_vec = shader_specialization
@@ -100,14 +101,14 @@ impl PipelineCompiler {
                 .cloned()
                 .collect::<Vec<String>>();
             let compiled_shader =
-                render_resource_context.get_specialized_shader(shader, Some(&shader_def_vec));
+                render_resource_context.get_specialized_shader(shader, Some(&shader_def_vec))?;
             let specialized_handle = shaders.add(compiled_shader);
             let weak_specialized_handle = specialized_handle.clone_weak();
             specialized_shaders.push(SpecializedShader {
                 shader: specialized_handle,
                 specialization: shader_specialization.clone(),
             });
-            weak_specialized_handle
+            Ok(weak_specialized_handle)
         }
     }
 
@@ -138,23 +139,31 @@ impl PipelineCompiler {
     ) -> Handle<PipelineDescriptor> {
         let source_descriptor = pipelines.get(source_pipeline).unwrap();
         let mut specialized_descriptor = source_descriptor.clone();
-        specialized_descriptor.shader_stages.vertex = self.compile_shader(
-            render_resource_context,
-            shaders,
-            &specialized_descriptor.shader_stages.vertex,
-            &pipeline_specialization.shader_specialization,
-        );
+        let specialized_vertex_shader = self
+            .compile_shader(
+                render_resource_context,
+                shaders,
+                &specialized_descriptor.shader_stages.vertex,
+                &pipeline_specialization.shader_specialization,
+            )
+            .unwrap();
+        specialized_descriptor.shader_stages.vertex = specialized_vertex_shader.clone_weak();
+        let mut specialized_fragment_shader = None;
         specialized_descriptor.shader_stages.fragment = specialized_descriptor
             .shader_stages
             .fragment
             .as_ref()
             .map(|fragment| {
-                self.compile_shader(
-                    render_resource_context,
-                    shaders,
-                    fragment,
-                    &pipeline_specialization.shader_specialization,
-                )
+                let shader = self
+                    .compile_shader(
+                        render_resource_context,
+                        shaders,
+                        fragment,
+                        &pipeline_specialization.shader_specialization,
+                    )
+                    .unwrap();
+                specialized_fragment_shader = Some(shader.clone_weak());
+                shader
             });
 
         let mut layout = render_resource_context.reflect_pipeline_layout(
@@ -221,7 +230,7 @@ impl PipelineCompiler {
                     .push(compiled_vertex_attribute);
             } else {
                 panic!(
-                    "Attribute {} is required by shader, but not supplied by mesh. Either remove the attribute from the shader or supply the attribute ({}) to the mesh. ",
+                    "Attribute {} is required by shader, but not supplied by mesh. Either remove the attribute from the shader or supply the attribute ({}) to the mesh.",
                     shader_vertex_attribute.name,
                     shader_vertex_attribute.name,
                 );
@@ -244,6 +253,18 @@ impl PipelineCompiler {
             &shaders,
         );
 
+        // track specialized shader pipelines
+        self.specialized_shader_pipelines
+            .entry(specialized_vertex_shader)
+            .or_insert_with(Default::default)
+            .push(source_pipeline.clone_weak());
+        if let Some(specialized_fragment_shader) = specialized_fragment_shader {
+            self.specialized_shader_pipelines
+                .entry(specialized_fragment_shader)
+                .or_insert_with(Default::default)
+                .push(source_pipeline.clone_weak());
+        }
+
         let specialized_pipelines = self
             .specialized_pipelines
             .entry(source_pipeline.clone_weak())
@@ -282,4 +303,56 @@ impl PipelineCompiler {
             })
             .flatten()
     }
+
+    /// Update specialized shaders and remove any related specialized
+    /// pipelines and assets.
+    pub fn update_shader(
+        &mut self,
+        shader: &Handle<Shader>,
+        pipelines: &mut Assets<PipelineDescriptor>,
+        shaders: &mut Assets<Shader>,
+        render_resource_context: &dyn RenderResourceContext,
+    ) -> Result<(), ShaderError> {
+        if let Some(specialized_shaders) = self.specialized_shaders.get_mut(shader) {
+            for specialized_shader in specialized_shaders {
+                // Recompile specialized shader. If it fails, we bail immediately.
+                let shader_def_vec = specialized_shader
+                    .specialization
+                    .shader_defs
+                    .iter()
+                    .cloned()
+                    .collect::<Vec<String>>();
+                let new_handle =
+                    shaders.add(render_resource_context.get_specialized_shader(
+                        shaders.get(shader).unwrap(),
+                        Some(&shader_def_vec),
+                    )?);
+
+                // Replace handle and remove old from assets.
+                let old_handle = std::mem::replace(&mut specialized_shader.shader, new_handle);
+                shaders.remove(&old_handle);
+
+                // Find source pipelines that use the old specialized
+                // shader, and remove from tracking.
+                if let Some(source_pipelines) =
+                    self.specialized_shader_pipelines.remove(&old_handle)
+                {
+                    // Remove all specialized pipelines from tracking
+                    // and asset storage. They will be rebuilt on next
+                    // draw.
+                    for source_pipeline in source_pipelines {
+                        if let Some(specialized_pipelines) =
+                            self.specialized_pipelines.remove(&source_pipeline)
+                        {
+                            for p in specialized_pipelines {
+                                pipelines.remove(p.pipeline);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        Ok(())
+    }
 }
diff --git a/crates/bevy_render/src/pipeline/pipeline_layout.rs b/crates/bevy_render/src/pipeline/pipeline_layout.rs
index 7069e1dca411b..3aa3a1ed8a03b 100644
--- a/crates/bevy_render/src/pipeline/pipeline_layout.rs
+++ b/crates/bevy_render/src/pipeline/pipeline_layout.rs
@@ -34,7 +34,7 @@ impl PipelineLayout {
                                     || binding.name != shader_binding.name
                                     || binding.index != shader_binding.index
                                 {
-                                    panic!("Binding {} in BindGroup {} does not match across all shader types: {:?} {:?}", binding.index, bind_group.index, binding, shader_binding);
+                                    panic!("Binding {} in BindGroup {} does not match across all shader types: {:?} {:?}.", binding.index, bind_group.index, binding, shader_binding);
                                 }
                             } else {
                                 bind_group.bindings.push(shader_binding.clone());
diff --git a/crates/bevy_render/src/pipeline/render_pipelines.rs b/crates/bevy_render/src/pipeline/render_pipelines.rs
index 6fa8871060216..0831e93cd0ad8 100644
--- a/crates/bevy_render/src/pipeline/render_pipelines.rs
+++ b/crates/bevy_render/src/pipeline/render_pipelines.rs
@@ -2,15 +2,15 @@ use super::{PipelineDescriptor, PipelineSpecialization};
 use crate::{
     draw::{Draw, DrawContext},
     mesh::{Indices, Mesh},
-    prelude::Msaa,
+    prelude::{Msaa, Visible},
     renderer::RenderResourceBindings,
 };
 use bevy_asset::{Assets, Handle};
 use bevy_ecs::{Query, Res, ResMut};
-use bevy_property::Properties;
+use bevy_reflect::{Reflect, ReflectComponent};
+use bevy_utils::HashSet;
 
-#[derive(Debug, Properties, Default, Clone)]
-#[non_exhaustive]
+#[derive(Debug, Default, Clone, Reflect)]
 pub struct RenderPipeline {
     pub pipeline: Handle<PipelineDescriptor>,
     pub specialization: PipelineSpecialization,
@@ -39,10 +39,11 @@ impl RenderPipeline {
     }
 }
 
-#[derive(Debug, Properties, Clone)]
+#[derive(Debug, Clone, Reflect)]
+#[reflect(Component)]
 pub struct RenderPipelines {
     pub pipelines: Vec<RenderPipeline>,
-    #[property(ignore)]
+    #[reflect(ignore)]
     pub bindings: RenderResourceBindings,
 }
 
@@ -81,10 +82,10 @@ pub fn draw_render_pipelines_system(
     mut render_resource_bindings: ResMut<RenderResourceBindings>,
     msaa: Res<Msaa>,
     meshes: Res<Assets<Mesh>>,
-    mut query: Query<(&mut Draw, &mut RenderPipelines, &Handle<Mesh>)>,
+    mut query: Query<(&mut Draw, &mut RenderPipelines, &Handle<Mesh>, &Visible)>,
 ) {
-    for (mut draw, mut render_pipelines, mesh_handle) in query.iter_mut() {
-        if !draw.is_visible {
+    for (mut draw, mut render_pipelines, mesh_handle, visible) in query.iter_mut() {
+        if !visible.is_visible {
             continue;
         }
 
@@ -111,9 +112,22 @@ pub fn draw_render_pipelines_system(
                     .bindings
                     .iter_dynamic_bindings()
                     .map(|name| name.to_string())
-                    .collect::<Vec<String>>();
+                    .collect::<HashSet<String>>();
                 pipeline.dynamic_bindings_generation =
                     render_pipelines.bindings.dynamic_bindings_generation();
+                for (handle, _) in render_pipelines.bindings.iter_assets() {
+                    if let Some(bindings) = draw_context
+                        .asset_render_resource_bindings
+                        .get_untyped(handle)
+                    {
+                        for binding in bindings.iter_dynamic_bindings() {
+                            pipeline
+                                .specialization
+                                .dynamic_bindings
+                                .insert(binding.to_string());
+                        }
+                    }
+                }
             }
         }
 
diff --git a/crates/bevy_render/src/pipeline/state_descriptors.rs b/crates/bevy_render/src/pipeline/state_descriptors.rs
index 1d04ab33af4f3..ffd5b99995133 100644
--- a/crates/bevy_render/src/pipeline/state_descriptors.rs
+++ b/crates/bevy_render/src/pipeline/state_descriptors.rs
@@ -1,5 +1,5 @@
 use crate::texture::TextureFormat;
-use bevy_property::Property;
+use bevy_reflect::Reflect;
 use serde::{Deserialize, Serialize};
 
 #[derive(Clone, Debug)]
@@ -59,7 +59,7 @@ pub enum CompareFunction {
     Always = 7,
 }
 
-#[derive(Copy, Clone, Debug, Hash, Eq, PartialEq, Serialize, Deserialize, Property)]
+#[derive(Copy, Clone, Debug, Hash, Eq, PartialEq, Serialize, Deserialize, Reflect)]
 pub enum PrimitiveTopology {
     PointList = 0,
     LineList = 1,
@@ -182,7 +182,7 @@ impl Default for BlendOperation {
     }
 }
 
-#[derive(Copy, Clone, Debug, Hash, Eq, PartialEq, Serialize, Deserialize, Property)]
+#[derive(Copy, Clone, Debug, Hash, Eq, PartialEq, Serialize, Deserialize, Reflect)]
 pub enum IndexFormat {
     Uint16 = 0,
     Uint32 = 1,
diff --git a/crates/bevy_render/src/pipeline/vertex_buffer_descriptor.rs b/crates/bevy_render/src/pipeline/vertex_buffer_descriptor.rs
index 37ecd2760d326..42bf9673df44a 100644
--- a/crates/bevy_render/src/pipeline/vertex_buffer_descriptor.rs
+++ b/crates/bevy_render/src/pipeline/vertex_buffer_descriptor.rs
@@ -1,12 +1,13 @@
 use super::VertexFormat;
-use bevy_property::Property;
+use bevy_reflect::{Reflect, ReflectDeserialize};
 use serde::{Deserialize, Serialize};
 use std::{
     borrow::Cow,
     hash::{Hash, Hasher},
 };
 
-#[derive(Clone, Debug, Eq, PartialEq, Default, Property, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq, Default, Reflect, Serialize, Deserialize)]
+#[reflect_value(Serialize, Deserialize, PartialEq)]
 pub struct VertexBufferDescriptor {
     pub name: Cow<'static, str>,
     pub stride: u64,
diff --git a/crates/bevy_render/src/render_graph/base.rs b/crates/bevy_render/src/render_graph/base.rs
index 5bc46a85152cf..e1630c4e8f2dd 100644
--- a/crates/bevy_render/src/render_graph/base.rs
+++ b/crates/bevy_render/src/render_graph/base.rs
@@ -10,11 +10,12 @@ use crate::{
     texture::{Extent3d, TextureDescriptor, TextureDimension, TextureFormat, TextureUsage},
     Color,
 };
-use bevy_property::Properties;
+use bevy_reflect::{Reflect, ReflectComponent};
 use bevy_window::WindowId;
 
 /// A component that indicates that an entity should be drawn in the "main pass"
-#[derive(Default, Properties)]
+#[derive(Default, Reflect)]
+#[reflect(Component)]
 pub struct MainPass;
 
 #[derive(Debug)]
@@ -63,8 +64,8 @@ pub struct BaseRenderGraphConfig {
 
 pub mod node {
     pub const PRIMARY_SWAP_CHAIN: &str = "swapchain";
-    pub const CAMERA3D: &str = "camera3d";
-    pub const CAMERA2D: &str = "camera2d";
+    pub const CAMERA_3D: &str = "camera_3d";
+    pub const CAMERA_2D: &str = "camera_2d";
     pub const TEXTURE_COPY: &str = "texture_copy";
     pub const MAIN_DEPTH_TEXTURE: &str = "main_pass_depth_texture";
     pub const MAIN_SAMPLED_COLOR_ATTACHMENT: &str = "main_pass_sampled_color_attachment";
@@ -73,8 +74,8 @@ pub mod node {
 }
 
 pub mod camera {
-    pub const CAMERA3D: &str = "Camera3d";
-    pub const CAMERA2D: &str = "Camera2d";
+    pub const CAMERA_3D: &str = "Camera3d";
+    pub const CAMERA_2D: &str = "Camera2d";
 }
 
 impl Default for BaseRenderGraphConfig {
@@ -100,11 +101,11 @@ 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::CAMERA3D, CameraNode::new(camera::CAMERA3D));
+            self.add_system_node(node::CAMERA_3D, CameraNode::new(camera::CAMERA_3D));
         }
 
         if config.add_2d_camera {
-            self.add_system_node(node::CAMERA2D, CameraNode::new(camera::CAMERA2D));
+            self.add_system_node(node::CAMERA_2D, CameraNode::new(camera::CAMERA_2D));
         }
 
         self.add_node(node::SHARED_BUFFERS, SharedBuffersNode::default());
@@ -153,11 +154,11 @@ impl BaseRenderGraphBuilder for RenderGraph {
             main_pass_node.use_default_clear_color(0);
 
             if config.add_3d_camera {
-                main_pass_node.add_camera(camera::CAMERA3D);
+                main_pass_node.add_camera(camera::CAMERA_3D);
             }
 
             if config.add_2d_camera {
-                main_pass_node.add_camera(camera::CAMERA2D);
+                main_pass_node.add_camera(camera::CAMERA_2D);
             }
 
             self.add_node(node::MAIN_PASS, main_pass_node);
@@ -168,11 +169,13 @@ impl BaseRenderGraphBuilder for RenderGraph {
                 .unwrap();
 
             if config.add_3d_camera {
-                self.add_node_edge(node::CAMERA3D, node::MAIN_PASS).unwrap();
+                self.add_node_edge(node::CAMERA_3D, node::MAIN_PASS)
+                    .unwrap();
             }
 
             if config.add_2d_camera {
-                self.add_node_edge(node::CAMERA2D, node::MAIN_PASS).unwrap();
+                self.add_node_edge(node::CAMERA_2D, node::MAIN_PASS)
+                    .unwrap();
             }
         }
 
diff --git a/crates/bevy_render/src/render_graph/graph.rs b/crates/bevy_render/src/render_graph/graph.rs
index 65c3319b50a46..22cbb72893dca 100644
--- a/crates/bevy_render/src/render_graph/graph.rs
+++ b/crates/bevy_render/src/render_graph/graph.rs
@@ -1,5 +1,5 @@
 use super::{Edge, Node, NodeId, NodeLabel, NodeState, RenderGraphError, SlotLabel, SystemNode};
-use bevy_ecs::{Commands, Schedule};
+use bevy_ecs::{Commands, Schedule, SystemStage};
 use bevy_utils::HashMap;
 use std::{borrow::Cow, fmt::Debug};
 pub struct RenderGraph {
@@ -12,7 +12,7 @@ pub struct RenderGraph {
 impl Default for RenderGraph {
     fn default() -> Self {
         let mut schedule = Schedule::default();
-        schedule.add_stage("update");
+        schedule.add_stage("update", SystemStage::parallel());
         Self {
             nodes: Default::default(),
             node_names: Default::default(),
@@ -40,10 +40,9 @@ impl RenderGraph {
     where
         T: SystemNode + 'static,
     {
-        self.system_node_schedule
-            .as_mut()
-            .unwrap()
-            .add_boxed_system_to_stage("update", node.get_system(&mut self.commands));
+        let schedule = self.system_node_schedule.as_mut().unwrap();
+        let stage = schedule.get_stage_mut::<SystemStage>("update").unwrap();
+        stage.add_system_boxed(node.get_system(&mut self.commands));
         self.add_node(name, node)
     }
 
diff --git a/crates/bevy_render/src/render_graph/mod.rs b/crates/bevy_render/src/render_graph/mod.rs
index d91697d6eaa45..a8c249e697c23 100644
--- a/crates/bevy_render/src/render_graph/mod.rs
+++ b/crates/bevy_render/src/render_graph/mod.rs
@@ -21,26 +21,26 @@ use thiserror::Error;
 
 #[derive(Error, Debug, Eq, PartialEq)]
 pub enum RenderGraphError {
-    #[error("Node does not exist")]
+    #[error("node does not exist")]
     InvalidNode(NodeLabel),
-    #[error("Node slot does not exist")]
+    #[error("node slot does not exist")]
     InvalidNodeSlot(SlotLabel),
-    #[error("Node does not match the given type")]
+    #[error("node does not match the given type")]
     WrongNodeType,
-    #[error("Attempted to connect a node output slot to an incompatible input node slot")]
+    #[error("attempted to connect a node output slot to an incompatible input node slot")]
     MismatchedNodeSlots {
         output_node: NodeId,
         output_slot: usize,
         input_node: NodeId,
         input_slot: usize,
     },
-    #[error("Attempted to add an edge that already exists")]
+    #[error("attempted to add an edge that already exists")]
     EdgeAlreadyExists(Edge),
-    #[error("Node has an unconnected input slot.")]
+    #[error("node has an unconnected input slot")]
     UnconnectedNodeInputSlot { node: NodeId, input_slot: usize },
-    #[error("Node has an unconnected output slot.")]
+    #[error("node has an unconnected output slot")]
     UnconnectedNodeOutputSlot { node: NodeId, output_slot: usize },
-    #[error("Node input slot already occupied")]
+    #[error("node input slot already occupied")]
     NodeInputSlotAlreadyOccupied {
         node: NodeId,
         input_slot: usize,
diff --git a/crates/bevy_render/src/render_graph/node.rs b/crates/bevy_render/src/render_graph/node.rs
index 3cf3aa13a6a6d..1c2a19443314e 100644
--- a/crates/bevy_render/src/render_graph/node.rs
+++ b/crates/bevy_render/src/render_graph/node.rs
@@ -1,9 +1,9 @@
 use super::{Edge, RenderGraphError, ResourceSlotInfo, ResourceSlots};
 use crate::renderer::RenderContext;
 use bevy_ecs::{Commands, Resources, System, World};
+use bevy_utils::Uuid;
 use downcast_rs::{impl_downcast, Downcast};
 use std::{borrow::Cow, fmt::Debug};
-use uuid::Uuid;
 
 #[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
 pub struct NodeId(Uuid);
@@ -37,7 +37,7 @@ pub trait Node: Downcast + Send + Sync + 'static {
 impl_downcast!(Node);
 
 pub trait SystemNode: Node {
-    fn get_system(&self, commands: &mut Commands) -> Box<dyn System<Input = (), Output = ()>>;
+    fn get_system(&self, commands: &mut Commands) -> Box<dyn System<In = (), Out = ()>>;
 }
 
 #[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 574535f4f28c4..5e677c75b3019 100644
--- a/crates/bevy_render/src/render_graph/nodes/camera_node.rs
+++ b/crates/bevy_render/src/render_graph/nodes/camera_node.rs
@@ -44,7 +44,7 @@ impl Node for CameraNode {
 }
 
 impl SystemNode for CameraNode {
-    fn get_system(&self, commands: &mut Commands) -> Box<dyn System<Input = (), Output = ()>> {
+    fn get_system(&self, commands: &mut Commands) -> Box<dyn System<In = (), Out = ()>> {
         let system = camera_node_system.system();
         commands.insert_local_resource(
             system.id(),
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 d0c130d14c45f..72f0dfb860be7 100644
--- a/crates/bevy_render/src/render_graph/nodes/pass_node.rs
+++ b/crates/bevy_render/src/render_graph/nodes/pass_node.rs
@@ -6,6 +6,7 @@ use crate::{
         BindGroupDescriptor, BindType, BindingDescriptor, BindingShaderStage, PipelineDescriptor,
         UniformProperty,
     },
+    prelude::Visible,
     render_graph::{Node, ResourceSlotInfo, ResourceSlots},
     renderer::{
         BindGroup, BindGroupId, BufferId, RenderContext, RenderResourceBindings, RenderResourceType,
@@ -236,15 +237,19 @@ where
                             continue;
                         };
 
-                        if !draw.is_visible {
-                            continue;
+                        if let Ok(visible) = world.get::<Visible>(visible_entity.entity) {
+                            if !visible.is_visible {
+                                continue;
+                            }
                         }
 
                         // each Draw component contains an ordered list of render commands. we turn those into actual render commands here
                         for render_command in draw.render_commands.iter() {
                             match render_command {
                                 RenderCommand::SetPipeline { pipeline } => {
-                                    // TODO: Filter pipelines
+                                    if draw_state.is_pipeline_set(pipeline.clone_weak()) {
+                                        continue;
+                                    }
                                     render_pass.set_pipeline(pipeline);
                                     let descriptor = pipelines.get(pipeline).unwrap();
                                     draw_state.set_pipeline(pipeline, descriptor);
@@ -290,18 +295,27 @@ where
                                     offset,
                                     slot,
                                 } => {
+                                    if draw_state.is_vertex_buffer_set(*slot, *buffer, *offset) {
+                                        continue;
+                                    }
                                     render_pass.set_vertex_buffer(*slot, *buffer, *offset);
-                                    draw_state.set_vertex_buffer(*slot, *buffer);
+                                    draw_state.set_vertex_buffer(*slot, *buffer, *offset);
                                 }
                                 RenderCommand::SetIndexBuffer { buffer, offset } => {
+                                    if draw_state.is_index_buffer_set(*buffer, *offset) {
+                                        continue;
+                                    }
                                     render_pass.set_index_buffer(*buffer, *offset);
-                                    draw_state.set_index_buffer(*buffer)
+                                    draw_state.set_index_buffer(*buffer, *offset)
                                 }
                                 RenderCommand::SetBindGroup {
                                     index,
                                     bind_group,
                                     dynamic_uniform_indices,
                                 } => {
+                                    if dynamic_uniform_indices.is_none() && draw_state.is_bind_group_set(*index, *bind_group) {
+                                        continue;
+                                    }
                                     let pipeline = pipelines.get(draw_state.pipeline.as_ref().unwrap()).unwrap();
                                     let layout = pipeline.get_layout().unwrap();
                                     let bind_group_descriptor = layout.get_bind_group(*index).unwrap();
@@ -329,8 +343,8 @@ where
 struct DrawState {
     pipeline: Option<Handle<PipelineDescriptor>>,
     bind_groups: Vec<Option<BindGroupId>>,
-    vertex_buffers: Vec<Option<BufferId>>,
-    index_buffer: Option<BufferId>,
+    vertex_buffers: Vec<Option<(BufferId, u64)>>,
+    index_buffer: Option<(BufferId, u64)>,
 }
 
 impl DrawState {
@@ -338,12 +352,24 @@ impl DrawState {
         self.bind_groups[index as usize] = Some(bind_group);
     }
 
-    pub fn set_vertex_buffer(&mut self, index: u32, buffer: BufferId) {
-        self.vertex_buffers[index as usize] = Some(buffer);
+    pub fn is_bind_group_set(&self, index: u32, bind_group: BindGroupId) -> bool {
+        self.bind_groups[index as usize] == Some(bind_group)
+    }
+
+    pub fn set_vertex_buffer(&mut self, index: u32, buffer: BufferId, offset: u64) {
+        self.vertex_buffers[index as usize] = Some((buffer, offset));
+    }
+
+    pub fn is_vertex_buffer_set(&self, index: u32, buffer: BufferId, offset: u64) -> bool {
+        self.vertex_buffers[index as usize] == Some((buffer, offset))
     }
 
-    pub fn set_index_buffer(&mut self, buffer: BufferId) {
-        self.index_buffer = Some(buffer);
+    pub fn set_index_buffer(&mut self, buffer: BufferId, offset: u64) {
+        self.index_buffer = Some((buffer, offset));
+    }
+
+    pub fn is_index_buffer_set(&self, buffer: BufferId, offset: u64) -> bool {
+        self.index_buffer == Some((buffer, offset))
     }
 
     pub fn can_draw(&self) -> bool {
@@ -355,6 +381,10 @@ impl DrawState {
         self.can_draw() && self.index_buffer.is_some()
     }
 
+    pub fn is_pipeline_set(&self, pipeline: Handle<PipelineDescriptor>) -> bool {
+        self.pipeline == Some(pipeline)
+    }
+
     pub fn set_pipeline(
         &mut self,
         handle: &Handle<PipelineDescriptor>,
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 0235c7407240d..e513d1434cccc 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
@@ -1,6 +1,6 @@
 use crate::{
-    draw::Draw,
     pipeline::RenderPipelines,
+    prelude::Visible,
     render_graph::{CommandQueue, Node, ResourceSlots, SystemNode},
     renderer::{
         self, BufferInfo, BufferUsage, RenderContext, RenderResourceBinding,
@@ -9,11 +9,15 @@ use crate::{
     texture,
 };
 
-use bevy_asset::{Asset, Assets, Handle, HandleId};
-use bevy_ecs::{Commands, Entity, IntoSystem, Local, Query, Res, ResMut, Resources, System, World};
+use bevy_app::{EventReader, Events};
+use bevy_asset::{Asset, AssetEvent, Assets, Handle, HandleId};
+use bevy_ecs::{
+    Changed, Commands, Entity, IntoSystem, Local, Or, Query, QuerySet, Res, ResMut, Resources,
+    System, With, World,
+};
 use bevy_utils::HashMap;
 use renderer::{AssetRenderResourceBindings, BufferId, RenderResourceType, RenderResources};
-use std::{hash::Hash, marker::PhantomData, ops::DerefMut};
+use std::{any::TypeId, hash::Hash, marker::PhantomData, ops::DerefMut};
 
 #[derive(Debug)]
 struct QueuedBufferWrite {
@@ -80,13 +84,14 @@ impl<I: Hash + Eq> BufferArray<I> {
         }
     }
 
-    pub fn resize(&mut self, render_resource_context: &dyn RenderResourceContext) {
+    pub fn resize(&mut self, render_resource_context: &dyn RenderResourceContext) -> bool {
         if self.len <= self.buffer_capacity {
-            return;
+            return false;
         }
 
         self.allocate_buffer(render_resource_context);
         // TODO: allow shrinking
+        true
     }
 
     pub fn allocate_buffer(&mut self, render_resource_context: &dyn RenderResourceContext) {
@@ -189,12 +194,29 @@ where
     }
 
     /// Resize BufferArray buffers if they aren't large enough
-    fn resize_buffer_arrays(&mut self, render_resource_context: &dyn RenderResourceContext) {
+    fn resize_buffer_arrays(
+        &mut self,
+        render_resource_context: &dyn RenderResourceContext,
+    ) -> bool {
+        let mut resized = false;
         for buffer_array in self.buffer_arrays.iter_mut() {
             if let Some(buffer_array) = buffer_array {
-                buffer_array.resize(render_resource_context);
+                resized |= buffer_array.resize(render_resource_context);
+            }
+        }
+
+        resized
+    }
+
+    fn set_required_staging_buffer_size_to_max(&mut self) {
+        let mut new_size = 0;
+        for buffer_array in self.buffer_arrays.iter() {
+            if let Some(buffer_array) = buffer_array {
+                new_size += buffer_array.item_size * buffer_array.len;
             }
         }
+
+        self.required_staging_buffer_size = new_size;
     }
 
     /// Update the staging buffer to provide enough space to copy data to target buffers.
@@ -238,91 +260,83 @@ where
         staging_buffer: &mut [u8],
     ) {
         for (i, render_resource) in uniforms.iter().enumerate() {
-            match render_resource.resource_type() {
-                Some(RenderResourceType::Buffer) => {
-                    let size = render_resource.buffer_byte_len().unwrap();
-                    let render_resource_name = uniforms.get_render_resource_name(i).unwrap();
-                    let aligned_size =
-                        render_resource_context.get_aligned_uniform_size(size, false);
-                    let buffer_array = self.buffer_arrays[i].as_mut().unwrap();
-                    let range = 0..aligned_size as u64;
-                    let (target_buffer, target_offset) = if dynamic_uniforms {
-                        let binding = buffer_array.get_binding(id).unwrap();
-                        let dynamic_index = if let RenderResourceBinding::Buffer {
-                            dynamic_index: Some(dynamic_index),
-                            ..
-                        } = binding
-                        {
-                            dynamic_index
-                        } else {
-                            panic!("dynamic index should always be set");
-                        };
-                        render_resource_bindings.set(render_resource_name, binding);
-                        (buffer_array.buffer.unwrap(), dynamic_index)
+            if let Some(RenderResourceType::Buffer) = render_resource.resource_type() {
+                let size = render_resource.buffer_byte_len().unwrap();
+                let render_resource_name = uniforms.get_render_resource_name(i).unwrap();
+                let aligned_size = render_resource_context.get_aligned_uniform_size(size, false);
+                let buffer_array = self.buffer_arrays[i].as_mut().unwrap();
+                let range = 0..aligned_size as u64;
+                let (target_buffer, target_offset) = if dynamic_uniforms {
+                    let binding = buffer_array.get_binding(id).unwrap();
+                    let dynamic_index = if let RenderResourceBinding::Buffer {
+                        dynamic_index: Some(dynamic_index),
+                        ..
+                    } = binding
+                    {
+                        dynamic_index
                     } else {
-                        let mut matching_buffer = None;
-                        if let Some(binding) = render_resource_bindings.get(render_resource_name) {
-                            let buffer_id = binding.get_buffer().unwrap();
-                            if let Some(BufferInfo {
-                                size: current_size, ..
-                            }) = render_resource_context.get_buffer_info(buffer_id)
-                            {
-                                if aligned_size == current_size {
-                                    matching_buffer = Some(buffer_id);
-                                } else {
-                                    render_resource_context.remove_buffer(buffer_id);
-                                }
+                        panic!("Dynamic index should always be set.");
+                    };
+                    render_resource_bindings.set(render_resource_name, binding);
+                    (buffer_array.buffer.unwrap(), dynamic_index)
+                } else {
+                    let mut matching_buffer = None;
+                    if let Some(binding) = render_resource_bindings.get(render_resource_name) {
+                        let buffer_id = binding.get_buffer().unwrap();
+                        if let Some(BufferInfo {
+                            size: current_size, ..
+                        }) = render_resource_context.get_buffer_info(buffer_id)
+                        {
+                            if aligned_size == current_size {
+                                matching_buffer = Some(buffer_id);
+                            } else {
+                                render_resource_context.remove_buffer(buffer_id);
                             }
                         }
+                    }
 
-                        let resource = if let Some(matching_buffer) = matching_buffer {
-                            matching_buffer
-                        } else {
-                            let mut usage = BufferUsage::UNIFORM;
-                            if let Some(render_resource_hints) =
-                                uniforms.get_render_resource_hints(i)
-                            {
-                                if render_resource_hints.contains(RenderResourceHints::BUFFER) {
-                                    usage = BufferUsage::STORAGE
-                                }
+                    let resource = if let Some(matching_buffer) = matching_buffer {
+                        matching_buffer
+                    } else {
+                        let mut usage = BufferUsage::UNIFORM;
+                        if let Some(render_resource_hints) = uniforms.get_render_resource_hints(i) {
+                            if render_resource_hints.contains(RenderResourceHints::BUFFER) {
+                                usage = BufferUsage::STORAGE
                             }
+                        }
 
-                            let buffer = render_resource_context.create_buffer(BufferInfo {
-                                size: aligned_size,
-                                buffer_usage: BufferUsage::COPY_DST | usage,
-                                ..Default::default()
-                            });
-
-                            render_resource_bindings.set(
-                                render_resource_name,
-                                RenderResourceBinding::Buffer {
-                                    buffer,
-                                    range,
-                                    dynamic_index: None,
-                                },
-                            );
-                            buffer
-                        };
-
-                        (resource, 0)
+                        let buffer = render_resource_context.create_buffer(BufferInfo {
+                            size: aligned_size,
+                            buffer_usage: BufferUsage::COPY_DST | usage,
+                            ..Default::default()
+                        });
+
+                        render_resource_bindings.set(
+                            render_resource_name,
+                            RenderResourceBinding::Buffer {
+                                buffer,
+                                range,
+                                dynamic_index: None,
+                            },
+                        );
+                        buffer
                     };
 
-                    render_resource.write_buffer_bytes(
-                        &mut staging_buffer[self.current_staging_buffer_offset
-                            ..(self.current_staging_buffer_offset + size)],
-                    );
+                    (resource, 0)
+                };
 
-                    self.queued_buffer_writes.push(QueuedBufferWrite {
-                        buffer: target_buffer,
-                        target_offset: target_offset as usize,
-                        source_offset: self.current_staging_buffer_offset,
-                        size,
-                    });
-                    self.current_staging_buffer_offset += size;
-                }
-                Some(RenderResourceType::Texture) => { /* ignore textures */ }
-                Some(RenderResourceType::Sampler) => { /* ignore samplers */ }
-                None => { /* ignore None */ }
+                render_resource.write_buffer_bytes(
+                    &mut staging_buffer[self.current_staging_buffer_offset
+                        ..(self.current_staging_buffer_offset + size)],
+                );
+
+                self.queued_buffer_writes.push(QueuedBufferWrite {
+                    buffer: target_buffer,
+                    target_offset: target_offset as usize,
+                    source_offset: self.current_staging_buffer_offset,
+                    size,
+                });
+                self.current_staging_buffer_offset += size;
             }
         }
     }
@@ -387,7 +401,7 @@ impl<T> SystemNode for RenderResourcesNode<T>
 where
     T: renderer::RenderResources,
 {
-    fn get_system(&self, commands: &mut Commands) -> Box<dyn System<Input = (), Output = ()>> {
+    fn get_system(&self, commands: &mut Commands) -> Box<dyn System<In = (), Out = ()>> {
         let system = render_resources_node_system::<T>.system();
         commands.insert_local_resource(
             system.id(),
@@ -420,36 +434,59 @@ impl<I, T: RenderResources> Default for RenderResourcesNodeState<I, T> {
 
 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>>,
-    mut query: Query<(Entity, &T, &Draw, &mut RenderPipelines)>,
+    mut queries: QuerySet<(
+        Query<(Entity, &T, &Visible, &mut RenderPipelines), Or<(Changed<T>, Changed<Visible>)>>,
+        Query<(Entity, &T, &Visible, &mut RenderPipelines)>,
+    )>,
 ) {
     let state = state.deref_mut();
     let uniform_buffer_arrays = &mut state.uniform_buffer_arrays;
     let render_resource_context = &**render_resource_context;
     uniform_buffer_arrays.begin_update();
     // initialize uniform buffer arrays using the first RenderResources
-    if let Some((_, first, _, _)) = query.iter_mut().next() {
+    if let Some((_, first, _, _)) = queries.q0_mut().iter_mut().next() {
         uniform_buffer_arrays.initialize(first, render_resource_context);
     }
 
-    for entity in query.removed::<T>() {
+    for entity in queries.q0().removed::<T>() {
         uniform_buffer_arrays.remove_bindings(*entity);
     }
 
-    for (entity, uniforms, draw, mut render_pipelines) in query.iter_mut() {
-        if !draw.is_visible {
-            continue;
+    // handle entities that were waiting for texture loads on the last update
+    for entity in std::mem::take(&mut *entities_waiting_for_textures) {
+        if let Ok((entity, uniforms, _visible, mut render_pipelines)) =
+            queries.q1_mut().get_mut(entity)
+        {
+            if !setup_uniform_texture_resources::<T>(
+                &uniforms,
+                render_resource_context,
+                &mut render_pipelines.bindings,
+            ) {
+                entities_waiting_for_textures.push(entity);
+            }
         }
+    }
 
+    for (entity, uniforms, visible, mut render_pipelines) in queries.q0_mut().iter_mut() {
+        if !visible.is_visible {
+            continue;
+        }
         uniform_buffer_arrays.prepare_uniform_buffers(entity, uniforms);
-        setup_uniform_texture_resources::<T>(
+        if !setup_uniform_texture_resources::<T>(
             &uniforms,
             render_resource_context,
             &mut render_pipelines.bindings,
-        )
+        ) {
+            entities_waiting_for_textures.push(entity);
+        }
     }
 
-    uniform_buffer_arrays.resize_buffer_arrays(render_resource_context);
+    let resized = uniform_buffer_arrays.resize_buffer_arrays(render_resource_context);
+    if resized {
+        uniform_buffer_arrays.set_required_staging_buffer_size_to_max()
+    }
     uniform_buffer_arrays.resize_staging_buffer(render_resource_context);
 
     if let Some(staging_buffer) = state.uniform_buffer_arrays.staging_buffer {
@@ -458,19 +495,41 @@ fn render_resources_node_system<T: RenderResources>(
             staging_buffer,
             0..state.uniform_buffer_arrays.staging_buffer_size as u64,
             &mut |mut staging_buffer, _render_resource_context| {
-                for (entity, uniforms, draw, mut render_pipelines) in query.iter_mut() {
-                    if !draw.is_visible {
-                        continue;
+                // if the buffer array was resized, write all entities to the new buffer, otherwise only write changes
+                if resized {
+                    for (entity, uniforms, visible, mut render_pipelines) in
+                        queries.q1_mut().iter_mut()
+                    {
+                        if !visible.is_visible {
+                            continue;
+                        }
+
+                        state.uniform_buffer_arrays.write_uniform_buffers(
+                            entity,
+                            &uniforms,
+                            state.dynamic_uniforms,
+                            render_resource_context,
+                            &mut render_pipelines.bindings,
+                            &mut staging_buffer,
+                        );
                     }
+                } else {
+                    for (entity, uniforms, visible, mut render_pipelines) in
+                        queries.q0_mut().iter_mut()
+                    {
+                        if !visible.is_visible {
+                            continue;
+                        }
 
-                    state.uniform_buffer_arrays.write_uniform_buffers(
-                        entity,
-                        &uniforms,
-                        state.dynamic_uniforms,
-                        render_resource_context,
-                        &mut render_pipelines.bindings,
-                        &mut staging_buffer,
-                    );
+                        state.uniform_buffer_arrays.write_uniform_buffers(
+                            entity,
+                            &uniforms,
+                            state.dynamic_uniforms,
+                            render_resource_context,
+                            &mut render_pipelines.bindings,
+                            &mut staging_buffer,
+                        );
+                    }
                 }
             },
         );
@@ -521,13 +580,11 @@ where
     }
 }
 
-const EXPECT_ASSET_MESSAGE: &str = "Only assets that exist should be in the modified assets list";
-
 impl<T> SystemNode for AssetRenderResourcesNode<T>
 where
     T: renderer::RenderResources + Asset,
 {
-    fn get_system(&self, commands: &mut Commands) -> Box<dyn System<Input = (), Output = ()>> {
+    fn get_system(&self, commands: &mut Commands) -> Box<dyn System<In = (), Out = ()>> {
         let system = asset_render_resources_node_system::<T>.system();
         commands.insert_local_resource(
             system.id(),
@@ -542,35 +599,91 @@ where
     }
 }
 
+struct AssetRenderNodeState<T: Asset> {
+    event_reader: EventReader<AssetEvent<T>>,
+    assets_waiting_for_textures: Vec<HandleId>,
+}
+
+impl<T: Asset> Default for AssetRenderNodeState<T> {
+    fn default() -> Self {
+        Self {
+            event_reader: Default::default(),
+            assets_waiting_for_textures: Default::default(),
+        }
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
 fn asset_render_resources_node_system<T: RenderResources + Asset>(
     mut state: Local<RenderResourcesNodeState<HandleId, T>>,
+    mut asset_state: Local<AssetRenderNodeState<T>>,
     assets: Res<Assets<T>>,
+    asset_events: Res<Events<AssetEvent<T>>>,
     mut asset_render_resource_bindings: ResMut<AssetRenderResourceBindings>,
     render_resource_context: Res<Box<dyn RenderResourceContext>>,
-    mut query: Query<(&Handle<T>, &Draw, &mut RenderPipelines)>,
+    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;
     let render_resource_context = &**render_resource_context;
 
-    let modified_assets = assets.ids().collect::<Vec<_>>();
+    let mut changed_assets = HashMap::default();
+    for event in asset_state.event_reader.iter(&asset_events) {
+        match event {
+            AssetEvent::Created { ref handle } => {
+                if let Some(asset) = assets.get(handle) {
+                    changed_assets.insert(handle.id, asset);
+                }
+            }
+            AssetEvent::Modified { ref handle } => {
+                if let Some(asset) = assets.get(handle) {
+                    changed_assets.insert(handle.id, asset);
+                }
+            }
+            AssetEvent::Removed { ref handle } => {
+                uniform_buffer_arrays.remove_bindings(handle.id);
+                // if asset was modified and removed in the same update, ignore the modification
+                // events are ordered so future modification events are ok
+                changed_assets.remove(&handle.id);
+            }
+        }
+    }
+
+    // handle assets that were waiting for texture loads on the last update
+    for asset_handle in std::mem::take(&mut asset_state.assets_waiting_for_textures) {
+        if let Some(asset) = assets.get(asset_handle) {
+            let mut bindings =
+                asset_render_resource_bindings.get_or_insert_mut(&Handle::<T>::weak(asset_handle));
+            if !setup_uniform_texture_resources::<T>(&asset, render_resource_context, &mut bindings)
+            {
+                asset_state.assets_waiting_for_textures.push(asset_handle);
+            }
+        }
+    }
 
     uniform_buffer_arrays.begin_update();
     // initialize uniform buffer arrays using the first RenderResources
-    if let Some(first_handle) = modified_assets.get(0) {
-        let asset = assets.get(*first_handle).expect(EXPECT_ASSET_MESSAGE);
+    if let Some(asset) = changed_assets.values().next() {
         uniform_buffer_arrays.initialize(asset, render_resource_context);
     }
 
-    for asset_handle in modified_assets.iter() {
-        let asset = assets.get(*asset_handle).expect(EXPECT_ASSET_MESSAGE);
+    for (asset_handle, asset) in changed_assets.iter() {
         uniform_buffer_arrays.prepare_uniform_buffers(*asset_handle, asset);
         let mut bindings =
             asset_render_resource_bindings.get_or_insert_mut(&Handle::<T>::weak(*asset_handle));
-        setup_uniform_texture_resources::<T>(&asset, render_resource_context, &mut bindings);
+        if !setup_uniform_texture_resources::<T>(&asset, render_resource_context, &mut bindings) {
+            asset_state.assets_waiting_for_textures.push(*asset_handle);
+        }
     }
 
-    uniform_buffer_arrays.resize_buffer_arrays(render_resource_context);
+    let resized = uniform_buffer_arrays.resize_buffer_arrays(render_resource_context);
+    if resized {
+        uniform_buffer_arrays.set_required_staging_buffer_size_to_max()
+    }
     uniform_buffer_arrays.resize_staging_buffer(render_resource_context);
 
     if let Some(staging_buffer) = state.uniform_buffer_arrays.staging_buffer {
@@ -579,19 +692,34 @@ fn asset_render_resources_node_system<T: RenderResources + Asset>(
             staging_buffer,
             0..state.uniform_buffer_arrays.staging_buffer_size as u64,
             &mut |mut staging_buffer, _render_resource_context| {
-                for asset_handle in modified_assets.iter() {
-                    let asset = assets.get(*asset_handle).expect(EXPECT_ASSET_MESSAGE);
-                    let mut render_resource_bindings = asset_render_resource_bindings
-                        .get_or_insert_mut(&Handle::<T>::weak(*asset_handle));
-                    // TODO: only setup buffer if we haven't seen this handle before
-                    state.uniform_buffer_arrays.write_uniform_buffers(
-                        *asset_handle,
-                        &asset,
-                        state.dynamic_uniforms,
-                        render_resource_context,
-                        &mut render_resource_bindings,
-                        &mut staging_buffer,
-                    );
+                if resized {
+                    for (asset_handle, asset) in assets.iter() {
+                        let mut render_resource_bindings = asset_render_resource_bindings
+                            .get_or_insert_mut(&Handle::<T>::weak(asset_handle));
+                        // TODO: only setup buffer if we haven't seen this handle before
+                        state.uniform_buffer_arrays.write_uniform_buffers(
+                            asset_handle,
+                            &asset,
+                            state.dynamic_uniforms,
+                            render_resource_context,
+                            &mut render_resource_bindings,
+                            &mut staging_buffer,
+                        );
+                    }
+                } else {
+                    for (asset_handle, asset) in changed_assets.iter() {
+                        let mut render_resource_bindings = asset_render_resource_bindings
+                            .get_or_insert_mut(&Handle::<T>::weak(*asset_handle));
+                        // TODO: only setup buffer if we haven't seen this handle before
+                        state.uniform_buffer_arrays.write_uniform_buffers(
+                            *asset_handle,
+                            &asset,
+                            state.dynamic_uniforms,
+                            render_resource_context,
+                            &mut render_resource_bindings,
+                            &mut staging_buffer,
+                        );
+                    }
                 }
             },
         );
@@ -602,23 +730,35 @@ fn asset_render_resources_node_system<T: RenderResources + Asset>(
             .copy_staging_buffer_to_final_buffers(&mut state.command_queue, staging_buffer);
     }
 
-    for (asset_handle, draw, mut render_pipelines) in query.iter_mut() {
-        if !draw.is_visible {
-            continue;
-        }
-        if let Some(asset_bindings) = asset_render_resource_bindings.get(asset_handle) {
-            render_pipelines.bindings.extend(asset_bindings);
+    // 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) {
+            render_pipelines
+                .bindings
+                .remove_asset_with_type(TypeId::of::<T>())
         }
     }
+
+    // update changed entity asset mapping
+    for (asset_handle, mut render_pipelines) in queries.q0_mut().iter_mut() {
+        render_pipelines
+            .bindings
+            .remove_asset_with_type(TypeId::of::<T>());
+        render_pipelines
+            .bindings
+            .add_asset(asset_handle.clone_weak_untyped(), TypeId::of::<T>());
+    }
 }
 
 fn setup_uniform_texture_resources<T>(
     uniforms: &T,
     render_resource_context: &dyn RenderResourceContext,
     render_resource_bindings: &mut RenderResourceBindings,
-) where
+) -> bool
+where
     T: renderer::RenderResources,
 {
+    let mut success = true;
     for (i, render_resource) in uniforms.iter().enumerate() {
         if let Some(RenderResourceType::Texture) = render_resource.resource_type() {
             let render_resource_name = uniforms.get_render_resource_name(i).unwrap();
@@ -640,8 +780,12 @@ fn setup_uniform_texture_resources<T>(
                         RenderResourceBinding::Sampler(sampler_resource.get_sampler().unwrap()),
                     );
                     continue;
+                } else {
+                    success = false;
                 }
             }
         }
     }
+
+    success
 }
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 676df16fc5162..39144b22d744d 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
@@ -16,8 +16,7 @@ impl Node for SharedBuffersNode {
         _input: &ResourceSlots,
         _output: &mut ResourceSlots,
     ) {
-        let shared_buffers = resources.get::<SharedBuffers>().unwrap();
-        let mut command_queue = shared_buffers.reset_command_queue();
-        command_queue.execute(render_context);
+        let mut shared_buffers = resources.get_mut::<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 d68a6729ec217..f2f0d7500429c 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
@@ -34,13 +34,17 @@ impl Node for TextureCopyNode {
                         }
 
                         let texture_descriptor: TextureDescriptor = texture.into();
-                        let width = texture.size.x as usize;
-                        let aligned_width = render_context
-                            .resources()
-                            .get_aligned_texture_size(texture.size.x as usize);
+                        let width = texture.size.width as usize;
+                        let aligned_width =
+                            render_context.resources().get_aligned_texture_size(width);
                         let format_size = texture.format.pixel_size();
-                        let mut aligned_data =
-                            vec![0; format_size * aligned_width * texture.size.y as usize];
+                        let mut aligned_data = vec![
+                            0;
+                            format_size
+                                * aligned_width
+                                * texture.size.height as usize
+                                * texture.size.depth as usize
+                        ];
                         texture
                             .data
                             .chunks_exact(format_size * width)
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 1c700c4d8c818..b8a95ccdb9110 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
@@ -49,7 +49,7 @@ impl Node for WindowSwapChainNode {
 
         let window = windows
             .get(self.window_id)
-            .expect("Received window resized event for non-existent window");
+            .expect("Received window resized event for non-existent window.");
 
         let render_resource_context = render_context.resources_mut();
 
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 dc6ee403f3ed8..d287002ab4e29 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
@@ -52,7 +52,7 @@ impl Node for WindowTextureNode {
 
         let window = windows
             .get(self.window_id)
-            .expect("Received window resized event for non-existent window");
+            .expect("Received window resized event for non-existent window.");
 
         if self
             .window_created_event_reader
@@ -68,8 +68,8 @@ impl Node for WindowTextureNode {
                 render_resource_context.remove_texture(old_texture);
             }
 
-            self.descriptor.size.width = window.width();
-            self.descriptor.size.height = window.height();
+            self.descriptor.size.width = window.physical_width();
+            self.descriptor.size.height = window.physical_height();
             let texture_resource = render_resource_context.create_texture(self.descriptor);
             output.set(WINDOW_TEXTURE, RenderResourceId::Texture(texture_resource));
         }
diff --git a/crates/bevy_render/src/render_graph/schedule.rs b/crates/bevy_render/src/render_graph/schedule.rs
index e250de45de664..23d70d2ec2e8a 100644
--- a/crates/bevy_render/src/render_graph/schedule.rs
+++ b/crates/bevy_render/src/render_graph/schedule.rs
@@ -4,7 +4,8 @@ use thiserror::Error;
 
 #[derive(Error, Debug)]
 pub enum StagerError {
-    #[error("Encountered a RenderGraphError")]
+    // This might have to be `:` tagged at the end.
+    #[error("encountered a `RenderGraphError`")]
     RenderGraphError(#[from] RenderGraphError),
 }
 
@@ -211,7 +212,7 @@ fn stage_node(
         .map(|e| {
             node_stages_and_jobs
                 .get(&e.get_output_node())
-                .expect("already checked that parents were visited")
+                .expect("Already checked that parents were visited.")
         })
         .max()
     {
@@ -223,7 +224,7 @@ fn stage_node(
             .filter(|e| {
                 let (max_stage, _) = node_stages_and_jobs
                     .get(&e.get_output_node())
-                    .expect("already checked that parents were visited");
+                    .expect("Already checked that parents were visited.");
                 max_stage == max_parent_stage
             })
             .count();
diff --git a/crates/bevy_render/src/render_graph/system.rs b/crates/bevy_render/src/render_graph/system.rs
index 875c33298c653..78fa184c2469e 100644
--- a/crates/bevy_render/src/render_graph/system.rs
+++ b/crates/bevy_render/src/render_graph/system.rs
@@ -10,12 +10,7 @@ pub fn render_graph_schedule_executor_system(world: &mut World, resources: &mut
 
     commands.apply(world, resources);
     if let Some(schedule) = system_schedule.as_mut() {
-        schedule.run_on_systems(|system| {
-            if !system.is_initialized() {
-                system.initialize(world, resources);
-            }
-        });
-        schedule.run(world, resources);
+        schedule.initialize_and_run(world, resources);
     }
     let mut render_graph = resources.get_mut::<RenderGraph>().unwrap();
     if let Some(schedule) = system_schedule.take() {
diff --git a/crates/bevy_render/src/renderer/headless_render_resource_context.rs b/crates/bevy_render/src/renderer/headless_render_resource_context.rs
index 03e3177f4c636..ed182a51bb1d3 100644
--- a/crates/bevy_render/src/renderer/headless_render_resource_context.rs
+++ b/crates/bevy_render/src/renderer/headless_render_resource_context.rs
@@ -2,7 +2,7 @@ use super::RenderResourceContext;
 use crate::{
     pipeline::{BindGroupDescriptorId, PipelineDescriptor},
     renderer::{BindGroup, BufferId, BufferInfo, RenderResourceId, SamplerId, TextureId},
-    shader::Shader,
+    shader::{Shader, ShaderError},
     texture::{SamplerDescriptor, TextureDescriptor},
 };
 use bevy_asset::{Assets, Handle, HandleUntyped};
@@ -149,7 +149,13 @@ impl RenderResourceContext for HeadlessRenderResourceContext {
         size
     }
 
-    fn get_specialized_shader(&self, shader: &Shader, _macros: Option<&[String]>) -> Shader {
-        shader.clone()
+    fn get_specialized_shader(
+        &self,
+        shader: &Shader,
+        _macros: Option<&[String]>,
+    ) -> Result<Shader, ShaderError> {
+        Ok(shader.clone())
     }
+
+    fn remove_stale_bind_groups(&self) {}
 }
diff --git a/crates/bevy_render/src/renderer/render_resource/buffer.rs b/crates/bevy_render/src/renderer/render_resource/buffer.rs
index e5104e140d09a..c254e228f17d1 100644
--- a/crates/bevy_render/src/renderer/render_resource/buffer.rs
+++ b/crates/bevy_render/src/renderer/render_resource/buffer.rs
@@ -1,4 +1,4 @@
-use uuid::Uuid;
+use bevy_utils::Uuid;
 
 #[derive(Copy, Clone, Hash, Eq, PartialEq, Debug)]
 pub struct BufferId(Uuid);
diff --git a/crates/bevy_render/src/renderer/render_resource/render_resource_bindings.rs b/crates/bevy_render/src/renderer/render_resource/render_resource_bindings.rs
index a09dfe86a6cbf..e02ce2661ebc8 100644
--- a/crates/bevy_render/src/renderer/render_resource/render_resource_bindings.rs
+++ b/crates/bevy_render/src/renderer/render_resource/render_resource_bindings.rs
@@ -5,7 +5,7 @@ use crate::{
 };
 use bevy_asset::{Asset, Handle, HandleUntyped};
 use bevy_utils::{HashMap, HashSet};
-use std::ops::Range;
+use std::{any::TypeId, ops::Range};
 
 #[derive(Clone, PartialEq, Eq, Debug)]
 pub enum RenderResourceBinding {
@@ -36,10 +36,13 @@ impl RenderResourceBinding {
     }
 
     pub fn is_dynamic_buffer(&self) -> bool {
-        matches!(self, RenderResourceBinding::Buffer {
-            dynamic_index: Some(_),
-            ..
-        })
+        matches!(
+            self,
+            RenderResourceBinding::Buffer {
+                dynamic_index: Some(_),
+                ..
+            }
+        )
     }
 
     pub fn get_sampler(&self) -> Option<SamplerId> {
@@ -67,6 +70,7 @@ pub struct RenderResourceBindings {
     /// A Buffer that is filled with zeros that will be used for attributes required by the shader, but undefined by the mesh.
     pub vertex_fallback_buffer: Option<BufferId>,
     pub index_buffer: Option<BufferId>,
+    assets: HashSet<(HandleUntyped, TypeId)>,
     bind_groups: HashMap<BindGroupId, BindGroup>,
     bind_group_descriptors: HashMap<BindGroupDescriptorId, Option<BindGroupId>>,
     dirty_bind_groups: HashSet<BindGroupId>,
@@ -99,6 +103,10 @@ impl RenderResourceBindings {
                     self.dirty_bind_groups.insert(*id);
                 }
             }
+        } else {
+            // unmatched bind group descriptors might now match
+            self.bind_group_descriptors
+                .retain(|_, value| value.is_some());
         }
     }
 
@@ -120,11 +128,12 @@ impl RenderResourceBindings {
             self.bind_group_descriptors.insert(descriptor.id, Some(id));
             BindGroupStatus::Changed(id)
         } else {
+            self.bind_group_descriptors.insert(descriptor.id, None);
             BindGroupStatus::NoMatch
         }
     }
 
-    pub fn update_bind_group(
+    fn update_bind_group_status(
         &mut self,
         bind_group_descriptor: &BindGroupDescriptor,
     ) -> BindGroupStatus {
@@ -144,6 +153,50 @@ impl RenderResourceBindings {
         }
     }
 
+    pub fn add_asset(&mut self, handle: HandleUntyped, type_id: TypeId) {
+        self.dynamic_bindings_generation += 1;
+        self.assets.insert((handle, type_id));
+    }
+
+    pub fn remove_asset_with_type(&mut self, type_id: TypeId) {
+        self.dynamic_bindings_generation += 1;
+        self.assets.retain(|(_, current_id)| *current_id != type_id);
+    }
+
+    pub fn iter_assets(&self) -> impl Iterator<Item = &(HandleUntyped, TypeId)> {
+        self.assets.iter()
+    }
+
+    pub fn update_bind_group(
+        &mut self,
+        bind_group_descriptor: &BindGroupDescriptor,
+        render_resource_context: &dyn RenderResourceContext,
+    ) -> Option<&BindGroup> {
+        let status = self.update_bind_group_status(bind_group_descriptor);
+        match status {
+            BindGroupStatus::Changed(id) => {
+                let bind_group = self
+                    .get_bind_group(id)
+                    .expect("`RenderResourceSet` was just changed, so it should exist.");
+                render_resource_context.create_bind_group(bind_group_descriptor.id, bind_group);
+                Some(bind_group)
+            }
+            BindGroupStatus::Unchanged(id) => {
+                // PERF: this is only required because RenderResourceContext::remove_stale_bind_groups doesn't inform RenderResourceBindings
+                // when a stale bind group has been removed
+                let bind_group = self
+                    .get_bind_group(id)
+                    .expect("`RenderResourceSet` was just changed, so it should exist.");
+                render_resource_context.create_bind_group(bind_group_descriptor.id, bind_group);
+                Some(bind_group)
+            }
+            BindGroupStatus::NoMatch => {
+                // ignore unchanged / unmatched render resource sets
+                None
+            }
+        }
+    }
+
     pub fn update_bind_groups(
         &mut self,
         pipeline: &PipelineDescriptor,
@@ -151,26 +204,7 @@ impl RenderResourceBindings {
     ) {
         let layout = pipeline.get_layout().unwrap();
         for bind_group_descriptor in layout.bind_groups.iter() {
-            match self.update_bind_group(bind_group_descriptor) {
-                BindGroupStatus::Changed(id) => {
-                    let bind_group = self
-                        .get_bind_group(id)
-                        .expect("RenderResourceSet was just changed, so it should exist");
-                    render_resource_context.create_bind_group(bind_group_descriptor.id, bind_group);
-                }
-                // TODO: Don't re-create bind groups if they havent changed. this will require cleanup of orphan bind groups and
-                // removal of global context.clear_bind_groups()
-                // PERF: see above
-                BindGroupStatus::Unchanged(id) => {
-                    let bind_group = self
-                        .get_bind_group(id)
-                        .expect("RenderResourceSet was just changed, so it should exist");
-                    render_resource_context.create_bind_group(bind_group_descriptor.id, bind_group);
-                }
-                BindGroupStatus::NoMatch => {
-                    // ignore unchanged / unmatched render resource sets
-                }
-            }
+            self.update_bind_group(bind_group_descriptor, render_resource_context);
         }
     }
 
@@ -208,10 +242,13 @@ impl RenderResourceBindings {
         self.bindings
             .iter()
             .filter(|(_, binding)| {
-                matches!(binding, RenderResourceBinding::Buffer {
-                    dynamic_index: Some(_),
-                    ..
-                })
+                matches!(
+                    binding,
+                    RenderResourceBinding::Buffer {
+                        dynamic_index: Some(_),
+                        ..
+                    }
+                )
             })
             .map(|(name, _)| name.as_str())
     }
@@ -224,7 +261,11 @@ pub struct AssetRenderResourceBindings {
 
 impl AssetRenderResourceBindings {
     pub fn get<T: Asset>(&self, handle: &Handle<T>) -> Option<&RenderResourceBindings> {
-        self.bindings.get(&handle.clone_weak_untyped())
+        self.get_untyped(&handle.clone_weak_untyped())
+    }
+
+    pub fn get_untyped(&self, handle: &HandleUntyped) -> Option<&RenderResourceBindings> {
+        self.bindings.get(handle)
     }
 
     pub fn get_or_insert_mut<T: Asset>(
@@ -237,7 +278,14 @@ impl AssetRenderResourceBindings {
     }
 
     pub fn get_mut<T: Asset>(&mut self, handle: &Handle<T>) -> Option<&mut RenderResourceBindings> {
-        self.bindings.get_mut(&handle.clone_weak_untyped())
+        self.get_mut_untyped(&handle.clone_weak_untyped())
+    }
+
+    pub fn get_mut_untyped(
+        &mut self,
+        handle: &HandleUntyped,
+    ) -> Option<&mut RenderResourceBindings> {
+        self.bindings.get_mut(handle)
     }
 }
 
@@ -289,15 +337,15 @@ mod tests {
         equal_bindings.set("a", resource1.clone());
         equal_bindings.set("b", resource2.clone());
 
-        let status = bindings.update_bind_group(&bind_group_descriptor);
+        let status = bindings.update_bind_group_status(&bind_group_descriptor);
         let id = if let BindGroupStatus::Changed(id) = status {
             id
         } else {
-            panic!("expected a changed bind group");
+            panic!("Expected a changed bind group.");
         };
 
         let different_bind_group_status =
-            different_bindings.update_bind_group(&bind_group_descriptor);
+            different_bindings.update_bind_group_status(&bind_group_descriptor);
         if let BindGroupStatus::Changed(different_bind_group_id) = different_bind_group_status {
             assert_ne!(
                 id, different_bind_group_id,
@@ -305,23 +353,24 @@ mod tests {
             );
             different_bind_group_id
         } else {
-            panic!("expected a changed bind group");
+            panic!("Expected a changed bind group.");
         };
 
-        let equal_bind_group_status = equal_bindings.update_bind_group(&bind_group_descriptor);
+        let equal_bind_group_status =
+            equal_bindings.update_bind_group_status(&bind_group_descriptor);
         if let BindGroupStatus::Changed(equal_bind_group_id) = equal_bind_group_status {
             assert_eq!(
                 id, equal_bind_group_id,
                 "equal bind group should have the same id"
             );
         } else {
-            panic!("expected a changed bind group");
+            panic!("Expected a changed bind group.");
         };
 
         let mut unmatched_bindings = RenderResourceBindings::default();
         unmatched_bindings.set("a", resource1.clone());
         let unmatched_bind_group_status =
-            unmatched_bindings.update_bind_group(&bind_group_descriptor);
+            unmatched_bindings.update_bind_group_status(&bind_group_descriptor);
         assert_eq!(unmatched_bind_group_status, BindGroupStatus::NoMatch);
     }
 }
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 39dcb3c673ea5..bf2e399e19938 100644
--- a/crates/bevy_render/src/renderer/render_resource/shared_buffers.rs
+++ b/crates/bevy_render/src/renderer/render_resource/shared_buffers.rs
@@ -1,77 +1,106 @@
 use super::{BufferId, BufferInfo, RenderResource, RenderResourceBinding};
 use crate::{
     render_graph::CommandQueue,
-    renderer::{BufferUsage, RenderResourceContext},
+    renderer::{BufferUsage, RenderContext, RenderResourceContext},
 };
-use bevy_ecs::Res;
-use parking_lot::RwLock;
-use std::sync::Arc;
+use bevy_ecs::{Res, ResMut};
 
-// TODO: Instead of allocating small "exact size" buffers each frame, this should use multiple large shared buffers and probably
-// a long-living "cpu mapped" staging buffer. Im punting that for now because I don't know the best way to use wgpu's new async
-// buffer mapping yet.
 pub struct SharedBuffers {
-    render_resource_context: Box<dyn RenderResourceContext>,
-    buffers: Arc<RwLock<Vec<BufferId>>>,
-    command_queue: Arc<RwLock<CommandQueue>>,
+    staging_buffer: Option<BufferId>,
+    uniform_buffer: Option<BufferId>,
+    buffers_to_free: Vec<BufferId>,
+    buffer_size: usize,
+    initial_size: usize,
+    current_offset: usize,
+    command_queue: CommandQueue,
 }
 
 impl SharedBuffers {
-    pub fn new(render_resource_context: Box<dyn RenderResourceContext>) -> Self {
+    pub fn new(initial_size: usize) -> Self {
         Self {
-            render_resource_context,
-            buffers: Default::default(),
+            staging_buffer: None,
+            uniform_buffer: None,
+            buffer_size: 0,
+            current_offset: 0,
+            initial_size,
+            buffers_to_free: Default::default(),
             command_queue: Default::default(),
         }
     }
 
-    pub fn get_buffer<T: RenderResource>(
-        &self,
+    pub fn grow(
+        &mut self,
+        render_resource_context: &dyn RenderResourceContext,
+        required_space: usize,
+    ) {
+        while self.buffer_size < self.current_offset + required_space {
+            self.buffer_size = if self.buffer_size == 0 {
+                self.initial_size
+            } else {
+                self.buffer_size * 2
+            };
+        }
+
+        self.current_offset = 0;
+
+        if let Some(staging_buffer) = self.staging_buffer.take() {
+            render_resource_context.unmap_buffer(staging_buffer);
+            self.buffers_to_free.push(staging_buffer);
+        }
+
+        if let Some(uniform_buffer) = self.uniform_buffer.take() {
+            self.buffers_to_free.push(uniform_buffer);
+        }
+
+        self.staging_buffer = Some(render_resource_context.create_buffer(BufferInfo {
+            size: self.buffer_size,
+            buffer_usage: BufferUsage::MAP_WRITE | BufferUsage::COPY_SRC,
+            mapped_at_creation: true,
+        }));
+        self.uniform_buffer = Some(render_resource_context.create_buffer(BufferInfo {
+            size: self.buffer_size,
+            buffer_usage: BufferUsage::COPY_DST | BufferUsage::UNIFORM,
+            mapped_at_creation: false,
+        }));
+    }
+
+    pub fn get_uniform_buffer<T: RenderResource>(
+        &mut self,
+        render_resource_context: &dyn RenderResourceContext,
         render_resource: &T,
-        buffer_usage: BufferUsage,
     ) -> Option<RenderResourceBinding> {
         if let Some(size) = render_resource.buffer_byte_len() {
-            let aligned_size = self
-                .render_resource_context
-                .get_aligned_uniform_size(size, false);
-            // PERF: this buffer will be slow
-            let staging_buffer = self.render_resource_context.create_buffer(BufferInfo {
-                size: aligned_size,
-                buffer_usage: BufferUsage::COPY_SRC | BufferUsage::MAP_WRITE,
-                mapped_at_creation: true,
-            });
+            // TODO: overlap alignment if/when possible
+            let aligned_size = render_resource_context.get_aligned_uniform_size(size, true);
+            let mut new_offset = self.current_offset + aligned_size;
+            if new_offset > self.buffer_size {
+                self.grow(render_resource_context, aligned_size);
+                new_offset = aligned_size;
+            }
 
-            self.render_resource_context.write_mapped_buffer(
+            let range = self.current_offset as u64..new_offset as u64;
+            let staging_buffer = self.staging_buffer.unwrap();
+            let uniform_buffer = self.uniform_buffer.unwrap();
+            render_resource_context.write_mapped_buffer(
                 staging_buffer,
-                0..size as u64,
+                range.clone(),
                 &mut |data, _renderer| {
                     render_resource.write_buffer_bytes(data);
                 },
             );
 
-            self.render_resource_context.unmap_buffer(staging_buffer);
-
-            let destination_buffer = self.render_resource_context.create_buffer(BufferInfo {
-                size: aligned_size,
-                buffer_usage: BufferUsage::COPY_DST | buffer_usage,
-                ..Default::default()
-            });
-
-            let mut command_queue = self.command_queue.write();
-            command_queue.copy_buffer_to_buffer(
+            self.command_queue.copy_buffer_to_buffer(
                 staging_buffer,
-                0,
-                destination_buffer,
-                0,
-                size as u64,
+                self.current_offset as u64,
+                uniform_buffer,
+                self.current_offset as u64,
+                aligned_size as u64,
             );
 
-            let mut buffers = self.buffers.write();
-            buffers.push(staging_buffer);
-            buffers.push(destination_buffer);
+            self.current_offset = new_offset;
             Some(RenderResourceBinding::Buffer {
-                buffer: destination_buffer,
-                range: 0..aligned_size as u64,
+                buffer: uniform_buffer,
+                range,
                 dynamic_index: None,
             })
         } else {
@@ -79,21 +108,29 @@ impl SharedBuffers {
         }
     }
 
-    // TODO: remove this when this actually uses shared buffers
-    pub fn free_buffers(&self) {
-        let mut buffers = self.buffers.write();
-        for buffer in buffers.drain(..) {
-            self.render_resource_context.remove_buffer(buffer)
+    pub fn update(&mut self, render_resource_context: &dyn RenderResourceContext) {
+        self.current_offset = 0;
+        for buffer in self.buffers_to_free.drain(..) {
+            render_resource_context.remove_buffer(buffer)
+        }
+
+        if let Some(staging_buffer) = self.staging_buffer {
+            render_resource_context.map_buffer(staging_buffer);
         }
     }
 
-    pub fn reset_command_queue(&self) -> CommandQueue {
-        let mut command_queue = self.command_queue.write();
-        std::mem::take(&mut *command_queue)
+    pub fn apply(&mut 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);
     }
 }
 
-// TODO: remove this when this actually uses shared buffers
-pub fn free_shared_buffers_system(shared_buffers: Res<SharedBuffers>) {
-    shared_buffers.free_buffers();
+pub fn shared_buffers_update_system(
+    mut shared_buffers: ResMut<SharedBuffers>,
+    render_resource_context: Res<Box<dyn RenderResourceContext>>,
+) {
+    shared_buffers.update(&**render_resource_context);
 }
diff --git a/crates/bevy_render/src/renderer/render_resource/texture.rs b/crates/bevy_render/src/renderer/render_resource/texture.rs
index 06bafa787e02a..46e7e51753eee 100644
--- a/crates/bevy_render/src/renderer/render_resource/texture.rs
+++ b/crates/bevy_render/src/renderer/render_resource/texture.rs
@@ -1,4 +1,4 @@
-use uuid::Uuid;
+use bevy_utils::Uuid;
 
 #[derive(Copy, Clone, Hash, Eq, PartialEq, Debug)]
 pub struct TextureId(Uuid);
diff --git a/crates/bevy_render/src/renderer/render_resource_context.rs b/crates/bevy_render/src/renderer/render_resource_context.rs
index 3e49b0bccafa4..365595fac7816 100644
--- a/crates/bevy_render/src/renderer/render_resource_context.rs
+++ b/crates/bevy_render/src/renderer/render_resource_context.rs
@@ -1,7 +1,7 @@
 use crate::{
     pipeline::{BindGroupDescriptorId, PipelineDescriptor, PipelineLayout},
     renderer::{BindGroup, BufferId, BufferInfo, RenderResourceId, SamplerId, TextureId},
-    shader::{Shader, ShaderLayout, ShaderStages},
+    shader::{Shader, ShaderError, ShaderLayout, ShaderStages},
     texture::{SamplerDescriptor, TextureDescriptor},
 };
 use bevy_asset::{Asset, Assets, Handle, HandleUntyped};
@@ -29,7 +29,11 @@ pub trait RenderResourceContext: Downcast + Send + Sync + 'static {
     fn create_buffer_with_data(&self, buffer_info: BufferInfo, data: &[u8]) -> BufferId;
     fn create_shader_module(&self, shader_handle: &Handle<Shader>, shaders: &Assets<Shader>);
     fn create_shader_module_from_source(&self, shader_handle: &Handle<Shader>, shader: &Shader);
-    fn get_specialized_shader(&self, shader: &Shader, macros: Option<&[String]>) -> Shader;
+    fn get_specialized_shader(
+        &self,
+        shader: &Shader,
+        macros: Option<&[String]>,
+    ) -> Result<Shader, ShaderError>;
     fn remove_buffer(&self, buffer: BufferId);
     fn remove_texture(&self, texture: TextureId);
     fn remove_sampler(&self, sampler: SamplerId);
@@ -62,6 +66,7 @@ pub trait RenderResourceContext: Downcast + Send + Sync + 'static {
         bind_group: &BindGroup,
     );
     fn clear_bind_groups(&self);
+    fn remove_stale_bind_groups(&self);
     /// Reflects the pipeline layout from its shaders.
     ///
     /// If `bevy_conventions` is true, it will be assumed that the shader follows "bevy shader conventions". These allow
diff --git a/crates/bevy_render/src/shader/shader.rs b/crates/bevy_render/src/shader/shader.rs
index 14e575f670366..19a89af632f0f 100644
--- a/crates/bevy_render/src/shader/shader.rs
+++ b/crates/bevy_render/src/shader/shader.rs
@@ -1,7 +1,16 @@
+use crate::{
+    pipeline::{PipelineCompiler, PipelineDescriptor},
+    renderer::RenderResourceContext,
+};
+
 use super::ShaderLayout;
-use bevy_asset::Handle;
-use bevy_type_registry::TypeUuid;
+use bevy_app::{EventReader, Events};
+use bevy_asset::{AssetEvent, AssetLoader, Assets, Handle, LoadContext, LoadedAsset};
+use bevy_ecs::{Local, Res, ResMut};
+use bevy_reflect::TypeUuid;
+use bevy_utils::{tracing::error, BoxedFuture};
 use std::marker::Copy;
+use thiserror::Error;
 
 /// The stage of a shader
 #[derive(Hash, Eq, PartialEq, Copy, Clone, Debug)]
@@ -11,7 +20,32 @@ pub enum ShaderStage {
     Compute,
 }
 
-#[cfg(all(not(target_os = "ios"), not(target_arch = "wasm32")))]
+/// An error that occurs during shader handling.
+#[derive(Error, Debug)]
+pub enum ShaderError {
+    /// Shader compilation error.
+    #[error("Shader compilation error: {0}")]
+    Compilation(String),
+
+    #[cfg(any(target_os = "ios", all(target_arch = "aarch64", target_os = "macos")))]
+    /// shaderc error.
+    #[error("shaderc error")]
+    ShaderC(#[from] shaderc::Error),
+
+    #[cfg(any(target_os = "ios", all(target_arch = "aarch64", target_os = "macos")))]
+    #[error("Error initializing shaderc Compiler")]
+    ErrorInitializingShadercCompiler,
+
+    #[cfg(any(target_os = "ios", all(target_arch = "aarch64", target_os = "macos")))]
+    #[error("Error initializing shaderc CompileOptions")]
+    ErrorInitializingShadercCompileOptions,
+}
+
+#[cfg(all(
+    not(target_os = "ios"),
+    not(target_arch = "wasm32"),
+    not(all(target_arch = "aarch64", target_os = "macos"))
+))]
 impl Into<bevy_glsl_to_spirv::ShaderType> for ShaderStage {
     fn into(self) -> bevy_glsl_to_spirv::ShaderType {
         match self {
@@ -22,16 +56,21 @@ impl Into<bevy_glsl_to_spirv::ShaderType> for ShaderStage {
     }
 }
 
-#[cfg(all(not(target_os = "ios"), not(target_arch = "wasm32")))]
+#[cfg(all(
+    not(target_os = "ios"),
+    not(target_arch = "wasm32"),
+    not(all(target_arch = "aarch64", target_os = "macos"))
+))]
 pub fn glsl_to_spirv(
     glsl_source: &str,
     stage: ShaderStage,
     shader_defs: Option<&[String]>,
-) -> Vec<u32> {
-    bevy_glsl_to_spirv::compile(glsl_source, stage.into(), shader_defs).unwrap()
+) -> Result<Vec<u32>, ShaderError> {
+    bevy_glsl_to_spirv::compile(glsl_source, stage.into(), shader_defs)
+        .map_err(ShaderError::Compilation)
 }
 
-#[cfg(target_os = "ios")]
+#[cfg(any(target_os = "ios", all(target_arch = "aarch64", target_os = "macos")))]
 impl Into<shaderc::ShaderKind> for ShaderStage {
     fn into(self) -> shaderc::ShaderKind {
         match self {
@@ -42,31 +81,31 @@ impl Into<shaderc::ShaderKind> for ShaderStage {
     }
 }
 
-#[cfg(target_os = "ios")]
+#[cfg(any(target_os = "ios", all(target_arch = "aarch64", target_os = "macos")))]
 pub fn glsl_to_spirv(
     glsl_source: &str,
     stage: ShaderStage,
     shader_defs: Option<&[String]>,
-) -> Vec<u32> {
-    let mut compiler = shaderc::Compiler::new().unwrap();
-    let mut options = shaderc::CompileOptions::new().unwrap();
+) -> Result<Vec<u32>, ShaderError> {
+    let mut compiler =
+        shaderc::Compiler::new().ok_or(ShaderError::ErrorInitializingShadercCompiler)?;
+    let mut options = shaderc::CompileOptions::new()
+        .ok_or(ShaderError::ErrorInitializingShadercCompileOptions)?;
     if let Some(shader_defs) = shader_defs {
         for def in shader_defs.iter() {
             options.add_macro_definition(def, None);
         }
     }
 
-    let binary_result = compiler
-        .compile_into_spirv(
-            glsl_source,
-            stage.into(),
-            "shader.glsl",
-            "main",
-            Some(&options),
-        )
-        .unwrap();
+    let binary_result = compiler.compile_into_spirv(
+        glsl_source,
+        stage.into(),
+        "shader.glsl",
+        "main",
+        Some(&options),
+    )?;
 
-    binary_result.as_binary().to_vec()
+    Ok(binary_result.as_binary().to_vec())
 }
 
 fn bytes_to_words(bytes: &[u8]) -> Vec<u32> {
@@ -114,19 +153,19 @@ impl Shader {
     }
 
     #[cfg(not(target_arch = "wasm32"))]
-    pub fn get_spirv(&self, macros: Option<&[String]>) -> Vec<u32> {
+    pub fn get_spirv(&self, macros: Option<&[String]>) -> Result<Vec<u32>, ShaderError> {
         match self.source {
-            ShaderSource::Spirv(ref bytes) => bytes.clone(),
+            ShaderSource::Spirv(ref bytes) => Ok(bytes.clone()),
             ShaderSource::Glsl(ref source) => glsl_to_spirv(&source, self.stage, macros),
         }
     }
 
     #[cfg(not(target_arch = "wasm32"))]
-    pub fn get_spirv_shader(&self, macros: Option<&[String]>) -> Shader {
-        Shader {
-            source: ShaderSource::Spirv(self.get_spirv(macros)),
+    pub fn get_spirv_shader(&self, macros: Option<&[String]>) -> Result<Shader, ShaderError> {
+        Ok(Shader {
+            source: ShaderSource::Spirv(self.get_spirv(macros)?),
             stage: self.stage,
-        }
+        })
     }
 
     #[cfg(not(target_arch = "wasm32"))]
@@ -137,13 +176,13 @@ impl Shader {
                 enforce_bevy_conventions,
             ))
         } else {
-            panic!("Cannot reflect layout of non-SpirV shader. Try compiling this shader to SpirV first using self.get_spirv_shader()");
+            panic!("Cannot reflect layout of non-SpirV shader. Try compiling this shader to SpirV first using self.get_spirv_shader().");
         }
     }
 
     #[cfg(target_arch = "wasm32")]
     pub fn reflect_layout(&self, _enforce_bevy_conventions: bool) -> Option<ShaderLayout> {
-        panic!("Cannot reflect layout on wasm32");
+        panic!("Cannot reflect layout on wasm32.");
     }
 }
 
@@ -188,3 +227,60 @@ impl ShaderStages {
         }
     }
 }
+
+#[derive(Default)]
+pub struct ShaderLoader;
+
+impl AssetLoader for ShaderLoader {
+    fn load<'a>(
+        &'a self,
+        bytes: &'a [u8],
+        load_context: &'a mut LoadContext,
+    ) -> BoxedFuture<'a, Result<(), anyhow::Error>> {
+        Box::pin(async move {
+            let ext = load_context.path().extension().unwrap().to_str().unwrap();
+
+            let shader = match ext {
+                "vert" => Shader::from_glsl(ShaderStage::Vertex, std::str::from_utf8(bytes)?),
+                "frag" => Shader::from_glsl(ShaderStage::Fragment, std::str::from_utf8(bytes)?),
+                _ => panic!("unhandled extension: {}", ext),
+            };
+
+            load_context.set_default_asset(LoadedAsset::new(shader));
+            Ok(())
+        })
+    }
+
+    fn extensions(&self) -> &[&str] {
+        &["vert", "frag"]
+    }
+}
+
+pub fn shader_update_system(
+    mut shaders: ResMut<Assets<Shader>>,
+    mut pipelines: ResMut<Assets<PipelineDescriptor>>,
+    shader_events: Res<Events<AssetEvent<Shader>>>,
+    mut shader_event_reader: Local<EventReader<AssetEvent<Shader>>>,
+    mut pipeline_compiler: ResMut<PipelineCompiler>,
+    render_resource_context: Res<Box<dyn RenderResourceContext>>,
+) {
+    for event in shader_event_reader.iter(&shader_events) {
+        match event {
+            AssetEvent::Modified { handle } => {
+                if let Err(e) = pipeline_compiler.update_shader(
+                    handle,
+                    &mut pipelines,
+                    &mut shaders,
+                    &**render_resource_context,
+                ) {
+                    error!("Failed to update shader: {}", e);
+                }
+            }
+            // Creating shaders on the fly is unhandled since they
+            // have to exist already when assigned to a pipeline. If a
+            // shader is removed the pipeline keeps using its
+            // specialized version. Maybe this should be a warning?
+            AssetEvent::Created { .. } | AssetEvent::Removed { .. } => (),
+        }
+    }
+}
diff --git a/crates/bevy_render/src/shader/shader_defs.rs b/crates/bevy_render/src/shader/shader_defs.rs
index b8ff477745acd..977872462732c 100644
--- a/crates/bevy_render/src/shader/shader_defs.rs
+++ b/crates/bevy_render/src/shader/shader_defs.rs
@@ -98,14 +98,16 @@ pub fn asset_shader_defs_system<T: Asset>(
     T: ShaderDefs + Send + Sync + 'static,
 {
     for (asset_handle, mut render_pipelines) in query.iter_mut() {
-        let shader_defs = assets.get(asset_handle).unwrap();
-        for shader_def in shader_defs.iter_shader_defs() {
-            for render_pipeline in render_pipelines.pipelines.iter_mut() {
-                render_pipeline
-                    .specialization
-                    .shader_specialization
-                    .shader_defs
-                    .insert(shader_def.to_string());
+        if let Some(asset_handle) = assets.get(asset_handle) {
+            let shader_defs = asset_handle;
+            for shader_def in shader_defs.iter_shader_defs() {
+                for render_pipeline in render_pipelines.pipelines.iter_mut() {
+                    render_pipeline
+                        .specialization
+                        .shader_specialization
+                        .shader_defs
+                        .insert(shader_def.to_string());
+                }
             }
         }
     }
diff --git a/crates/bevy_render/src/shader/shader_reflect.rs b/crates/bevy_render/src/shader/shader_reflect.rs
index 2a35d0fb21b49..13bfbeae38386 100644
--- a/crates/bevy_render/src/shader/shader_reflect.rs
+++ b/crates/bevy_render/src/shader/shader_reflect.rs
@@ -84,7 +84,7 @@ impl ShaderLayout {
                     entry_point: entry_point_name,
                 }
             }
-            Err(err) => panic!("Failed to reflect shader layout: {:?}", err),
+            Err(err) => panic!("Failed to reflect shader layout: {:?}.", err),
         }
     }
 }
@@ -108,7 +108,7 @@ fn reflect_dimension(type_description: &ReflectTypeDescription) -> TextureViewDi
         ReflectDimension::Type2d => TextureViewDimension::D2,
         ReflectDimension::Type3d => TextureViewDimension::D3,
         ReflectDimension::Cube => TextureViewDimension::Cube,
-        dimension => panic!("unsupported image dimension: {:?}", dimension),
+        dimension => panic!("Unsupported image dimension: {:?}.", dimension),
     }
 }
 
@@ -142,7 +142,7 @@ fn reflect_binding(
         ),
         // TODO: detect comparison "true" case: https://github.com/gpuweb/gpuweb/issues/552
         ReflectDescriptorType::Sampler => (&binding.name, BindType::Sampler { comparison: false }),
-        _ => panic!("unsupported bind type {:?}", binding.descriptor_type),
+        _ => panic!("Unsupported bind type {:?}.", binding.descriptor_type),
     };
 
     let mut shader_stage = match shader_stage {
@@ -199,7 +199,7 @@ fn reflect_uniform_numeric(type_description: &ReflectTypeDescription) -> Uniform
         match traits.numeric.scalar.signedness {
             0 => NumberType::UInt,
             1 => NumberType::Int,
-            signedness => panic!("unexpected signedness {}", signedness),
+            signedness => panic!("Unexpected signedness {}.", signedness),
         }
     } else if type_description
         .type_flags
@@ -207,7 +207,7 @@ fn reflect_uniform_numeric(type_description: &ReflectTypeDescription) -> Uniform
     {
         NumberType::Float
     } else {
-        panic!("unexpected type flag {:?}", type_description.type_flags);
+        panic!("Unexpected type flag {:?}.", type_description.type_flags);
     };
 
     // TODO: handle scalar width here
@@ -252,7 +252,7 @@ fn reflect_vertex_format(type_description: &ReflectTypeDescription) -> VertexFor
         match traits.numeric.scalar.signedness {
             0 => NumberType::UInt,
             1 => NumberType::Int,
-            signedness => panic!("unexpected signedness {}", signedness),
+            signedness => panic!("Unexpected signedness {}.", signedness),
         }
     } else if type_description
         .type_flags
@@ -260,7 +260,7 @@ fn reflect_vertex_format(type_description: &ReflectTypeDescription) -> VertexFor
     {
         NumberType::Float
     } else {
-        panic!("unexpected type flag {:?}", type_description.type_flags);
+        panic!("Unexpected type flag {:?}.", type_description.type_flags);
     };
 
     let width = traits.numeric.scalar.width;
@@ -328,7 +328,8 @@ mod tests {
             }
         "#,
         )
-        .get_spirv_shader(None);
+        .get_spirv_shader(None)
+        .unwrap();
 
         let layout = vertex_shader.reflect_layout(true).unwrap();
         assert_eq!(
diff --git a/crates/bevy_render/src/texture/hdr_texture_loader.rs b/crates/bevy_render/src/texture/hdr_texture_loader.rs
index f3929892e64cd..da03340ef67ea 100644
--- a/crates/bevy_render/src/texture/hdr_texture_loader.rs
+++ b/crates/bevy_render/src/texture/hdr_texture_loader.rs
@@ -1,7 +1,6 @@
-use super::{Texture, TextureFormat};
+use super::{Extent3d, Texture, TextureDimension, TextureFormat};
 use anyhow::Result;
 use bevy_asset::{AssetLoader, LoadContext, LoadedAsset};
-use bevy_math::Vec2;
 use bevy_utils::BoxedFuture;
 
 /// Loads HDR textures as Texture assets
@@ -37,7 +36,8 @@ impl AssetLoader for HdrTextureLoader {
             }
 
             let texture = Texture::new(
-                Vec2::new(info.width as f32, info.height as f32),
+                Extent3d::new(info.width, info.height, 1),
+                TextureDimension::D2,
                 rgba_data,
                 format,
             );
diff --git a/crates/bevy_render/src/texture/image_texture_loader.rs b/crates/bevy_render/src/texture/image_texture_loader.rs
index 2def1cf6389f0..f866a0751843b 100644
--- a/crates/bevy_render/src/texture/image_texture_loader.rs
+++ b/crates/bevy_render/src/texture/image_texture_loader.rs
@@ -1,7 +1,6 @@
-use super::{Texture, TextureFormat};
+use super::{Extent3d, Texture, TextureDimension, TextureFormat};
 use anyhow::Result;
 use bevy_asset::{AssetLoader, LoadContext, LoadedAsset};
-use bevy_math::Vec2;
 use bevy_utils::BoxedFuture;
 
 /// Loader for images that can be read by the `image` crate.
@@ -10,6 +9,8 @@ use bevy_utils::BoxedFuture;
 #[derive(Clone, Default)]
 pub struct ImageTextureLoader;
 
+const FILE_EXTENSIONS: &[&str] = &["png", "dds", "tga", "jpg", "jpeg"];
+
 impl AssetLoader for ImageTextureLoader {
     fn load<'a>(
         &'a self,
@@ -24,16 +25,15 @@ impl AssetLoader for ImageTextureLoader {
 
             let ext = load_context.path().extension().unwrap().to_str().unwrap();
 
-            // NOTE: If more formats are added they can be added here.
-            let img_format = if ext.eq_ignore_ascii_case("png") {
-                image::ImageFormat::Png
-            } else {
-                panic!(
+            let img_format = image::ImageFormat::from_extension(ext)
+                .ok_or_else(|| {
+                    format!(
                     "Unexpected image format {:?} for file {}, this is an error in `bevy_render`.",
                     ext,
                     load_context.path().display()
                 )
-            };
+                })
+                .unwrap();
 
             // Load the image in the expected format.
             // Some formats like PNG allow for R or RG textures too, so the texture
@@ -148,13 +148,18 @@ impl AssetLoader for ImageTextureLoader {
                 }
             }
 
-            let texture = Texture::new(Vec2::new(width as f32, height as f32), data, format);
+            let texture = Texture::new(
+                Extent3d::new(width, height, 1),
+                TextureDimension::D2,
+                data,
+                format,
+            );
             load_context.set_default_asset(LoadedAsset::new(texture));
             Ok(())
         })
     }
 
     fn extensions(&self) -> &[&str] {
-        &["png"]
+        FILE_EXTENSIONS
     }
 }
diff --git a/crates/bevy_render/src/texture/texture.rs b/crates/bevy_render/src/texture/texture.rs
index 4a39f365b4c2f..89d07ddbdb3b2 100644
--- a/crates/bevy_render/src/texture/texture.rs
+++ b/crates/bevy_render/src/texture/texture.rs
@@ -1,12 +1,11 @@
-use super::{SamplerDescriptor, TextureDescriptor, TextureFormat};
+use super::{Extent3d, SamplerDescriptor, TextureDescriptor, TextureDimension, TextureFormat};
 use crate::renderer::{
     RenderResource, RenderResourceContext, RenderResourceId, RenderResourceType,
 };
 use bevy_app::prelude::{EventReader, Events};
 use bevy_asset::{AssetEvent, Assets, Handle};
 use bevy_ecs::{Res, ResMut};
-use bevy_math::Vec2;
-use bevy_type_registry::TypeUuid;
+use bevy_reflect::TypeUuid;
 use bevy_utils::HashSet;
 
 pub const TEXTURE_ASSET_INDEX: u64 = 0;
@@ -16,8 +15,9 @@ pub const SAMPLER_ASSET_INDEX: u64 = 1;
 #[uuid = "6ea26da6-6cf8-4ea2-9986-1d7bf6c17d6f"]
 pub struct Texture {
     pub data: Vec<u8>,
-    pub size: Vec2,
+    pub size: Extent3d,
     pub format: TextureFormat,
+    pub dimension: TextureDimension,
     pub sampler: SamplerDescriptor,
 }
 
@@ -25,31 +25,48 @@ impl Default for Texture {
     fn default() -> Self {
         Texture {
             data: Default::default(),
-            size: Default::default(),
+            size: Extent3d {
+                width: 1,
+                height: 1,
+                depth: 1,
+            },
             format: TextureFormat::Rgba8UnormSrgb,
+            dimension: TextureDimension::D2,
             sampler: Default::default(),
         }
     }
 }
 
 impl Texture {
-    pub fn new(size: Vec2, data: Vec<u8>, format: TextureFormat) -> Self {
+    pub fn new(
+        size: Extent3d,
+        dimension: TextureDimension,
+        data: Vec<u8>,
+        format: TextureFormat,
+    ) -> Self {
         debug_assert_eq!(
-            size.x as usize * size.y as usize * format.pixel_size(),
+            size.volume() * format.pixel_size(),
             data.len(),
             "Pixel data, size and format have to match",
         );
         Self {
             data,
             size,
+            dimension,
             format,
             ..Default::default()
         }
     }
 
-    pub fn new_fill(size: Vec2, pixel: &[u8], format: TextureFormat) -> Self {
+    pub fn new_fill(
+        size: Extent3d,
+        dimension: TextureDimension,
+        pixel: &[u8],
+        format: TextureFormat,
+    ) -> Self {
         let mut value = Texture {
             format,
+            dimension,
             ..Default::default()
         };
         value.resize(size);
@@ -57,11 +74,11 @@ impl Texture {
         debug_assert_eq!(
             pixel.len() % format.pixel_size(),
             0,
-            "Must not have incomplete pixel data"
+            "Must not have incomplete pixel data."
         );
         debug_assert!(
             pixel.len() <= value.data.len(),
-            "Fill data must fit within pixel buffer"
+            "Fill data must fit within pixel buffer."
         );
 
         for current_pixel in value.data.chunks_exact_mut(pixel.len()) {
@@ -70,16 +87,42 @@ impl Texture {
         value
     }
 
-    pub fn aspect(&self) -> f32 {
-        self.size.y / self.size.x
+    pub fn aspect_2d(&self) -> f32 {
+        self.size.height as f32 / self.size.width as f32
     }
 
-    pub fn resize(&mut self, size: Vec2) {
+    pub fn resize(&mut self, size: Extent3d) {
         self.size = size;
-        let width = size.x as usize;
-        let height = size.y as usize;
         self.data
-            .resize(width * height * self.format.pixel_size(), 0);
+            .resize(size.volume() * self.format.pixel_size(), 0);
+    }
+
+    /// Changes the `size`, asserting that the total number of data elements (pixels) remains the same.
+    pub fn reinterpret_size(&mut self, new_size: Extent3d) {
+        assert!(
+            new_size.volume() == self.size.volume(),
+            "Incompatible sizes: old = {:?} new = {:?}",
+            self.size,
+            new_size
+        );
+
+        self.size = new_size;
+    }
+
+    /// Takes a 2D texture containing vertically stacked images of the same size, and reinterprets it as a 2D array texture,
+    /// where each of the stacked images becomes one layer of the array. This is primarily for use with the `texture2DArray`
+    /// shader uniform type.
+    pub fn reinterpret_stacked_2d_as_array(&mut self, layers: u32) {
+        // Must be a stacked image, and the height must be divisible by layers.
+        assert!(self.dimension == TextureDimension::D2);
+        assert!(self.size.depth == 1);
+        assert_eq!(self.size.height % layers, 0);
+
+        self.reinterpret_size(Extent3d {
+            width: self.size.width,
+            height: self.size.height / layers,
+            depth: layers,
+        });
     }
 
     pub fn texture_resource_system(
diff --git a/crates/bevy_render/src/texture/texture_descriptor.rs b/crates/bevy_render/src/texture/texture_descriptor.rs
index 82515d4f89176..15ab341ccda56 100644
--- a/crates/bevy_render/src/texture/texture_descriptor.rs
+++ b/crates/bevy_render/src/texture/texture_descriptor.rs
@@ -14,14 +14,10 @@ pub struct TextureDescriptor {
 impl From<&Texture> for TextureDescriptor {
     fn from(texture: &Texture) -> Self {
         TextureDescriptor {
-            size: Extent3d {
-                width: texture.size.x as u32,
-                height: texture.size.y as u32,
-                depth: 1,
-            },
+            size: texture.size,
             mip_level_count: 1,
             sample_count: 1,
-            dimension: TextureDimension::D2,
+            dimension: texture.dimension,
             format: texture.format,
             usage: TextureUsage::SAMPLED | TextureUsage::COPY_DST,
         }
diff --git a/crates/bevy_render/src/texture/texture_dimension.rs b/crates/bevy_render/src/texture/texture_dimension.rs
index 77e8b42262b42..d230be2303c7e 100644
--- a/crates/bevy_render/src/texture/texture_dimension.rs
+++ b/crates/bevy_render/src/texture/texture_dimension.rs
@@ -1,5 +1,7 @@
 // NOTE: These are currently just copies of the wgpu types, but they might change in the future
 
+use bevy_math::Vec3;
+
 /// Dimensions of a particular texture view.
 #[derive(Copy, Clone, Debug, Hash, Eq, PartialEq, Ord, PartialOrd)]
 pub enum TextureViewDimension {
@@ -27,6 +29,24 @@ pub struct Extent3d {
     pub depth: u32,
 }
 
+impl Extent3d {
+    pub fn new(width: u32, height: u32, depth: u32) -> Self {
+        Self {
+            width,
+            height,
+            depth,
+        }
+    }
+
+    pub fn volume(&self) -> usize {
+        (self.width * self.height * self.depth) as usize
+    }
+
+    pub fn as_vec3(&self) -> Vec3 {
+        Vec3::new(self.width as f32, self.height as f32, self.depth as f32)
+    }
+}
+
 /// Type of data shaders will read from a texture.
 #[derive(Copy, Hash, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
 pub enum TextureComponentType {
diff --git a/crates/bevy_scene/Cargo.toml b/crates/bevy_scene/Cargo.toml
index 855a9b13e9bd4..a6d862f6e88fc 100644
--- a/crates/bevy_scene/Cargo.toml
+++ b/crates/bevy_scene/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_scene"
-version = "0.3.0"
+version = "0.4.0"
 edition = "2018"
 authors = [
     "Bevy Contributors <bevyengine@gmail.com>",
@@ -14,12 +14,12 @@ keywords = ["bevy"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.3.0" }
-bevy_asset = { path = "../bevy_asset", version = "0.3.0" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.3.0" }
-bevy_property = { path = "../bevy_property", version = "0.3.0" }
-bevy_type_registry = { path = "../bevy_type_registry", version = "0.3.0" }
-bevy_utils = { path = "../bevy_utils", version = "0.3.0" }
+bevy_app = { path = "../bevy_app", version = "0.4.0" }
+bevy_asset = { path = "../bevy_asset", version = "0.4.0" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.4.0" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.4.0", features = ["bevy"] }
+bevy_transform = { path = "../bevy_transform", version = "0.4.0" }
+bevy_utils = { path = "../bevy_utils", version = "0.4.0" }
 
 # other
 serde = { version = "1.0", features = ["derive"] }
diff --git a/crates/bevy_scene/src/command.rs b/crates/bevy_scene/src/command.rs
index 3c9c6ec2526ee..54efbd552a12c 100644
--- a/crates/bevy_scene/src/command.rs
+++ b/crates/bevy_scene/src/command.rs
@@ -1,5 +1,6 @@
 use bevy_asset::Handle;
-use bevy_ecs::{Command, Commands, Resources, World};
+use bevy_ecs::{Command, Commands, Entity, Resources, World};
+use bevy_transform::hierarchy::ChildBuilder;
 
 use crate::{Scene, SceneSpawner};
 
@@ -23,3 +24,29 @@ impl SpawnSceneCommands for Commands {
         self.add_command(SpawnScene { scene_handle })
     }
 }
+
+pub struct SpawnSceneAsChild {
+    scene_handle: Handle<Scene>,
+    parent: Entity,
+}
+
+impl Command for SpawnSceneAsChild {
+    fn write(self: Box<Self>, _world: &mut World, resources: &mut Resources) {
+        let mut spawner = resources.get_mut::<SceneSpawner>().unwrap();
+        spawner.spawn_as_child(self.scene_handle, self.parent);
+    }
+}
+
+pub trait SpawnSceneAsChildCommands {
+    fn spawn_scene(&mut self, scene: Handle<Scene>) -> &mut Self;
+}
+
+impl<'a> SpawnSceneAsChildCommands for ChildBuilder<'a> {
+    fn spawn_scene(&mut self, scene_handle: Handle<Scene>) -> &mut Self {
+        self.add_command(SpawnSceneAsChild {
+            scene_handle,
+            parent: self.parent_entity(),
+        });
+        self
+    }
+}
diff --git a/crates/bevy_scene/src/dynamic_scene.rs b/crates/bevy_scene/src/dynamic_scene.rs
index f8ed4bbb0d55a..da6b4915ba406 100644
--- a/crates/bevy_scene/src/dynamic_scene.rs
+++ b/crates/bevy_scene/src/dynamic_scene.rs
@@ -1,14 +1,13 @@
 use crate::{serde::SceneSerializer, Scene};
 use anyhow::Result;
 use bevy_ecs::{EntityMap, Resources, World};
-use bevy_property::{DynamicProperties, PropertyTypeRegistry};
-use bevy_type_registry::{ComponentRegistry, TypeRegistry, TypeUuid};
+use bevy_reflect::{Reflect, ReflectComponent, ReflectMapEntities, TypeRegistryArc, TypeUuid};
 use serde::Serialize;
 use thiserror::Error;
 
 #[derive(Error, Debug)]
 pub enum DynamicSceneToWorldError {
-    #[error("Scene contains an unregistered component.")]
+    #[error("scene contains an unregistered component")]
     UnregisteredComponent { type_name: String },
 }
 
@@ -20,16 +19,17 @@ pub struct DynamicScene {
 
 pub struct Entity {
     pub entity: u32,
-    pub components: Vec<DynamicProperties>,
+    pub components: Vec<Box<dyn Reflect>>,
 }
 
 impl DynamicScene {
-    pub fn from_scene(scene: &Scene, component_registry: &ComponentRegistry) -> Self {
-        Self::from_world(&scene.world, component_registry)
+    pub fn from_scene(scene: &Scene, type_registry: &TypeRegistryArc) -> Self {
+        Self::from_world(&scene.world, type_registry)
     }
 
-    pub fn from_world(world: &World, component_registry: &ComponentRegistry) -> Self {
+    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() {
@@ -40,11 +40,15 @@ impl DynamicScene {
                     })
                 }
                 for type_info in archetype.types() {
-                    if let Some(component_registration) = component_registry.get(&type_info.id()) {
-                        let properties =
-                            component_registration.get_component_properties(&archetype, index);
-
-                        entities[index].components.push(properties.to_dynamic());
+                    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());
+                            }
+                        }
                     }
                 }
             }
@@ -60,38 +64,45 @@ impl DynamicScene {
         world: &mut World,
         resources: &Resources,
     ) -> Result<(), DynamicSceneToWorldError> {
-        let type_registry = resources.get::<TypeRegistry>().unwrap();
-        let component_registry = type_registry.component.read();
+        let type_registry = resources.get::<TypeRegistryArc>().unwrap();
+        let type_registry = type_registry.read();
         let mut entity_map = EntityMap::default();
         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);
             for component in scene_entity.components.iter() {
-                let component_registration = component_registry
-                    .get_with_name(&component.type_name)
+                let registration = type_registry
+                    .get_with_name(component.type_name())
                     .ok_or_else(|| DynamicSceneToWorldError::UnregisteredComponent {
-                        type_name: component.type_name.to_string(),
+                        type_name: component.type_name().to_string(),
+                    })?;
+                let reflect_component =
+                    registration.data::<ReflectComponent>().ok_or_else(|| {
+                        DynamicSceneToWorldError::UnregisteredComponent {
+                            type_name: component.type_name().to_string(),
+                        }
                     })?;
-                if world.has_component_type(new_entity, component_registration.ty) {
-                    component_registration.apply_property_to_entity(world, new_entity, component);
+                if world.has_component_type(new_entity, registration.type_id()) {
+                    reflect_component.apply_component(world, new_entity, &**component);
                 } else {
-                    component_registration
-                        .add_property_to_entity(world, resources, new_entity, component);
+                    reflect_component.add_component(world, resources, new_entity, &**component);
                 }
             }
         }
 
-        for component_registration in component_registry.iter() {
-            component_registration
-                .map_entities(world, &entity_map)
-                .unwrap();
+        for registration in type_registry.iter() {
+            if let Some(map_entities_reflect) = registration.data::<ReflectMapEntities>() {
+                map_entities_reflect
+                    .map_entities(world, &entity_map)
+                    .unwrap();
+            }
         }
 
         Ok(())
     }
 
     // TODO: move to AssetSaver when it is implemented
-    pub fn serialize_ron(&self, registry: &PropertyTypeRegistry) -> Result<String, ron::Error> {
+    pub fn serialize_ron(&self, registry: &TypeRegistryArc) -> Result<String, ron::Error> {
         serialize_ron(SceneSerializer::new(self, registry))
     }
 
diff --git a/crates/bevy_scene/src/lib.rs b/crates/bevy_scene/src/lib.rs
index 6fec4e5b6a660..349007910a808 100644
--- a/crates/bevy_scene/src/lib.rs
+++ b/crates/bevy_scene/src/lib.rs
@@ -5,6 +5,7 @@ mod scene_loader;
 mod scene_spawner;
 pub mod serde;
 
+use bevy_ecs::{IntoSystem, SystemStage};
 pub use command::*;
 pub use dynamic_scene::*;
 pub use scene::*;
@@ -12,7 +13,9 @@ pub use scene_loader::*;
 pub use scene_spawner::*;
 
 pub mod prelude {
-    pub use crate::{DynamicScene, Scene, SceneSpawner, SpawnSceneCommands};
+    pub use crate::{
+        DynamicScene, Scene, SceneSpawner, SpawnSceneAsChildCommands, SpawnSceneCommands,
+    };
 }
 
 use bevy_app::prelude::*;
@@ -29,7 +32,7 @@ impl Plugin for ScenePlugin {
             .add_asset::<Scene>()
             .init_asset_loader::<SceneLoader>()
             .init_resource::<SceneSpawner>()
-            .add_stage_after(stage::EVENT, SCENE_STAGE)
-            .add_system_to_stage(SCENE_STAGE, scene_spawner_system);
+            .add_stage_after(stage::EVENT, SCENE_STAGE, SystemStage::parallel())
+            .add_system_to_stage(SCENE_STAGE, scene_spawner_system.system());
     }
 }
diff --git a/crates/bevy_scene/src/scene.rs b/crates/bevy_scene/src/scene.rs
index 29b67211e8541..028ba75ad71fa 100644
--- a/crates/bevy_scene/src/scene.rs
+++ b/crates/bevy_scene/src/scene.rs
@@ -1,5 +1,5 @@
 use bevy_ecs::World;
-use bevy_type_registry::TypeUuid;
+use bevy_reflect::TypeUuid;
 
 #[derive(Debug, TypeUuid)]
 #[uuid = "c156503c-edd9-4ec7-8d33-dab392df03cd"]
diff --git a/crates/bevy_scene/src/scene_loader.rs b/crates/bevy_scene/src/scene_loader.rs
index 2daa54475fee2..4ff76330e12d9 100644
--- a/crates/bevy_scene/src/scene_loader.rs
+++ b/crates/bevy_scene/src/scene_loader.rs
@@ -2,23 +2,20 @@ use crate::serde::SceneDeserializer;
 use anyhow::Result;
 use bevy_asset::{AssetLoader, LoadContext, LoadedAsset};
 use bevy_ecs::{FromResources, Resources};
-use bevy_property::PropertyTypeRegistry;
-use bevy_type_registry::TypeRegistry;
+use bevy_reflect::TypeRegistryArc;
 use bevy_utils::BoxedFuture;
-use parking_lot::RwLock;
 use serde::de::DeserializeSeed;
-use std::sync::Arc;
 
 #[derive(Debug)]
 pub struct SceneLoader {
-    property_type_registry: Arc<RwLock<PropertyTypeRegistry>>,
+    type_registry: TypeRegistryArc,
 }
 
 impl FromResources for SceneLoader {
     fn from_resources(resources: &Resources) -> Self {
-        let type_registry = resources.get::<TypeRegistry>().unwrap();
+        let type_registry = resources.get::<TypeRegistryArc>().unwrap();
         SceneLoader {
-            property_type_registry: type_registry.property.clone(),
+            type_registry: (&*type_registry).clone(),
         }
     }
 }
@@ -30,10 +27,9 @@ impl AssetLoader for SceneLoader {
         load_context: &'a mut LoadContext,
     ) -> BoxedFuture<'a, Result<()>> {
         Box::pin(async move {
-            let registry = self.property_type_registry.read();
             let mut deserializer = ron::de::Deserializer::from_bytes(&bytes)?;
             let scene_deserializer = SceneDeserializer {
-                property_type_registry: &registry,
+                type_registry: &*self.type_registry.read(),
             };
             let scene = scene_deserializer.deserialize(&mut deserializer)?;
             load_context.set_default_asset(LoadedAsset::new(scene));
diff --git a/crates/bevy_scene/src/scene_spawner.rs b/crates/bevy_scene/src/scene_spawner.rs
index 48eb32e8071d2..428eda2920452 100644
--- a/crates/bevy_scene/src/scene_spawner.rs
+++ b/crates/bevy_scene/src/scene_spawner.rs
@@ -1,8 +1,9 @@
 use crate::{DynamicScene, Scene};
 use bevy_app::prelude::*;
 use bevy_asset::{AssetEvent, Assets, Handle};
-use bevy_ecs::{EntityMap, Resources, World};
-use bevy_type_registry::TypeRegistry;
+use bevy_ecs::{Entity, EntityMap, Resources, World};
+use bevy_reflect::{ReflectComponent, ReflectMapEntities, TypeRegistryArc};
+use bevy_transform::prelude::Parent;
 use bevy_utils::HashMap;
 use thiserror::Error;
 use uuid::Uuid;
@@ -28,17 +29,20 @@ pub struct SceneSpawner {
     spawned_instances: HashMap<InstanceId, InstanceInfo>,
     scene_asset_event_reader: EventReader<AssetEvent<DynamicScene>>,
     dynamic_scenes_to_spawn: Vec<Handle<DynamicScene>>,
-    scenes_to_spawn: Vec<Handle<Scene>>,
+    scenes_to_spawn: Vec<(Handle<Scene>, InstanceId)>,
     scenes_to_despawn: Vec<Handle<DynamicScene>>,
+    scenes_with_parent: Vec<(InstanceId, Entity)>,
 }
 
 #[derive(Error, Debug)]
 pub enum SceneSpawnError {
-    #[error("Scene contains an unregistered component.")]
+    #[error("scene contains the unregistered component `{type_name}`. consider adding `#[reflect(Component)]` to your type")]
     UnregisteredComponent { type_name: String },
-    #[error("Scene does not exist. Perhaps it is still loading?")]
+    #[error("scene contains the unregistered type `{type_name}`. consider registering the type using `app.register_type::<T>()`")]
+    UnregisteredType { type_name: String },
+    #[error("scene does not exist")]
     NonExistentScene { handle: Handle<DynamicScene> },
-    #[error("Scene does not exist. Perhaps it is still loading?")]
+    #[error("scene does not exist")]
     NonExistentRealScene { handle: Handle<Scene> },
 }
 
@@ -48,7 +52,14 @@ impl SceneSpawner {
     }
 
     pub fn spawn(&mut self, scene_handle: Handle<Scene>) {
-        self.scenes_to_spawn.push(scene_handle);
+        let instance_id = InstanceId::new();
+        self.scenes_to_spawn.push((scene_handle, instance_id));
+    }
+
+    pub fn spawn_as_child(&mut self, scene_handle: Handle<Scene>, parent: Entity) {
+        let instance_id = InstanceId::new();
+        self.scenes_to_spawn.push((scene_handle, instance_id));
+        self.scenes_with_parent.push((instance_id, parent));
     }
 
     pub fn despawn(&mut self, scene_handle: Handle<DynamicScene>) {
@@ -100,8 +111,8 @@ impl SceneSpawner {
         scene_handle: &Handle<DynamicScene>,
         instance_info: &mut InstanceInfo,
     ) -> Result<(), SceneSpawnError> {
-        let type_registry = resources.get::<TypeRegistry>().unwrap();
-        let component_registry = type_registry.component.read();
+        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)
@@ -116,18 +127,23 @@ impl SceneSpawner {
                 .entry(bevy_ecs::Entity::new(scene_entity.entity))
                 .or_insert_with(|| world.reserve_entity());
             for component in scene_entity.components.iter() {
-                let component_registration = component_registry
-                    .get_with_name(&component.type_name)
-                    .ok_or(SceneSpawnError::UnregisteredComponent {
-                        type_name: component.type_name.to_string(),
+                let registration = type_registry
+                    .get_with_name(component.type_name())
+                    .ok_or_else(|| SceneSpawnError::UnregisteredType {
+                        type_name: component.type_name().to_string(),
                     })?;
-                if world.has_component_type(entity, component_registration.ty) {
-                    if component.type_name != "Camera" {
-                        component_registration.apply_property_to_entity(world, entity, component);
+                let reflect_component =
+                    registration.data::<ReflectComponent>().ok_or_else(|| {
+                        SceneSpawnError::UnregisteredComponent {
+                            type_name: component.type_name().to_string(),
+                        }
+                    })?;
+                if world.has_component_type(entity, registration.type_id()) {
+                    if registration.short_name() != "Camera" {
+                        reflect_component.apply_component(world, entity, &**component);
                     }
                 } else {
-                    component_registration
-                        .add_property_to_entity(world, resources, entity, component);
+                    reflect_component.add_component(world, resources, entity, &**component);
                 }
             }
         }
@@ -140,12 +156,21 @@ impl SceneSpawner {
         resources: &Resources,
         scene_handle: Handle<Scene>,
     ) -> Result<(), SceneSpawnError> {
-        let instance_id = InstanceId::new();
+        self.spawn_sync_internal(world, resources, scene_handle, InstanceId::new())
+    }
+
+    fn spawn_sync_internal(
+        &mut self,
+        world: &mut World,
+        resources: &Resources,
+        scene_handle: Handle<Scene>,
+        instance_id: InstanceId,
+    ) -> Result<(), SceneSpawnError> {
         let mut instance_info = InstanceInfo {
             entity_map: EntityMap::default(),
         };
-        let type_registry = resources.get::<TypeRegistry>().unwrap();
-        let component_registry = type_registry.component.read();
+        let type_registry = resources.get::<TypeRegistryArc>().unwrap();
+        let type_registry = type_registry.read();
         let scenes = resources.get::<Assets<Scene>>().unwrap();
         let scene =
             scenes
@@ -161,22 +186,33 @@ impl SceneSpawner {
                     .entry(*scene_entity)
                     .or_insert_with(|| world.reserve_entity());
                 for type_info in archetype.types() {
-                    if let Some(component_registration) = component_registry.get(&type_info.id()) {
-                        component_registration.component_copy(
-                            &scene.world,
-                            world,
-                            resources,
-                            *scene_entity,
-                            entity,
-                        );
-                    }
+                    let registration = type_registry.get(type_info.id()).ok_or_else(|| {
+                        SceneSpawnError::UnregisteredType {
+                            type_name: type_info.type_name().to_string(),
+                        }
+                    })?;
+                    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 component_registration in component_registry.iter() {
-            component_registration
-                .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
@@ -238,11 +274,11 @@ impl SceneSpawner {
 
         let scenes_to_spawn = std::mem::take(&mut self.scenes_to_spawn);
 
-        for scene_handle in scenes_to_spawn {
-            match self.spawn_sync(world, resources, scene_handle) {
+        for (scene_handle, instance_id) in scenes_to_spawn {
+            match self.spawn_sync_internal(world, resources, scene_handle, instance_id) {
                 Ok(_) => {}
                 Err(SceneSpawnError::NonExistentRealScene { handle }) => {
-                    self.scenes_to_spawn.push(handle)
+                    self.scenes_to_spawn.push((handle, instance_id))
                 }
                 Err(err) => return Err(err),
             }
@@ -250,6 +286,24 @@ impl SceneSpawner {
 
         Ok(())
     }
+
+    pub(crate) fn set_scene_instance_parent_sync(&mut self, world: &mut World) {
+        let scenes_with_parent = std::mem::take(&mut self.scenes_with_parent);
+
+        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));
+                    }
+                }
+            } else {
+                self.scenes_with_parent.push((instance_id, parent));
+            }
+        }
+    }
 }
 
 pub fn scene_spawner_system(world: &mut World, resources: &mut Resources) {
@@ -269,8 +323,11 @@ pub fn scene_spawner_system(world: &mut World, resources: &mut Resources) {
     }
 
     scene_spawner.despawn_queued_scenes(world).unwrap();
-    scene_spawner.spawn_queued_scenes(world, resources).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);
 }
diff --git a/crates/bevy_scene/src/serde.rs b/crates/bevy_scene/src/serde.rs
index 8a9a47c3bf42a..46f7f03f9b39e 100644
--- a/crates/bevy_scene/src/serde.rs
+++ b/crates/bevy_scene/src/serde.rs
@@ -1,8 +1,8 @@
 use crate::{DynamicScene, Entity};
 use anyhow::Result;
-use bevy_property::{
-    property_serde::{DynamicPropertiesDeserializer, DynamicPropertiesSerializer},
-    DynamicProperties, PropertyTypeRegistry,
+use bevy_reflect::{
+    serde::{ReflectDeserializer, ReflectSerializer},
+    Reflect, TypeRegistry, TypeRegistryArc,
 };
 use serde::{
     de::{DeserializeSeed, Error, MapAccess, SeqAccess, Visitor},
@@ -12,11 +12,11 @@ use serde::{
 
 pub struct SceneSerializer<'a> {
     pub scene: &'a DynamicScene,
-    pub registry: &'a PropertyTypeRegistry,
+    pub registry: &'a TypeRegistryArc,
 }
 
 impl<'a> SceneSerializer<'a> {
-    pub fn new(scene: &'a DynamicScene, registry: &'a PropertyTypeRegistry) -> Self {
+    pub fn new(scene: &'a DynamicScene, registry: &'a TypeRegistryArc) -> Self {
         SceneSerializer { scene, registry }
     }
 }
@@ -39,7 +39,7 @@ impl<'a> Serialize for SceneSerializer<'a> {
 
 pub struct EntitySerializer<'a> {
     pub entity: &'a Entity,
-    pub registry: &'a PropertyTypeRegistry,
+    pub registry: &'a TypeRegistryArc,
 }
 
 impl<'a> Serialize for EntitySerializer<'a> {
@@ -61,8 +61,8 @@ impl<'a> Serialize for EntitySerializer<'a> {
 }
 
 pub struct ComponentsSerializer<'a> {
-    pub components: &'a [DynamicProperties],
-    pub registry: &'a PropertyTypeRegistry,
+    pub components: &'a [Box<dyn Reflect>],
+    pub registry: &'a TypeRegistryArc,
 }
 
 impl<'a> Serialize for ComponentsSerializer<'a> {
@@ -71,10 +71,10 @@ impl<'a> Serialize for ComponentsSerializer<'a> {
         S: serde::Serializer,
     {
         let mut state = serializer.serialize_seq(Some(self.components.len()))?;
-        for dynamic_properties in self.components.iter() {
-            state.serialize_element(&DynamicPropertiesSerializer::new(
-                dynamic_properties,
-                self.registry,
+        for component in self.components.iter() {
+            state.serialize_element(&ReflectSerializer::new(
+                &**component,
+                &*self.registry.read(),
             ))?;
         }
         state.end()
@@ -82,7 +82,7 @@ impl<'a> Serialize for ComponentsSerializer<'a> {
 }
 
 pub struct SceneDeserializer<'a> {
-    pub property_type_registry: &'a PropertyTypeRegistry,
+    pub type_registry: &'a TypeRegistry,
 }
 
 impl<'a, 'de> DeserializeSeed<'de> for SceneDeserializer<'a> {
@@ -94,14 +94,14 @@ impl<'a, 'de> DeserializeSeed<'de> for SceneDeserializer<'a> {
     {
         Ok(DynamicScene {
             entities: deserializer.deserialize_seq(SceneEntitySeqVisitor {
-                property_type_registry: self.property_type_registry,
+                type_registry: self.type_registry,
             })?,
         })
     }
 }
 
 struct SceneEntitySeqVisitor<'a> {
-    pub property_type_registry: &'a PropertyTypeRegistry,
+    pub type_registry: &'a TypeRegistry,
 }
 
 impl<'a, 'de> Visitor<'de> for SceneEntitySeqVisitor<'a> {
@@ -117,7 +117,7 @@ impl<'a, 'de> Visitor<'de> for SceneEntitySeqVisitor<'a> {
     {
         let mut entities = Vec::new();
         while let Some(entity) = seq.next_element_seed(SceneEntityDeserializer {
-            property_type_registry: self.property_type_registry,
+            type_registry: self.type_registry,
         })? {
             entities.push(entity);
         }
@@ -127,7 +127,7 @@ impl<'a, 'de> Visitor<'de> for SceneEntitySeqVisitor<'a> {
 }
 
 pub struct SceneEntityDeserializer<'a> {
-    pub property_type_registry: &'a PropertyTypeRegistry,
+    pub type_registry: &'a TypeRegistry,
 }
 
 impl<'a, 'de> DeserializeSeed<'de> for SceneEntityDeserializer<'a> {
@@ -141,7 +141,7 @@ impl<'a, 'de> DeserializeSeed<'de> for SceneEntityDeserializer<'a> {
             ENTITY_STRUCT,
             &[ENTITY_FIELD_ENTITY, ENTITY_FIELD_COMPONENTS],
             SceneEntityVisitor {
-                registry: self.property_type_registry,
+                registry: self.type_registry,
             },
         )
     }
@@ -158,9 +158,8 @@ pub const ENTITY_STRUCT: &str = "Entity";
 pub const ENTITY_FIELD_ENTITY: &str = "entity";
 pub const ENTITY_FIELD_COMPONENTS: &str = "components";
 
-#[derive(Debug)]
 struct SceneEntityVisitor<'a> {
-    pub registry: &'a PropertyTypeRegistry,
+    pub registry: &'a TypeRegistry,
 }
 
 impl<'a, 'de> Visitor<'de> for SceneEntityVisitor<'a> {
@@ -211,11 +210,11 @@ impl<'a, 'de> Visitor<'de> for SceneEntityVisitor<'a> {
 }
 
 pub struct ComponentVecDeserializer<'a> {
-    pub registry: &'a PropertyTypeRegistry,
+    pub registry: &'a TypeRegistry,
 }
 
 impl<'a, 'de> DeserializeSeed<'de> for ComponentVecDeserializer<'a> {
-    type Value = Vec<DynamicProperties>;
+    type Value = Vec<Box<dyn Reflect>>;
 
     fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
     where
@@ -228,11 +227,11 @@ impl<'a, 'de> DeserializeSeed<'de> for ComponentVecDeserializer<'a> {
 }
 
 struct ComponentSeqVisitor<'a> {
-    pub registry: &'a PropertyTypeRegistry,
+    pub registry: &'a TypeRegistry,
 }
 
 impl<'a, 'de> Visitor<'de> for ComponentSeqVisitor<'a> {
-    type Value = Vec<DynamicProperties>;
+    type Value = Vec<Box<dyn Reflect>>;
 
     fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
         formatter.write_str("list of components")
@@ -243,9 +242,7 @@ impl<'a, 'de> Visitor<'de> for ComponentSeqVisitor<'a> {
         A: SeqAccess<'de>,
     {
         let mut dynamic_properties = Vec::new();
-        while let Some(entity) =
-            seq.next_element_seed(DynamicPropertiesDeserializer::new(self.registry))?
-        {
+        while let Some(entity) = seq.next_element_seed(ReflectDeserializer::new(self.registry))? {
             dynamic_properties.push(entity);
         }
 
diff --git a/crates/bevy_sprite/Cargo.toml b/crates/bevy_sprite/Cargo.toml
index 58b5a5ac4b42b..57f35d7ec3273 100644
--- a/crates/bevy_sprite/Cargo.toml
+++ b/crates/bevy_sprite/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_sprite"
-version = "0.3.0"
+version = "0.4.0"
 edition = "2018"
 authors = [
     "Bevy Contributors <bevyengine@gmail.com>",
@@ -14,17 +14,18 @@ keywords = ["bevy"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.3.0" }
-bevy_asset = { path = "../bevy_asset", version = "0.3.0" }
-bevy_core = { path = "../bevy_core", version = "0.3.0" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.3.0" }
-bevy_math = { path = "../bevy_math", version = "0.3.0" }
-bevy_render = { path = "../bevy_render", version = "0.3.0" }
-bevy_transform = { path = "../bevy_transform", version = "0.3.0" }
-bevy_type_registry = { path = "../bevy_type_registry", version = "0.3.0" }
-bevy_utils = { path = "../bevy_utils", version = "0.3.0" }
+bevy_app = { path = "../bevy_app", version = "0.4.0" }
+bevy_asset = { path = "../bevy_asset", version = "0.4.0" }
+bevy_core = { path = "../bevy_core", version = "0.4.0" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.4.0" }
+bevy_math = { path = "../bevy_math", version = "0.4.0" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.4.0", features = ["bevy"] }
+bevy_render = { path = "../bevy_render", version = "0.4.0" }
+bevy_transform = { path = "../bevy_transform", version = "0.4.0" }
+bevy_utils = { path = "../bevy_utils", version = "0.4.0" }
 
 # other
 rectangle-pack = "0.2"
 thiserror = "1.0"
 guillotiere = "0.6.0"
+serde = { version = "1", features = ["derive"] }
diff --git a/crates/bevy_sprite/src/collide_aabb.rs b/crates/bevy_sprite/src/collide_aabb.rs
index 489fdfd2c931c..096ed84ed053e 100644
--- a/crates/bevy_sprite/src/collide_aabb.rs
+++ b/crates/bevy_sprite/src/collide_aabb.rs
@@ -42,7 +42,7 @@ pub fn collide(a_pos: Vec3, a_size: Vec2, b_pos: Vec3, b_size: Vec2) -> Option<C
         // if we had an "x" and a "y" collision, pick the "primary" side using penetration depth
         match (x_collision, y_collision) {
             (Some(x_collision), Some(y_collision)) => {
-                if y_depth < x_depth {
+                if y_depth.abs() < x_depth.abs() {
                     Some(y_collision)
                 } else {
                     Some(x_collision)
diff --git a/crates/bevy_sprite/src/color_material.rs b/crates/bevy_sprite/src/color_material.rs
index 28a618b03b2fb..e82e75f21e54e 100644
--- a/crates/bevy_sprite/src/color_material.rs
+++ b/crates/bevy_sprite/src/color_material.rs
@@ -1,6 +1,6 @@
 use bevy_asset::{self, Handle};
+use bevy_reflect::TypeUuid;
 use bevy_render::{color::Color, renderer::RenderResources, shader::ShaderDefs, texture::Texture};
-use bevy_type_registry::TypeUuid;
 
 #[derive(Debug, RenderResources, ShaderDefs, TypeUuid)]
 #[uuid = "506cff92-a9f3-4543-862d-6851c7fdfc99"]
diff --git a/crates/bevy_sprite/src/dynamic_texture_atlas_builder.rs b/crates/bevy_sprite/src/dynamic_texture_atlas_builder.rs
index be5cdd2c27c95..8fc4827523c77 100644
--- a/crates/bevy_sprite/src/dynamic_texture_atlas_builder.rs
+++ b/crates/bevy_sprite/src/dynamic_texture_atlas_builder.rs
@@ -24,8 +24,8 @@ impl DynamicTextureAtlasBuilder {
         texture: &Texture,
     ) -> Option<u32> {
         let allocation = self.atlas_allocator.allocate(size2(
-            texture.size.x as i32 + self.padding,
-            texture.size.y as i32 + self.padding,
+            texture.size.width as i32 + self.padding,
+            texture.size.height as i32 + self.padding,
         ));
         if let Some(allocation) = allocation {
             let atlas_texture = textures.get_mut(&texture_atlas.texture).unwrap();
@@ -72,7 +72,7 @@ impl DynamicTextureAtlasBuilder {
         let mut rect = allocation.rectangle;
         rect.max.x -= self.padding;
         rect.max.y -= self.padding;
-        let atlas_width = atlas_texture.size.x as usize;
+        let atlas_width = atlas_texture.size.width as usize;
         let rect_width = rect.width() as usize;
         let format_size = atlas_texture.format.pixel_size();
 
diff --git a/crates/bevy_sprite/src/entity.rs b/crates/bevy_sprite/src/entity.rs
index ace55688b503a..9136cce5ed598 100644
--- a/crates/bevy_sprite/src/entity.rs
+++ b/crates/bevy_sprite/src/entity.rs
@@ -7,7 +7,7 @@ use bevy_ecs::Bundle;
 use bevy_render::{
     mesh::Mesh,
     pipeline::{RenderPipeline, RenderPipelines},
-    prelude::Draw,
+    prelude::{Draw, Visible},
     render_graph::base::MainPass,
 };
 use bevy_transform::prelude::{GlobalTransform, Transform};
@@ -19,6 +19,7 @@ pub struct SpriteBundle {
     pub material: Handle<ColorMaterial>,
     pub main_pass: MainPass,
     pub draw: Draw,
+    pub visible: Visible,
     pub render_pipelines: RenderPipelines,
     pub transform: Transform,
     pub global_transform: GlobalTransform,
@@ -27,16 +28,17 @@ pub struct SpriteBundle {
 impl Default for SpriteBundle {
     fn default() -> Self {
         Self {
-            mesh: QUAD_HANDLE,
+            mesh: QUAD_HANDLE.typed(),
             render_pipelines: RenderPipelines::from_pipelines(vec![RenderPipeline::new(
-                SPRITE_PIPELINE_HANDLE,
+                SPRITE_PIPELINE_HANDLE.typed(),
             )]),
-            draw: Draw {
+            visible: Visible {
                 is_transparent: true,
                 ..Default::default()
             },
-            sprite: Default::default(),
             main_pass: MainPass,
+            draw: Default::default(),
+            sprite: Default::default(),
             material: Default::default(),
             transform: Default::default(),
             global_transform: Default::default(),
@@ -54,6 +56,7 @@ pub struct SpriteSheetBundle {
     pub texture_atlas: Handle<TextureAtlas>,
     /// Data pertaining to how the sprite is drawn on the screen
     pub draw: Draw,
+    pub visible: Visible,
     pub render_pipelines: RenderPipelines,
     pub main_pass: MainPass,
     pub mesh: Handle<Mesh>, // TODO: maybe abstract this out
@@ -65,14 +68,15 @@ impl Default for SpriteSheetBundle {
     fn default() -> Self {
         Self {
             render_pipelines: RenderPipelines::from_pipelines(vec![RenderPipeline::new(
-                SPRITE_SHEET_PIPELINE_HANDLE,
+                SPRITE_SHEET_PIPELINE_HANDLE.typed(),
             )]),
-            draw: Draw {
+            visible: Visible {
                 is_transparent: true,
                 ..Default::default()
             },
-            mesh: QUAD_HANDLE,
             main_pass: MainPass,
+            mesh: QUAD_HANDLE.typed(),
+            draw: Default::default(),
             sprite: Default::default(),
             texture_atlas: Default::default(),
             transform: Default::default(),
diff --git a/crates/bevy_sprite/src/lib.rs b/crates/bevy_sprite/src/lib.rs
index 2bad06938efb0..bc574243a4bf5 100644
--- a/crates/bevy_sprite/src/lib.rs
+++ b/crates/bevy_sprite/src/lib.rs
@@ -9,6 +9,7 @@ mod sprite;
 mod texture_atlas;
 mod texture_atlas_builder;
 
+use bevy_ecs::IntoSystem;
 pub use color_material::*;
 pub use dynamic_texture_atlas_builder::*;
 pub use rect::*;
@@ -25,29 +26,31 @@ pub mod prelude {
 }
 
 use bevy_app::prelude::*;
-use bevy_asset::{AddAsset, Assets, Handle};
+use bevy_asset::{AddAsset, Assets, Handle, HandleUntyped};
 use bevy_math::Vec2;
+use bevy_reflect::{RegisterTypeBuilder, TypeUuid};
 use bevy_render::{
     mesh::{shape, Mesh},
     render_graph::RenderGraph,
     shader::asset_shader_defs_system,
 };
-use bevy_type_registry::TypeUuid;
 use sprite::sprite_system;
 
 #[derive(Default)]
 pub struct SpritePlugin;
 
-pub const QUAD_HANDLE: Handle<Mesh> = Handle::weak_from_u64(Mesh::TYPE_UUID, 14240461981130137526);
+pub const QUAD_HANDLE: HandleUntyped =
+    HandleUntyped::weak_from_u64(Mesh::TYPE_UUID, 14240461981130137526);
 
 impl Plugin for SpritePlugin {
     fn build(&self, app: &mut AppBuilder) {
         app.add_asset::<ColorMaterial>()
             .add_asset::<TextureAtlas>()
-            .add_system_to_stage(stage::POST_UPDATE, sprite_system)
+            .register_type::<Sprite>()
+            .add_system_to_stage(stage::POST_UPDATE, sprite_system.system())
             .add_system_to_stage(
                 stage::POST_UPDATE,
-                asset_shader_defs_system::<ColorMaterial>,
+                asset_shader_defs_system::<ColorMaterial>.system(),
             );
 
         let resources = app.resources_mut();
diff --git a/crates/bevy_sprite/src/render/mod.rs b/crates/bevy_sprite/src/render/mod.rs
index c4cd96a5d3dad..221df7cb95091 100644
--- a/crates/bevy_sprite/src/render/mod.rs
+++ b/crates/bevy_sprite/src/render/mod.rs
@@ -1,6 +1,7 @@
 use crate::{ColorMaterial, Sprite, TextureAtlas, TextureAtlasSprite};
-use bevy_asset::{Assets, Handle};
+use bevy_asset::{Assets, HandleUntyped};
 use bevy_ecs::Resources;
+use bevy_reflect::TypeUuid;
 use bevy_render::{
     pipeline::{
         BlendDescriptor, BlendFactor, BlendOperation, ColorStateDescriptor, ColorWrite,
@@ -11,13 +12,12 @@ use bevy_render::{
     shader::{Shader, ShaderStage, ShaderStages},
     texture::TextureFormat,
 };
-use bevy_type_registry::TypeUuid;
 
-pub const SPRITE_PIPELINE_HANDLE: Handle<PipelineDescriptor> =
-    Handle::weak_from_u64(PipelineDescriptor::TYPE_UUID, 2785347840338765446);
+pub const SPRITE_PIPELINE_HANDLE: HandleUntyped =
+    HandleUntyped::weak_from_u64(PipelineDescriptor::TYPE_UUID, 2785347840338765446);
 
-pub const SPRITE_SHEET_PIPELINE_HANDLE: Handle<PipelineDescriptor> =
-    Handle::weak_from_u64(PipelineDescriptor::TYPE_UUID, 9016885805180281612);
+pub const SPRITE_SHEET_PIPELINE_HANDLE: HandleUntyped =
+    HandleUntyped::weak_from_u64(PipelineDescriptor::TYPE_UUID, 9016885805180281612);
 
 pub fn build_sprite_sheet_pipeline(shaders: &mut Assets<Shader>) -> PipelineDescriptor {
     PipelineDescriptor {
diff --git a/crates/bevy_sprite/src/sprite.rs b/crates/bevy_sprite/src/sprite.rs
index 9efc960dc6a9d..b5c3c836d5235 100644
--- a/crates/bevy_sprite/src/sprite.rs
+++ b/crates/bevy_sprite/src/sprite.rs
@@ -2,10 +2,11 @@ use crate::ColorMaterial;
 use bevy_asset::{Assets, Handle};
 use bevy_ecs::{Query, Res};
 use bevy_math::Vec2;
+use bevy_reflect::{Reflect, ReflectDeserialize, TypeUuid};
 use bevy_render::{renderer::RenderResources, texture::Texture};
-use bevy_type_registry::TypeUuid;
+use serde::{Deserialize, Serialize};
 
-#[derive(Debug, Default, RenderResources, TypeUuid)]
+#[derive(Debug, Default, RenderResources, TypeUuid, Reflect)]
 #[uuid = "7233c597-ccfa-411f-bd59-9af349432ada"]
 pub struct Sprite {
     pub size: Vec2,
@@ -14,7 +15,8 @@ pub struct Sprite {
 }
 
 /// Determines how `Sprite` resize should be handled
-#[derive(Debug)]
+#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize, Reflect)]
+#[reflect_value(PartialEq, Serialize, Deserialize)]
 pub enum SpriteResizeMode {
     Manual,
     Automatic,
@@ -48,7 +50,11 @@ pub fn sprite_system(
                 let material = materials.get(handle).unwrap();
                 if let Some(ref texture_handle) = material.texture {
                     if let Some(texture) = textures.get(texture_handle) {
-                        sprite.size = texture.size;
+                        let texture_size = texture.size.as_vec3().truncate();
+                        // only set sprite size if it has changed (this check prevents change detection from triggering)
+                        if sprite.size != texture_size {
+                            sprite.size = texture_size;
+                        }
                     }
                 }
             }
diff --git a/crates/bevy_sprite/src/texture_atlas.rs b/crates/bevy_sprite/src/texture_atlas.rs
index 8336c8d1ce11a..c78d398432fd3 100644
--- a/crates/bevy_sprite/src/texture_atlas.rs
+++ b/crates/bevy_sprite/src/texture_atlas.rs
@@ -2,12 +2,12 @@ use crate::Rect;
 use bevy_asset::Handle;
 use bevy_core::Byteable;
 use bevy_math::Vec2;
+use bevy_reflect::TypeUuid;
 use bevy_render::{
     color::Color,
     renderer::{RenderResource, RenderResources},
     texture::Texture,
 };
-use bevy_type_registry::TypeUuid;
 use bevy_utils::HashMap;
 
 /// An atlas containing multiple textures (like a spritesheet or a tilemap)
diff --git a/crates/bevy_sprite/src/texture_atlas_builder.rs b/crates/bevy_sprite/src/texture_atlas_builder.rs
index 262667a8d65ed..2be6d0058e04d 100644
--- a/crates/bevy_sprite/src/texture_atlas_builder.rs
+++ b/crates/bevy_sprite/src/texture_atlas_builder.rs
@@ -1,7 +1,7 @@
 use crate::{Rect, TextureAtlas};
 use bevy_asset::{Assets, Handle};
 use bevy_math::Vec2;
-use bevy_render::texture::{Texture, TextureFormat};
+use bevy_render::texture::{Extent3d, Texture, TextureDimension, TextureFormat};
 use bevy_utils::HashMap;
 use rectangle_pack::{
     contains_smallest_box, pack_rects, volume_heuristic, GroupedRectsToPlace, PackedLocation,
@@ -9,45 +9,60 @@ use rectangle_pack::{
 };
 use thiserror::Error;
 
+#[derive(Debug, Error)]
+pub enum TextureAtlasBuilderError {
+    #[error("could not pack textures into an atlas within the given bounds")]
+    NotEnoughSpace,
+}
+
 #[derive(Debug)]
+/// A builder which is used to create a texture atlas from many individual
+/// sprites.
 pub struct TextureAtlasBuilder {
-    pub textures: Vec<Handle<Texture>>,
-    pub rects_to_place: GroupedRectsToPlace<Handle<Texture>>,
-    pub initial_size: Vec2,
-    pub max_size: Vec2,
+    /// The grouped rects which must be placed with a key value pair of a
+    /// texture handle to an index.
+    rects_to_place: GroupedRectsToPlace<Handle<Texture>>,
+    /// The initial atlas size in pixels.
+    initial_size: Vec2,
+    /// The absolute maximum size of the texture atlas in pixels.
+    max_size: Vec2,
 }
 
 impl Default for TextureAtlasBuilder {
     fn default() -> Self {
-        Self::new(Vec2::new(256., 256.), Vec2::new(2048., 2048.))
+        Self {
+            rects_to_place: GroupedRectsToPlace::new(),
+            initial_size: Vec2::new(256., 256.),
+            max_size: Vec2::new(2048., 2048.),
+        }
     }
 }
 
-#[derive(Debug, Error)]
-pub enum RectanglePackError {
-    #[error("Could not pack textures into an atlas within the given bounds")]
-    NotEnoughSpace,
-}
+pub type TextureAtlasBuilderResult<T> = Result<T, TextureAtlasBuilderError>;
 
 impl TextureAtlasBuilder {
-    pub fn new(initial_size: Vec2, max_size: Vec2) -> Self {
-        Self {
-            textures: Default::default(),
-            rects_to_place: GroupedRectsToPlace::new(),
-            initial_size,
-            max_size,
-        }
+    /// Sets the initial size of the atlas in pixels.
+    pub fn initial_size(mut self, size: Vec2) -> Self {
+        self.initial_size = size;
+        self
+    }
+
+    /// Sets the max size of the atlas in pixels.
+    pub fn max_size(mut self, size: Vec2) -> Self {
+        self.max_size = size;
+        self
     }
 
+    /// Adds a texture to be copied to the texture atlas.
     pub fn add_texture(&mut self, texture_handle: Handle<Texture>, texture: &Texture) {
         self.rects_to_place.push_rect(
             texture_handle,
             None,
-            RectToInsert::new(texture.size.x as u32, texture.size.y as u32, 1),
+            RectToInsert::new(texture.size.width, texture.size.height, 1),
         )
     }
 
-    fn place_texture(
+    fn copy_texture(
         &mut self,
         atlas_texture: &mut Texture,
         texture: &Texture,
@@ -57,7 +72,7 @@ impl TextureAtlasBuilder {
         let rect_height = packed_location.height() as usize;
         let rect_x = packed_location.x() as usize;
         let rect_y = packed_location.y() as usize;
-        let atlas_width = atlas_texture.size.x as usize;
+        let atlas_width = atlas_texture.size.width as usize;
         let format_size = atlas_texture.format.pixel_size();
 
         for (texture_y, bound_y) in (rect_y..rect_y + rect_height).enumerate() {
@@ -70,10 +85,21 @@ impl TextureAtlasBuilder {
         }
     }
 
+    /// Consumes the builder and returns a result with a new texture atlas.
+    ///
+    /// Internally it copies all rectangles from the textures and copies them
+    /// into a new texture which the texture atlas will use. It is not useful to
+    /// hold a strong handle to the texture afterwards else it will exist twice
+    /// in memory.
+    ///
+    /// # Errors
+    ///
+    /// If there is not enough space in the atlas texture, an error will
+    /// be returned. It is then recommended to make a larger sprite sheet.
     pub fn finish(
         mut self,
         textures: &mut Assets<Texture>,
-    ) -> Result<TextureAtlas, RectanglePackError> {
+    ) -> Result<TextureAtlas, TextureAtlasBuilderError> {
         let initial_width = self.initial_size.x as u32;
         let initial_height = self.initial_size.y as u32;
         let max_width = self.max_size.x as u32;
@@ -93,7 +119,6 @@ impl TextureAtlasBuilder {
 
             let mut target_bins = std::collections::BTreeMap::new();
             target_bins.insert(0, TargetBin::new(current_width, current_height, 1));
-
             rect_placements = match pack_rects(
                 &self.rects_to_place,
                 target_bins,
@@ -102,7 +127,8 @@ impl TextureAtlasBuilder {
             ) {
                 Ok(rect_placements) => {
                     atlas_texture = Texture::new_fill(
-                        Vec2::new(current_width as f32, current_height as f32),
+                        Extent3d::new(current_width, current_height, 1),
+                        TextureDimension::D2,
                         &[0, 0, 0, 0],
                         TextureFormat::Rgba8UnormSrgb,
                     );
@@ -120,7 +146,7 @@ impl TextureAtlasBuilder {
             }
         }
 
-        let rect_placements = rect_placements.ok_or(RectanglePackError::NotEnoughSpace)?;
+        let rect_placements = rect_placements.ok_or(TextureAtlasBuilderError::NotEnoughSpace)?;
 
         let mut texture_rects = Vec::with_capacity(rect_placements.packed_locations().len());
         let mut texture_handles = HashMap::default();
@@ -134,10 +160,10 @@ impl TextureAtlasBuilder {
                 );
             texture_handles.insert(texture_handle.clone_weak(), texture_rects.len());
             texture_rects.push(Rect { min, max });
-            self.place_texture(&mut atlas_texture, texture, packed_location);
+            self.copy_texture(&mut atlas_texture, texture, packed_location);
         }
         Ok(TextureAtlas {
-            size: atlas_texture.size,
+            size: atlas_texture.size.as_vec3().truncate(),
             texture: textures.add(atlas_texture),
             textures: texture_rects,
             texture_handles: Some(texture_handles),
diff --git a/crates/bevy_tasks/Cargo.toml b/crates/bevy_tasks/Cargo.toml
index 344ec184a2788..a11a6f1db5acf 100644
--- a/crates/bevy_tasks/Cargo.toml
+++ b/crates/bevy_tasks/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_tasks"
-version = "0.3.0"
+version = "0.4.0"
 edition = "2018"
 authors = [
     "Bevy Contributors <bevyengine@gmail.com>",
diff --git a/crates/bevy_tasks/src/task_pool.rs b/crates/bevy_tasks/src/task_pool.rs
index 7185dfb8614bb..febd8351c9a29 100644
--- a/crates/bevy_tasks/src/task_pool.rs
+++ b/crates/bevy_tasks/src/task_pool.rs
@@ -69,10 +69,12 @@ impl Drop for TaskPoolInner {
     fn drop(&mut self) {
         self.shutdown_tx.close();
 
+        let panicking = thread::panicking();
         for join_handle in self.threads.drain(..) {
-            join_handle
-                .join()
-                .expect("task thread panicked while executing");
+            let res = join_handle.join();
+            if !panicking {
+                res.expect("Task thread panicked while executing.");
+            }
         }
     }
 }
@@ -132,7 +134,7 @@ impl TaskPool {
                         // Use unwrap_err because we expect a Closed error
                         future::block_on(shutdown_future).unwrap_err();
                     })
-                    .expect("failed to spawn thread")
+                    .expect("Failed to spawn thread.")
             })
             .collect();
 
@@ -167,34 +169,51 @@ impl TaskPool {
         let executor: &async_executor::Executor = &*self.executor;
         let executor: &'scope async_executor::Executor = unsafe { mem::transmute(executor) };
 
-        let fut = async move {
-            let mut scope = Scope {
-                executor,
-                spawned: Vec::new(),
-            };
-
-            f(&mut scope);
-
-            let mut results = Vec::with_capacity(scope.spawned.len());
-            for task in scope.spawned {
-                results.push(task.await);
-            }
-
-            results
+        let mut scope = Scope {
+            executor,
+            spawned: Vec::new(),
         };
 
-        // Pin the future on the stack.
-        pin!(fut);
+        f(&mut scope);
+
+        if scope.spawned.is_empty() {
+            Vec::default()
+        } else if scope.spawned.len() == 1 {
+            vec![future::block_on(&mut scope.spawned[0])]
+        } else {
+            let fut = async move {
+                let mut results = Vec::with_capacity(scope.spawned.len());
+                for task in scope.spawned {
+                    results.push(task.await);
+                }
 
-        // SAFETY: This function blocks until all futures complete, so we do not read/write the
-        // data from futures outside of the 'scope lifetime. However, rust has no way of knowing
-        // this so we must convert to 'static here to appease the compiler as it is unable to
-        // validate safety.
-        let fut: Pin<&mut (dyn Future<Output = Vec<T>> + Send)> = fut;
-        let fut: Pin<&'static mut (dyn Future<Output = Vec<T>> + Send + 'static)> =
-            unsafe { mem::transmute(fut) };
+                results
+            };
 
-        future::block_on(self.executor.spawn(fut))
+            // Pin the future on the stack.
+            pin!(fut);
+
+            // SAFETY: This function blocks until all futures complete, so we do not read/write the
+            // data from futures outside of the 'scope lifetime. However, rust has no way of knowing
+            // this so we must convert to 'static here to appease the compiler as it is unable to
+            // validate safety.
+            let fut: Pin<&mut (dyn Future<Output = Vec<T>> + Send)> = fut;
+            let fut: Pin<&'static mut (dyn Future<Output = Vec<T>> + Send + 'static)> =
+                unsafe { mem::transmute(fut) };
+
+            // The thread that calls scope() will participate in driving tasks in the pool forward
+            // until the tasks that are spawned by this scope() call complete. (If the caller of scope()
+            // happens to be a thread in this thread pool, and we only have one thread in the pool, then
+            // simply calling future::block_on(spawned) would deadlock.)
+            let mut spawned = self.executor.spawn(fut);
+            loop {
+                if let Some(result) = future::block_on(future::poll_once(&mut spawned)) {
+                    break result;
+                }
+
+                self.executor.try_tick();
+            }
+        }
     }
 
     /// Spawns a static future onto the thread pool. The returned Task is a future. It can also be
diff --git a/crates/bevy_text/Cargo.toml b/crates/bevy_text/Cargo.toml
index e222578241872..81e93a34a27f1 100644
--- a/crates/bevy_text/Cargo.toml
+++ b/crates/bevy_text/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_text"
-version = "0.3.0"
+version = "0.4.0"
 edition = "2018"
 authors = [
     "Bevy Contributors <bevyengine@gmail.com>",
@@ -14,15 +14,15 @@ keywords = ["bevy"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.3.0" }
-bevy_asset = { path = "../bevy_asset", version = "0.3.0" }
-bevy_core = { path = "../bevy_core", version = "0.3.0" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.3.0" }
-bevy_math = { path = "../bevy_math", version = "0.3.0" }
-bevy_render = { path = "../bevy_render", version = "0.3.0" }
-bevy_sprite = { path = "../bevy_sprite", version = "0.3.0" }
-bevy_type_registry = { path = "../bevy_type_registry", version = "0.3.0" }
-bevy_utils = { path = "../bevy_utils", version = "0.3.0" }
+bevy_app = { path = "../bevy_app", version = "0.4.0" }
+bevy_asset = { path = "../bevy_asset", version = "0.4.0" }
+bevy_core = { path = "../bevy_core", version = "0.4.0" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.4.0" }
+bevy_math = { path = "../bevy_math", version = "0.4.0" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.4.0", features = ["bevy"] }
+bevy_render = { path = "../bevy_render", version = "0.4.0" }
+bevy_sprite = { path = "../bevy_sprite", version = "0.4.0" }
+bevy_utils = { path = "../bevy_utils", version = "0.4.0" }
 
 # other
 anyhow = "1.0"
diff --git a/crates/bevy_text/src/draw.rs b/crates/bevy_text/src/draw.rs
index d06212c7b5b1a..c92aa889d20d9 100644
--- a/crates/bevy_text/src/draw.rs
+++ b/crates/bevy_text/src/draw.rs
@@ -3,12 +3,10 @@ use bevy_render::{
     color::Color,
     draw::{Draw, DrawContext, DrawError, Drawable},
     mesh,
+    mesh::Mesh,
     pipeline::{PipelineSpecialization, VertexBufferDescriptor},
     prelude::Msaa,
-    renderer::{
-        AssetRenderResourceBindings, BindGroup, BufferUsage, RenderResourceBindings,
-        RenderResourceId,
-    },
+    renderer::{BindGroup, RenderResourceBindings, RenderResourceId},
 };
 use bevy_sprite::TextureAtlasSprite;
 use glyph_brush_layout::{HorizontalAlign, VerticalAlign};
@@ -49,7 +47,6 @@ impl Default for TextStyle {
 
 pub struct DrawableText<'a> {
     pub render_resource_bindings: &'a mut RenderResourceBindings,
-    pub asset_render_resource_bindings: &'a mut AssetRenderResourceBindings,
     pub position: Vec3,
     pub style: &'a TextStyle,
     pub text_glyphs: &'a Vec<PositionedGlyph>,
@@ -61,7 +58,7 @@ impl<'a> Drawable for DrawableText<'a> {
     fn draw(&mut self, draw: &mut Draw, context: &mut DrawContext) -> Result<(), DrawError> {
         context.set_pipeline(
             draw,
-            &bevy_sprite::SPRITE_SHEET_PIPELINE_HANDLE,
+            &bevy_sprite::SPRITE_SHEET_PIPELINE_HANDLE.typed(),
             &PipelineSpecialization {
                 sample_count: self.msaa.samples,
                 vertex_buffer_descriptor: self.font_quad_vertex_descriptor.clone(),
@@ -72,22 +69,28 @@ impl<'a> Drawable for DrawableText<'a> {
         let render_resource_context = &**context.render_resource_context;
 
         if let Some(RenderResourceId::Buffer(vertex_attribute_buffer_id)) = render_resource_context
-            .get_asset_resource(&bevy_sprite::QUAD_HANDLE, mesh::VERTEX_ATTRIBUTE_BUFFER_ID)
+            .get_asset_resource(
+                &bevy_sprite::QUAD_HANDLE.typed::<Mesh>(),
+                mesh::VERTEX_ATTRIBUTE_BUFFER_ID,
+            )
         {
             draw.set_vertex_buffer(0, vertex_attribute_buffer_id, 0);
         } else {
-            println!("could not find vertex buffer for bevy_sprite::QUAD_HANDLE")
+            println!("Could not find vertex buffer for `bevy_sprite::QUAD_HANDLE`.")
         }
 
         let mut indices = 0..0;
         if let Some(RenderResourceId::Buffer(quad_index_buffer)) = render_resource_context
-            .get_asset_resource(&bevy_sprite::QUAD_HANDLE, mesh::INDEX_BUFFER_ASSET_INDEX)
+            .get_asset_resource(
+                &bevy_sprite::QUAD_HANDLE.typed::<Mesh>(),
+                mesh::INDEX_BUFFER_ASSET_INDEX,
+            )
         {
             draw.set_index_buffer(quad_index_buffer, 0);
             if let Some(buffer_info) = render_resource_context.get_buffer_info(quad_index_buffer) {
                 indices = 0..(buffer_info.size / 4) as u32;
             } else {
-                panic!("expected buffer type");
+                panic!("Expected buffer type.");
             }
         }
 
@@ -95,11 +98,7 @@ impl<'a> Drawable for DrawableText<'a> {
         context.set_bind_groups_from_bindings(draw, &mut [self.render_resource_bindings])?;
 
         for tv in self.text_glyphs {
-            let atlas_render_resource_bindings = self
-                .asset_render_resource_bindings
-                .get_mut(&tv.atlas_info.texture_atlas)
-                .unwrap();
-            context.set_bind_groups_from_bindings(draw, &mut [atlas_render_resource_bindings])?;
+            context.set_asset_bind_groups(draw, &tv.atlas_info.texture_atlas)?;
 
             let sprite = TextureAtlasSprite {
                 index: tv.atlas_info.glyph_index,
@@ -108,14 +107,8 @@ impl<'a> Drawable for DrawableText<'a> {
 
             let transform = Mat4::from_translation(self.position + tv.position.extend(0.));
 
-            let transform_buffer = context
-                .shared_buffers
-                .get_buffer(&transform, BufferUsage::UNIFORM)
-                .unwrap();
-            let sprite_buffer = context
-                .shared_buffers
-                .get_buffer(&sprite, BufferUsage::UNIFORM)
-                .unwrap();
+            let transform_buffer = context.get_uniform_buffer(&transform).unwrap();
+            let sprite_buffer = context.get_uniform_buffer(&sprite).unwrap();
             let sprite_bind_group = BindGroup::build()
                 .add_binding(0, transform_buffer)
                 .add_binding(1, sprite_buffer)
diff --git a/crates/bevy_text/src/error.rs b/crates/bevy_text/src/error.rs
index 10967f0e32cc0..1bb7cf1253581 100644
--- a/crates/bevy_text/src/error.rs
+++ b/crates/bevy_text/src/error.rs
@@ -3,8 +3,8 @@ use thiserror::Error;
 
 #[derive(Debug, PartialEq, Eq, Error)]
 pub enum TextError {
-    #[error("Font not found")]
+    #[error("font not found")]
     NoSuchFont,
-    #[error("Failed to add glyph to newly-created atlas {0:?}")]
+    #[error("failed to add glyph to newly-created atlas {0:?}")]
     FailedToAddGlyph(GlyphId),
 }
diff --git a/crates/bevy_text/src/font.rs b/crates/bevy_text/src/font.rs
index f701bff87c413..a9400632b634c 100644
--- a/crates/bevy_text/src/font.rs
+++ b/crates/bevy_text/src/font.rs
@@ -1,10 +1,9 @@
 use ab_glyph::{FontArc, FontVec, InvalidFont, OutlinedGlyph};
-use bevy_math::Vec2;
+use bevy_reflect::TypeUuid;
 use bevy_render::{
     color::Color,
-    texture::{Texture, TextureFormat},
+    texture::{Extent3d, Texture, TextureDimension, TextureFormat},
 };
-use bevy_type_registry::TypeUuid;
 
 #[derive(Debug, TypeUuid)]
 #[uuid = "97059ac6-c9ba-4da9-95b6-bed82c3ce198"]
@@ -36,7 +35,8 @@ impl Font {
             (color.b() * 255.0) as u8,
         ];
         Texture::new(
-            Vec2::new(width as f32, height as f32),
+            Extent3d::new(width as u32, height as u32, 1),
+            TextureDimension::D2,
             alpha
                 .iter()
                 .map(|a| {
diff --git a/crates/bevy_text/src/font_atlas.rs b/crates/bevy_text/src/font_atlas.rs
index bd6d7c6a16453..0120d70ea3682 100644
--- a/crates/bevy_text/src/font_atlas.rs
+++ b/crates/bevy_text/src/font_atlas.rs
@@ -1,7 +1,7 @@
 use ab_glyph::GlyphId;
 use bevy_asset::{Assets, Handle};
 use bevy_math::Vec2;
-use bevy_render::texture::{Texture, TextureFormat};
+use bevy_render::texture::{Extent3d, Texture, TextureDimension, TextureFormat};
 use bevy_sprite::{DynamicTextureAtlasBuilder, TextureAtlas};
 use bevy_utils::HashMap;
 
@@ -18,7 +18,8 @@ impl FontAtlas {
         size: Vec2,
     ) -> FontAtlas {
         let atlas_texture = textures.add(Texture::new_fill(
-            size,
+            Extent3d::new(size.x as u32, size.y as u32, 1),
+            TextureDimension::D2,
             &[0, 0, 0, 0],
             TextureFormat::Rgba8UnormSrgb,
         ));
diff --git a/crates/bevy_text/src/font_atlas_set.rs b/crates/bevy_text/src/font_atlas_set.rs
index decf5dd52491f..afdc7652c9e9f 100644
--- a/crates/bevy_text/src/font_atlas_set.rs
+++ b/crates/bevy_text/src/font_atlas_set.rs
@@ -3,9 +3,9 @@ use ab_glyph::{GlyphId, OutlinedGlyph};
 use bevy_asset::{Assets, Handle};
 use bevy_core::FloatOrd;
 use bevy_math::Vec2;
+use bevy_reflect::TypeUuid;
 use bevy_render::texture::Texture;
 use bevy_sprite::TextureAtlas;
-use bevy_type_registry::TypeUuid;
 use bevy_utils::{AHashExt, HashMap};
 
 type FontSizeKey = FloatOrd;
diff --git a/crates/bevy_text/src/glyph_brush.rs b/crates/bevy_text/src/glyph_brush.rs
index 20d05373554a0..77570f9870ac7 100644
--- a/crates/bevy_text/src/glyph_brush.rs
+++ b/crates/bevy_text/src/glyph_brush.rs
@@ -55,7 +55,7 @@ impl GlyphBrush {
             return Ok(Vec::new());
         }
 
-        let first_glyph = glyphs.first().expect("Must have at least one glyph");
+        let first_glyph = glyphs.first().expect("Must have at least one glyph.");
         let font_id = first_glyph.font_id.0;
         let handle = &self.handles[font_id];
         let font = fonts.get(handle).ok_or(TextError::NoSuchFont)?;
diff --git a/crates/bevy_transform/Cargo.toml b/crates/bevy_transform/Cargo.toml
index eddd4e69f8ac3..3f1584991cc69 100644
--- a/crates/bevy_transform/Cargo.toml
+++ b/crates/bevy_transform/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_transform"
-version = "0.3.0"
+version = "0.4.0"
 edition = "2018"
 authors = [
     "Bevy Contributors <bevyengine@gmail.com>",
@@ -14,12 +14,11 @@ keywords = ["bevy"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.3.0" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.3.0" }
-bevy_math = { path = "../bevy_math", version = "0.3.0" }
-bevy_property = { path = "../bevy_property", version = "0.3.0" }
-bevy_type_registry = { path = "../bevy_type_registry", version = "0.3.0" }
-bevy_utils = { path = "../bevy_utils", version = "0.3.0" }
+bevy_app = { path = "../bevy_app", version = "0.4.0" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.4.0" }
+bevy_math = { path = "../bevy_math", version = "0.4.0" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.4.0", features = ["bevy"] }
+bevy_utils = { path = "../bevy_utils", version = "0.4.0" }
 
 # other
 smallvec = { version = "1.4", features = ["serde"] }
diff --git a/crates/bevy_transform/src/components/children.rs b/crates/bevy_transform/src/components/children.rs
index 5b08a41b48f6d..e3a0c380f68a5 100644
--- a/crates/bevy_transform/src/components/children.rs
+++ b/crates/bevy_transform/src/components/children.rs
@@ -1,10 +1,11 @@
 use bevy_ecs::{Entity, MapEntities};
-use bevy_property::Properties;
+use bevy_reflect::{Reflect, ReflectComponent, ReflectMapEntities};
 use smallvec::SmallVec;
-use std::ops::{Deref, DerefMut};
+use std::ops::Deref;
 
-#[derive(Default, Clone, Properties, Debug)]
-pub struct Children(pub SmallVec<[Entity; 8]>);
+#[derive(Default, Clone, Debug, Reflect)]
+#[reflect(Component, MapEntities)]
+pub struct Children(pub(crate) SmallVec<[Entity; 8]>);
 
 impl MapEntities for Children {
     fn map_entities(
@@ -23,18 +24,17 @@ impl Children {
     pub fn with(entity: &[Entity]) -> Self {
         Self(SmallVec::from_slice(entity))
     }
+
+    /// Swaps the child at `a_index` with the child at `b_index`
+    pub fn swap(&mut self, a_index: usize, b_index: usize) {
+        self.0.swap(a_index, b_index);
+    }
 }
 
 impl Deref for Children {
-    type Target = SmallVec<[Entity; 8]>;
+    type Target = [Entity];
 
     fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-impl DerefMut for Children {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.0
+        &self.0[..]
     }
 }
diff --git a/crates/bevy_transform/src/components/global_transform.rs b/crates/bevy_transform/src/components/global_transform.rs
index 4292372081e7c..ad567e3e0e982 100644
--- a/crates/bevy_transform/src/components/global_transform.rs
+++ b/crates/bevy_transform/src/components/global_transform.rs
@@ -1,10 +1,10 @@
+use super::Transform;
 use bevy_math::{Mat3, Mat4, Quat, Vec3};
-use bevy_property::Properties;
+use bevy_reflect::{Reflect, ReflectComponent};
 use std::ops::Mul;
 
-use super::Transform;
-
-#[derive(Debug, PartialEq, Clone, Copy, Properties)]
+#[derive(Debug, PartialEq, Clone, Copy, Reflect)]
+#[reflect(Component)]
 pub struct GlobalTransform {
     pub translation: Vec3,
     pub rotation: Quat,
diff --git a/crates/bevy_transform/src/components/parent.rs b/crates/bevy_transform/src/components/parent.rs
index bf9bdab9a67b2..3379988de426e 100644
--- a/crates/bevy_transform/src/components/parent.rs
+++ b/crates/bevy_transform/src/components/parent.rs
@@ -1,8 +1,9 @@
 use bevy_ecs::{Entity, FromResources, MapEntities};
-use bevy_property::Properties;
+use bevy_reflect::{Reflect, ReflectComponent, ReflectMapEntities};
 use std::ops::{Deref, DerefMut};
 
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Properties)]
+#[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.
@@ -25,9 +26,6 @@ impl MapEntities for Parent {
     }
 }
 
-#[derive(Debug, Copy, Clone, Eq, PartialEq)]
-pub struct PreviousParent(pub Entity);
-
 impl Deref for Parent {
     type Target = Entity;
 
@@ -41,3 +39,24 @@ impl DerefMut for Parent {
         &mut self.0
     }
 }
+
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Reflect)]
+#[reflect(Component, MapEntities)]
+pub struct PreviousParent(pub(crate) Entity);
+
+impl MapEntities for PreviousParent {
+    fn map_entities(
+        &mut self,
+        entity_map: &bevy_ecs::EntityMap,
+    ) -> Result<(), bevy_ecs::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 {
+        PreviousParent(Entity::new(u32::MAX))
+    }
+}
diff --git a/crates/bevy_transform/src/components/transform.rs b/crates/bevy_transform/src/components/transform.rs
index 85876ff6005af..388a996257714 100644
--- a/crates/bevy_transform/src/components/transform.rs
+++ b/crates/bevy_transform/src/components/transform.rs
@@ -1,10 +1,10 @@
+use super::GlobalTransform;
 use bevy_math::{Mat3, Mat4, Quat, Vec3};
-use bevy_property::Properties;
+use bevy_reflect::{Reflect, ReflectComponent};
 use std::ops::Mul;
 
-use super::GlobalTransform;
-
-#[derive(Debug, PartialEq, Clone, Copy, Properties)]
+#[derive(Debug, PartialEq, Clone, Copy, Reflect)]
+#[reflect(Component)]
 pub struct Transform {
     pub translation: Vec3,
     pub rotation: Quat,
diff --git a/crates/bevy_transform/src/hierarchy/child_builder.rs b/crates/bevy_transform/src/hierarchy/child_builder.rs
index b42772cfb8bc7..81267f799e154 100644
--- a/crates/bevy_transform/src/hierarchy/child_builder.rs
+++ b/crates/bevy_transform/src/hierarchy/child_builder.rs
@@ -19,7 +19,7 @@ impl Command for InsertChildren {
         {
             let mut added = false;
             if let Ok(mut children) = world.get_mut::<Children>(self.parent) {
-                children.insert_from_slice(self.index, &self.children);
+                children.0.insert_from_slice(self.index, &self.children);
                 added = true;
             }
 
@@ -54,7 +54,7 @@ impl Command for PushChildren {
         {
             let mut added = false;
             if let Ok(mut children) = world.get_mut::<Children>(self.parent) {
-                children.extend(self.children.iter().cloned());
+                children.0.extend(self.children.iter().cloned());
                 added = true;
             }
 
@@ -81,6 +81,10 @@ impl<'a> ChildBuilder<'a> {
         self.commands.current_entity()
     }
 
+    pub fn parent_entity(&self) -> Entity {
+        self.push_children.parent
+    }
+
     pub fn with_bundle(
         &mut self,
         components: impl DynamicBundle + Send + Sync + 'static,
@@ -102,6 +106,11 @@ impl<'a> ChildBuilder<'a> {
         func(current_entity);
         self
     }
+
+    pub fn add_command<C: Command + 'static>(&mut self, command: C) -> &mut Self {
+        self.commands.add_command(command);
+        self
+    }
 }
 
 pub trait BuildChildren {
diff --git a/crates/bevy_transform/src/hierarchy/hierarchy.rs b/crates/bevy_transform/src/hierarchy/hierarchy.rs
index 6509fa0ff7a0d..85343d3f37c14 100644
--- a/crates/bevy_transform/src/hierarchy/hierarchy.rs
+++ b/crates/bevy_transform/src/hierarchy/hierarchy.rs
@@ -1,48 +1,17 @@
 use crate::components::{Children, Parent};
-use bevy_ecs::{Command, Commands, Entity, Query, Resources, World};
+use bevy_ecs::{Command, Commands, Entity, Resources, World};
 use bevy_utils::tracing::debug;
 
-pub fn run_on_hierarchy<T, S>(
-    children_query: &Query<&Children>,
-    state: &mut S,
-    entity: Entity,
-    parent_result: Option<T>,
-    mut previous_result: Option<T>,
-    run: &mut dyn FnMut(&mut S, Entity, Option<T>, Option<T>) -> Option<T>,
-) -> Option<T>
-where
-    T: Clone,
-{
-    let parent_result = run(state, entity, parent_result, previous_result);
-    previous_result = None;
-    if let Ok(children) = children_query.get(entity) {
-        for child in children.iter().cloned() {
-            previous_result = run_on_hierarchy(
-                children_query,
-                state,
-                child,
-                parent_result.clone(),
-                previous_result,
-                run,
-            );
-        }
-    } else {
-        previous_result = parent_result;
-    }
-
-    previous_result
-}
-
 #[derive(Debug)]
 pub struct DespawnRecursive {
     entity: Entity,
 }
 
-fn despawn_with_children_recursive(world: &mut World, entity: Entity) {
+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) {
-            children.retain(|c| *c != entity);
+            children.0.retain(|c| *c != entity);
         }
     }
 
@@ -52,12 +21,8 @@ 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 Some(children) = world
-        .get::<Children>(entity)
-        .ok()
-        .map(|children| children.0.iter().cloned().collect::<Vec<Entity>>())
-    {
-        for e in children {
+    if let Ok(mut children) = world.get_mut::<Children>(entity) {
+        for e in std::mem::take(&mut children.0) {
             despawn_with_children_recursive(world, e);
         }
     }
@@ -98,28 +63,32 @@ mod tests {
         let mut command_buffer = Commands::default();
         command_buffer.set_entity_reserver(world.get_entity_reserver());
 
-        command_buffer.spawn((0u32, 0u64)).with_children(|parent| {
-            parent.spawn((0u32, 0u64));
-        });
+        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((1u32, 1u64));
+        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((2u32, 2u64));
+            parent.spawn(("Parent, to be deleted".to_owned(), 3u32));
             // All descendents of the "parent" should also be deleted.
             parent.with_children(|parent| {
-                parent.spawn((3u32, 3u64)).with_children(|parent| {
-                    // child
-                    parent.spawn((4u32, 4u64));
-                });
-                parent.spawn((5u32, 5u64));
+                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((0u32, 0u64));
+        command_buffer.spawn(("An innocent bystander".to_owned(), 7u32));
         command_buffer.apply(&mut world, &mut resources);
 
         let parent_entity = world.get::<Children>(grandparent_entity).unwrap()[0];
@@ -128,10 +97,11 @@ mod tests {
         command_buffer.despawn_recursive(parent_entity); // despawning the same entity twice should not panic
         command_buffer.apply(&mut world, &mut resources);
 
-        let results = world
-            .query::<(&u32, &u64)>()
-            .map(|(a, b)| (*a, *b))
+        let mut results = world
+            .query::<(&String, &u32)>()
+            .map(|(a, b)| (a.clone(), *b))
             .collect::<Vec<_>>();
+        results.sort_unstable_by_key(|(_, index)| *index);
 
         {
             let children = world.get::<Children>(grandparent_entity).unwrap();
@@ -142,11 +112,14 @@ mod tests {
             );
         }
 
-        // parent_entity and its children should be deleted,
-        // the grandparent tuple (1, 1) and (0, 0) tuples remaining.
         assert_eq!(
             results,
-            vec![(0u32, 0u64), (0u32, 0u64), (0u32, 0u64), (1u32, 1u64)]
+            vec![
+                ("Another parent".to_owned(), 0u32),
+                ("Another child".to_owned(), 1u32),
+                ("Grandparent".to_owned(), 2u32),
+                ("An innocent bystander".to_owned(), 7u32)
+            ]
         );
     }
 }
diff --git a/crates/bevy_transform/src/hierarchy/hierarchy_maintenance_system.rs b/crates/bevy_transform/src/hierarchy/hierarchy_maintenance_system.rs
index 09f67b68e8b05..fadd9707bca9a 100644
--- a/crates/bevy_transform/src/hierarchy/hierarchy_maintenance_system.rs
+++ b/crates/bevy_transform/src/hierarchy/hierarchy_maintenance_system.rs
@@ -1,15 +1,14 @@
 use crate::components::*;
-use bevy_ecs::{Changed, Commands, Entity, Query, Without};
+use bevy_ecs::{Commands, Entity, Query, Without};
 use bevy_utils::HashMap;
 use smallvec::SmallVec;
 
 pub fn parent_update_system(
     commands: &mut Commands,
     removed_parent_query: Query<(Entity, &PreviousParent), Without<Parent>>,
-    mut changed_parent_query: Query<
-        (Entity, &Parent, Option<&mut PreviousParent>),
-        Changed<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
+    mut parent_query: Query<(Entity, &Parent, Option<&mut PreviousParent>)>,
     mut children_query: Query<&mut Children>,
 ) {
     // Entities with a missing `Parent` (ie. ones that have a `PreviousParent`), remove
@@ -25,7 +24,7 @@ pub fn parent_update_system(
     let mut children_additions = HashMap::<Entity, SmallVec<[Entity; 8]>>::default();
 
     // Entities with a changed Parent (that also have a PreviousParent, even if None)
-    for (entity, parent, possible_previous_parent) in changed_parent_query.iter_mut() {
+    for (entity, parent, possible_previous_parent) in parent_query.iter_mut() {
         if let Some(mut previous_parent) = possible_previous_parent {
             // New and previous point to the same Entity, carry on, nothing to see here.
             if previous_parent.0 == parent.0 {
@@ -47,6 +46,10 @@ pub fn parent_update_system(
         // `children_additions`).
         if let Ok(mut new_parent_children) = children_query.get_mut(parent.0) {
             // This is the parent
+            debug_assert!(
+                !(*new_parent_children).0.contains(&entity),
+                "children already added"
+            );
             (*new_parent_children).0.push(entity);
         } else {
             // The parent doesn't have a children entity, lets add it
@@ -68,7 +71,7 @@ pub fn parent_update_system(
 mod test {
     use super::*;
     use crate::{hierarchy::BuildChildren, transform_propagate_system::transform_propagate_system};
-    use bevy_ecs::{Resources, Schedule, World};
+    use bevy_ecs::{IntoSystem, Resources, Schedule, SystemStage, World};
     use bevy_math::Vec3;
 
     #[test]
@@ -76,10 +79,12 @@ mod test {
         let mut world = World::default();
         let mut resources = Resources::default();
 
+        let mut update_stage = SystemStage::parallel();
+        update_stage.add_system(parent_update_system.system());
+        update_stage.add_system(transform_propagate_system.system());
+
         let mut schedule = Schedule::default();
-        schedule.add_stage("update");
-        schedule.add_system_to_stage("update", parent_update_system);
-        schedule.add_system_to_stage("update", transform_propagate_system);
+        schedule.add_stage("update", update_stage);
 
         // Add parent entities
         let mut commands = Commands::default();
@@ -98,8 +103,7 @@ mod test {
             });
         let parent = parent.unwrap();
         commands.apply(&mut world, &mut resources);
-        schedule.initialize(&mut world, &mut resources);
-        schedule.run(&mut world, &mut resources);
+        schedule.initialize_and_run(&mut world, &mut resources);
 
         assert_eq!(
             world
@@ -115,7 +119,7 @@ mod test {
         // Parent `e1` to `e2`.
         (*world.get_mut::<Parent>(children[0]).unwrap()).0 = children[1];
 
-        schedule.run(&mut world, &mut resources);
+        schedule.initialize_and_run(&mut world, &mut resources);
 
         assert_eq!(
             world
@@ -139,7 +143,7 @@ mod test {
 
         world.despawn(children[0]).unwrap();
 
-        schedule.run(&mut world, &mut resources);
+        schedule.initialize_and_run(&mut world, &mut resources);
 
         assert_eq!(
             world
diff --git a/crates/bevy_transform/src/hierarchy/world_child_builder.rs b/crates/bevy_transform/src/hierarchy/world_child_builder.rs
index a658956c06e69..b2122fe135f5c 100644
--- a/crates/bevy_transform/src/hierarchy/world_child_builder.rs
+++ b/crates/bevy_transform/src/hierarchy/world_child_builder.rs
@@ -22,7 +22,7 @@ impl<'a, 'b> WorldChildBuilder<'a, 'b> {
             let world = &mut self.world_builder.world;
             let mut added = false;
             if let Ok(mut children) = world.get_mut::<Children>(parent_entity) {
-                children.push(entity);
+                children.0.push(entity);
                 added = true;
             }
 
@@ -52,6 +52,15 @@ impl<'a, 'b> WorldChildBuilder<'a, 'b> {
     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 {
diff --git a/crates/bevy_transform/src/lib.rs b/crates/bevy_transform/src/lib.rs
index fe8dc696c996e..97dd09ed24bd2 100644
--- a/crates/bevy_transform/src/lib.rs
+++ b/crates/bevy_transform/src/lib.rs
@@ -6,26 +6,31 @@ pub mod prelude {
     pub use crate::{components::*, hierarchy::*, TransformPlugin};
 }
 
-use bevy_app::prelude::*;
-use bevy_type_registry::RegisterType;
-use prelude::{parent_update_system, Children, GlobalTransform, Parent, Transform};
+use bevy_app::{prelude::*, startup_stage};
+use bevy_ecs::IntoSystem;
+use bevy_reflect::RegisterTypeBuilder;
+use prelude::{parent_update_system, Children, GlobalTransform, Parent, PreviousParent, Transform};
 
 #[derive(Default)]
 pub struct TransformPlugin;
 
 impl Plugin for TransformPlugin {
     fn build(&self, app: &mut AppBuilder) {
-        app.register_component_with::<Children>(|reg| reg.map_entities())
-            .register_component_with::<Parent>(|reg| reg.map_entities())
-            .register_component::<Transform>()
-            .register_component::<GlobalTransform>()
+        app.register_type::<Children>()
+            .register_type::<Parent>()
+            .register_type::<PreviousParent>()
+            .register_type::<Transform>()
+            .register_type::<GlobalTransform>()
             // add transform systems to startup so the first update is "correct"
-            .add_startup_system(parent_update_system)
-            .add_startup_system(transform_propagate_system::transform_propagate_system)
-            .add_system_to_stage(stage::POST_UPDATE, parent_update_system)
+            .add_startup_system_to_stage(startup_stage::POST_STARTUP, parent_update_system.system())
+            .add_startup_system_to_stage(
+                startup_stage::POST_STARTUP,
+                transform_propagate_system::transform_propagate_system.system(),
+            )
+            .add_system_to_stage(stage::POST_UPDATE, parent_update_system.system())
             .add_system_to_stage(
                 stage::POST_UPDATE,
-                transform_propagate_system::transform_propagate_system,
+                transform_propagate_system::transform_propagate_system.system(),
             );
     }
 }
diff --git a/crates/bevy_transform/src/transform_propagate_system.rs b/crates/bevy_transform/src/transform_propagate_system.rs
index 05e335edbf0e6..6914ad31ab0c1 100644
--- a/crates/bevy_transform/src/transform_propagate_system.rs
+++ b/crates/bevy_transform/src/transform_propagate_system.rs
@@ -3,22 +3,29 @@ use bevy_ecs::prelude::*;
 
 pub fn transform_propagate_system(
     mut root_query: Query<
-        (Option<&Children>, &Transform, &mut GlobalTransform),
+        (Entity, Option<&Children>, &Transform, &mut GlobalTransform),
         (Without<Parent>, With<GlobalTransform>),
     >,
     mut transform_query: Query<(&Transform, &mut GlobalTransform), With<Parent>>,
+    changed_transform_query: Query<Entity, Changed<Transform>>,
     children_query: Query<Option<&Children>, (With<Parent>, With<GlobalTransform>)>,
 ) {
-    for (children, transform, mut global_transform) in root_query.iter_mut() {
-        *global_transform = GlobalTransform::from(*transform);
+    for (entity, children, transform, mut global_transform) in root_query.iter_mut() {
+        let mut changed = false;
+        if changed_transform_query.get(entity).is_ok() {
+            *global_transform = GlobalTransform::from(*transform);
+            changed = true;
+        }
 
         if let Some(children) = children {
             for child in children.0.iter() {
                 propagate_recursive(
                     &global_transform,
+                    &changed_transform_query,
                     &mut transform_query,
                     &children_query,
                     *child,
+                    changed,
                 );
             }
         }
@@ -27,13 +34,19 @@ pub fn transform_propagate_system(
 
 fn propagate_recursive(
     parent: &GlobalTransform,
+    changed_transform_query: &Query<Entity, Changed<Transform>>,
     transform_query: &mut Query<(&Transform, &mut GlobalTransform), With<Parent>>,
     children_query: &Query<Option<&Children>, (With<Parent>, With<GlobalTransform>)>,
     entity: Entity,
+    mut changed: bool,
 ) {
+    changed |= changed_transform_query.get(entity).is_ok();
+
     let global_matrix = {
         if let Ok((transform, mut global_transform)) = transform_query.get_mut(entity) {
-            *global_transform = parent.mul_transform(*transform);
+            if changed {
+                *global_transform = parent.mul_transform(*transform);
+            }
             *global_transform
         } else {
             return;
@@ -42,7 +55,14 @@ fn propagate_recursive(
 
     if let Ok(Some(children)) = children_query.get(entity) {
         for child in children.0.iter() {
-            propagate_recursive(&global_matrix, transform_query, children_query, *child);
+            propagate_recursive(
+                &global_matrix,
+                changed_transform_query,
+                transform_query,
+                children_query,
+                *child,
+                changed,
+            );
         }
     }
 }
@@ -50,8 +70,8 @@ fn propagate_recursive(
 #[cfg(test)]
 mod test {
     use super::*;
-    use crate::hierarchy::{parent_update_system, BuildChildren};
-    use bevy_ecs::{Resources, Schedule, World};
+    use crate::hierarchy::{parent_update_system, BuildChildren, BuildWorldChildren};
+    use bevy_ecs::{Resources, Schedule, SystemStage, World};
     use bevy_math::Vec3;
 
     #[test]
@@ -59,36 +79,40 @@ mod test {
         let mut world = World::default();
         let mut resources = Resources::default();
 
+        let mut update_stage = SystemStage::parallel();
+        update_stage.add_system(parent_update_system.system());
+        update_stage.add_system(transform_propagate_system.system());
+
         let mut schedule = Schedule::default();
-        schedule.add_stage("update");
-        schedule.add_system_to_stage("update", parent_update_system);
-        schedule.add_system_to_stage("update", transform_propagate_system);
+        schedule.add_stage("update", update_stage);
 
         // Root entity
-        let parent = world.spawn((
+        world.spawn((
             Transform::from_translation(Vec3::new(1.0, 0.0, 0.0)),
             GlobalTransform::identity(),
         ));
-        let children = world
-            .spawn_batch(vec![
-                (
-                    Transform::from_translation(Vec3::new(0.0, 2.0, 0.)),
-                    Parent(parent),
-                    GlobalTransform::identity(),
-                ),
-                (
-                    Transform::from_translation(Vec3::new(0.0, 0.0, 3.)),
-                    Parent(parent),
-                    GlobalTransform::identity(),
-                ),
-            ])
-            .collect::<Vec<Entity>>();
-        // we need to run the schedule two times because components need to be filled in
-        // to resolve this problem in code, just add the correct components, or use Commands
-        // which adds all of the components needed with the correct state (see next test)
-        schedule.initialize(&mut world, &mut resources);
-        schedule.run(&mut world, &mut resources);
-        schedule.run(&mut world, &mut resources);
+
+        let mut children = Vec::new();
+        world
+            .build()
+            .spawn((
+                Transform::from_translation(Vec3::new(1.0, 0.0, 0.0)),
+                GlobalTransform::identity(),
+            ))
+            .with_children(|parent| {
+                parent
+                    .spawn((
+                        Transform::from_translation(Vec3::new(0.0, 2.0, 0.)),
+                        GlobalTransform::identity(),
+                    ))
+                    .for_current_entity(|entity| children.push(entity))
+                    .spawn((
+                        Transform::from_translation(Vec3::new(0.0, 0.0, 3.)),
+                        GlobalTransform::identity(),
+                    ))
+                    .for_current_entity(|entity| children.push(entity));
+            });
+        schedule.initialize_and_run(&mut world, &mut resources);
 
         assert_eq!(
             *world.get::<GlobalTransform>(children[0]).unwrap(),
@@ -108,10 +132,12 @@ mod test {
         let mut world = World::default();
         let mut resources = Resources::default();
 
+        let mut update_stage = SystemStage::parallel();
+        update_stage.add_system(parent_update_system.system());
+        update_stage.add_system(transform_propagate_system.system());
+
         let mut schedule = Schedule::default();
-        schedule.add_stage("update");
-        schedule.add_system_to_stage("update", parent_update_system);
-        schedule.add_system_to_stage("update", transform_propagate_system);
+        schedule.add_stage("update", update_stage);
 
         // Root entity
         let mut commands = Commands::default();
@@ -136,8 +162,7 @@ mod test {
                     .for_current_entity(|entity| children.push(entity));
             });
         commands.apply(&mut world, &mut resources);
-        schedule.initialize(&mut world, &mut resources);
-        schedule.run(&mut world, &mut resources);
+        schedule.initialize_and_run(&mut world, &mut resources);
 
         assert_eq!(
             *world.get::<GlobalTransform>(children[0]).unwrap(),
diff --git a/crates/bevy_type_registry/Cargo.toml b/crates/bevy_type_registry/Cargo.toml
deleted file mode 100644
index a71e73de9896d..0000000000000
--- a/crates/bevy_type_registry/Cargo.toml
+++ /dev/null
@@ -1,26 +0,0 @@
-[package]
-name = "bevy_type_registry"
-version = "0.3.0"
-edition = "2018"
-authors = [
-    "Bevy Contributors <bevyengine@gmail.com>",
-    "Carter Anderson <mcanders1@gmail.com>",
-]
-description = "Provides a type registry for Bevy Engine"
-homepage = "https://bevyengine.org"
-repository = "https://github.com/bevyengine/bevy"
-license = "MIT"
-keywords = ["bevy"]
-
-[dependencies]
-# bevy
-bevy_app = { path = "../bevy_app", version = "0.3.0" }
-bevy_derive = { path = "../bevy_derive", version = "0.3.0" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.3.0" }
-bevy_property = { path = "../bevy_property", version = "0.3.0" }
-bevy_utils = { path = "../bevy_utils", version = "0.3.0" }
-
-# other
-uuid = { version = "0.8", features = ["v4", "serde"] }
-serde = { version = "1", features = ["derive"] }
-parking_lot = "0.11.0"
diff --git a/crates/bevy_type_registry/src/lib.rs b/crates/bevy_type_registry/src/lib.rs
deleted file mode 100644
index 2f0fbe88cea53..0000000000000
--- a/crates/bevy_type_registry/src/lib.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-mod register_type;
-mod type_registry;
-mod type_uuid;
-
-pub use register_type::*;
-pub use type_registry::*;
-pub use type_uuid::*;
-pub use uuid::Uuid;
-
-use bevy_app::prelude::*;
-use bevy_property::DynamicProperties;
-
-#[derive(Default)]
-pub struct TypeRegistryPlugin;
-
-impl Plugin for TypeRegistryPlugin {
-    fn build(&self, app: &mut AppBuilder) {
-        app.init_resource::<TypeRegistry>()
-            .register_property::<DynamicProperties>();
-    }
-}
diff --git a/crates/bevy_type_registry/src/register_type.rs b/crates/bevy_type_registry/src/register_type.rs
deleted file mode 100644
index 40f1258a8f9ff..0000000000000
--- a/crates/bevy_type_registry/src/register_type.rs
+++ /dev/null
@@ -1,78 +0,0 @@
-use crate::{ComponentRegistration, ComponentRegistrationBuilder, TypeRegistry};
-use bevy_app::AppBuilder;
-use bevy_ecs::{Component, FromResources};
-use bevy_property::{DeserializeProperty, Properties, Property};
-
-pub trait RegisterType {
-    fn register_component<T>(&mut self) -> &mut Self
-    where
-        T: Properties + DeserializeProperty + Component + FromResources;
-    fn register_component_with<T>(
-        &mut self,
-        build: fn(ComponentRegistrationBuilder<T>) -> ComponentRegistrationBuilder<T>,
-    ) -> &mut Self
-    where
-        T: Properties + DeserializeProperty + Component + FromResources;
-    fn register_properties<T>(&mut self) -> &mut Self
-    where
-        T: Properties + DeserializeProperty + FromResources;
-    fn register_property<T>(&mut self) -> &mut Self
-    where
-        T: Property + DeserializeProperty;
-}
-
-impl RegisterType for AppBuilder {
-    fn register_component<T>(&mut self) -> &mut Self
-    where
-        T: Properties + DeserializeProperty + Component + FromResources,
-    {
-        {
-            let type_registry = self.app.resources.get::<TypeRegistry>().unwrap();
-            type_registry.component.write().register::<T>();
-            type_registry.property.write().register::<T>();
-        }
-        self
-    }
-
-    fn register_properties<T>(&mut self) -> &mut Self
-    where
-        T: Properties + DeserializeProperty + Component + FromResources,
-    {
-        {
-            let type_registry = self.app.resources.get::<TypeRegistry>().unwrap();
-            type_registry.property.write().register::<T>();
-        }
-        self
-    }
-
-    fn register_property<T>(&mut self) -> &mut Self
-    where
-        T: Property + DeserializeProperty,
-    {
-        {
-            let type_registry = self.app.resources.get::<TypeRegistry>().unwrap();
-            type_registry.property.write().register::<T>();
-        }
-        self
-    }
-
-    fn register_component_with<T>(
-        &mut self,
-        build: fn(ComponentRegistrationBuilder<T>) -> ComponentRegistrationBuilder<T>,
-    ) -> &mut Self
-    where
-        T: Properties + DeserializeProperty + Component + FromResources,
-    {
-        {
-            let mut builder = ComponentRegistration::build::<T>();
-            builder = build(builder);
-            let type_registry = self.app.resources.get::<TypeRegistry>().unwrap();
-            type_registry
-                .component
-                .write()
-                .add_registration(builder.finish());
-            type_registry.property.write().register::<T>();
-        }
-        self
-    }
-}
diff --git a/crates/bevy_type_registry/src/type_registry.rs b/crates/bevy_type_registry/src/type_registry.rs
deleted file mode 100644
index 0a22562755fc5..0000000000000
--- a/crates/bevy_type_registry/src/type_registry.rs
+++ /dev/null
@@ -1,334 +0,0 @@
-use bevy_ecs::{
-    Archetype, Component, Entity, EntityMap, FromResources, MapEntities, MapEntitiesError,
-    Resources, World,
-};
-use bevy_property::{
-    DeserializeProperty, Properties, Property, PropertyTypeRegistration, PropertyTypeRegistry,
-};
-use bevy_utils::{HashMap, HashSet};
-use parking_lot::RwLock;
-use std::{any::TypeId, marker::PhantomData, sync::Arc};
-
-#[derive(Clone, Default)]
-pub struct TypeRegistry {
-    pub property: Arc<RwLock<PropertyTypeRegistry>>,
-    pub component: Arc<RwLock<ComponentRegistry>>,
-}
-
-#[derive(Default)]
-pub struct ComponentRegistry {
-    pub registrations: HashMap<TypeId, ComponentRegistration>,
-    pub short_names: HashMap<String, TypeId>,
-    pub full_names: HashMap<String, TypeId>,
-    pub ambiguous_names: HashSet<String>,
-}
-
-impl ComponentRegistry {
-    pub fn register<T>(&mut self)
-    where
-        T: Properties + Component + FromResources,
-    {
-        self.add_registration(ComponentRegistration::of::<T>());
-    }
-
-    pub fn add_registration(&mut self, registration: ComponentRegistration) {
-        let short_name = registration.short_name.to_string();
-        self.full_names
-            .insert(registration.long_name.to_string(), registration.ty);
-        if self.short_names.contains_key(&short_name) || self.ambiguous_names.contains(&short_name)
-        {
-            // name is ambiguous. fall back to long names for all ambiguous types
-            self.short_names.remove(&short_name);
-            self.ambiguous_names.insert(short_name);
-        } else {
-            self.short_names.insert(short_name, registration.ty);
-        }
-        self.registrations.insert(registration.ty, registration);
-    }
-
-    pub fn get(&self, type_id: &TypeId) -> Option<&ComponentRegistration> {
-        self.registrations.get(type_id)
-    }
-
-    pub fn get_with_full_name(&self, full_name: &str) -> Option<&ComponentRegistration> {
-        self.full_names
-            .get(full_name)
-            .and_then(|id| self.registrations.get(id))
-    }
-
-    pub fn get_with_short_name(&self, short_name: &str) -> Option<&ComponentRegistration> {
-        self.short_names
-            .get(short_name)
-            .and_then(|id| self.registrations.get(id))
-    }
-
-    pub fn get_with_name(&self, type_name: &str) -> Option<&ComponentRegistration> {
-        let mut registration = self.get_with_short_name(type_name);
-        if registration.is_none() {
-            registration = self.get_with_full_name(type_name);
-            if registration.is_none() && self.ambiguous_names.contains(type_name) {
-                panic!("Type name is ambiguous: {}", type_name);
-            }
-        }
-        registration
-    }
-
-    pub fn iter(&self) -> impl Iterator<Item = &ComponentRegistration> {
-        self.registrations.values()
-    }
-}
-
-#[derive(Clone)]
-pub struct ComponentRegistration {
-    pub ty: TypeId,
-    pub short_name: String,
-    pub long_name: &'static str,
-    component_add_fn: fn(&mut World, resources: &Resources, Entity, &dyn Property),
-    component_apply_fn: fn(&mut World, Entity, &dyn Property),
-    component_properties_fn: fn(&Archetype, usize) -> &dyn Properties,
-    component_copy_fn: fn(&World, &mut World, &Resources, Entity, Entity),
-    copy_to_scene_fn: fn(&World, &mut World, &Resources, Entity, Entity),
-    copy_from_scene_fn: fn(&World, &mut World, &Resources, Entity, Entity),
-    map_entities_fn: fn(&mut World, &EntityMap) -> Result<(), MapEntitiesError>,
-}
-
-struct ComponentRegistrationDefaults;
-
-impl ComponentRegistrationDefaults {
-    pub fn component_add<T: Component + Properties + FromResources>(
-        world: &mut World,
-        resources: &Resources,
-        entity: Entity,
-        property: &dyn Property,
-    ) {
-        let mut component = T::from_resources(resources);
-        component.apply(property);
-        world.insert_one(entity, component).unwrap();
-    }
-
-    fn component_apply<T: Component + Properties>(
-        world: &mut World,
-        entity: Entity,
-        property: &dyn Property,
-    ) {
-        let mut component = world.get_mut::<T>(entity).unwrap();
-        component.apply(property);
-    }
-
-    fn component_copy<T: Component + Properties + FromResources>(
-        source_world: &World,
-        destination_world: &mut World,
-        resources: &Resources,
-        source_entity: Entity,
-        destination_entity: Entity,
-    ) {
-        let source_component = source_world.get::<T>(source_entity).unwrap();
-        let mut destination_component = T::from_resources(resources);
-        destination_component.apply(source_component);
-        destination_world
-            .insert_one(destination_entity, destination_component)
-            .unwrap();
-    }
-
-    fn component_properties<T: Component + Properties>(
-        archetype: &Archetype,
-        index: usize,
-    ) -> &dyn Properties {
-        // the type has been looked up by the caller, so this is safe
-        unsafe {
-            let ptr = archetype.get::<T>().unwrap().as_ptr().add(index);
-            ptr.as_ref().unwrap()
-        }
-    }
-
-    fn map_entities(_world: &mut World, _entity_map: &EntityMap) -> Result<(), MapEntitiesError> {
-        Ok(())
-    }
-}
-
-impl ComponentRegistration {
-    pub fn build<T>() -> ComponentRegistrationBuilder<T>
-    where
-        T: Properties + DeserializeProperty + Component + FromResources,
-    {
-        ComponentRegistrationBuilder {
-            registration: ComponentRegistration::of::<T>(),
-            marker: PhantomData::default(),
-        }
-    }
-
-    pub fn of<T: Properties + Component + FromResources>() -> Self {
-        let ty = TypeId::of::<T>();
-        Self {
-            ty,
-            component_add_fn: ComponentRegistrationDefaults::component_add::<T>,
-            component_apply_fn: ComponentRegistrationDefaults::component_apply::<T>,
-            component_copy_fn: ComponentRegistrationDefaults::component_copy::<T>,
-            component_properties_fn: ComponentRegistrationDefaults::component_properties::<T>,
-            copy_from_scene_fn: ComponentRegistrationDefaults::component_copy::<T>,
-            copy_to_scene_fn: ComponentRegistrationDefaults::component_copy::<T>,
-            map_entities_fn: ComponentRegistrationDefaults::map_entities,
-            short_name: PropertyTypeRegistration::get_short_name(std::any::type_name::<T>()),
-            long_name: std::any::type_name::<T>(),
-        }
-    }
-
-    pub fn add_property_to_entity(
-        &self,
-        world: &mut World,
-        resources: &Resources,
-        entity: Entity,
-        property: &dyn Property,
-    ) {
-        (self.component_add_fn)(world, resources, entity, property);
-    }
-
-    pub fn apply_property_to_entity(
-        &self,
-        world: &mut World,
-        entity: Entity,
-        property: &dyn Property,
-    ) {
-        (self.component_apply_fn)(world, entity, property);
-    }
-
-    pub fn get_component_properties<'a>(
-        &self,
-        archetype: &'a Archetype,
-        entity_index: usize,
-    ) -> &'a dyn Properties {
-        (self.component_properties_fn)(archetype, entity_index)
-    }
-
-    pub fn component_copy(
-        &self,
-        source_world: &World,
-        destination_world: &mut World,
-        resources: &Resources,
-        source_entity: Entity,
-        destination_entity: Entity,
-    ) {
-        (self.component_copy_fn)(
-            source_world,
-            destination_world,
-            resources,
-            source_entity,
-            destination_entity,
-        );
-    }
-
-    pub fn copy_from_scene(
-        &self,
-        scene_world: &World,
-        destination_world: &mut World,
-        resources: &Resources,
-        source_entity: Entity,
-        destination_entity: Entity,
-    ) {
-        (self.component_copy_fn)(
-            scene_world,
-            destination_world,
-            resources,
-            source_entity,
-            destination_entity,
-        );
-    }
-
-    pub fn copy_to_scene(
-        &self,
-        source_world: &World,
-        scene_world: &mut World,
-        resources: &Resources,
-        source_entity: Entity,
-        destination_entity: Entity,
-    ) {
-        (self.copy_to_scene_fn)(
-            source_world,
-            scene_world,
-            resources,
-            source_entity,
-            destination_entity,
-        );
-    }
-
-    pub fn map_entities(
-        &self,
-        world: &mut World,
-        entity_map: &EntityMap,
-    ) -> Result<(), MapEntitiesError> {
-        (self.map_entities_fn)(world, entity_map)
-    }
-}
-
-pub struct ComponentRegistrationBuilder<T> {
-    registration: ComponentRegistration,
-    marker: PhantomData<T>,
-}
-
-impl<T> ComponentRegistrationBuilder<T>
-where
-    T: Properties + DeserializeProperty + Component + FromResources,
-{
-    pub fn map_entities(mut self) -> Self
-    where
-        T: MapEntities,
-    {
-        self.registration.map_entities_fn = |world: &mut World, entity_map: &EntityMap| {
-            // TODO: add UntrackedMut<T> pointer that returns &mut T. This will avoid setting the "mutated" state
-            for mut component in &mut world.query_mut::<&mut T>() {
-                component.map_entities(entity_map)?;
-            }
-
-            Ok(())
-        };
-        self
-    }
-
-    pub fn into_scene_component<C: Component>(mut self) -> Self
-    where
-        T: IntoComponent<C>,
-    {
-        self.registration.copy_to_scene_fn =
-            |source_world: &World,
-             scene_world: &mut World,
-             resources: &Resources,
-             source_entity: Entity,
-             scene_entity: Entity| {
-                let source_component = source_world.get::<T>(source_entity).unwrap();
-                let scene_component = source_component.into_component(resources);
-                scene_world
-                    .insert_one(scene_entity, scene_component)
-                    .unwrap();
-            };
-
-        self
-    }
-
-    pub fn into_runtime_component<C: Component>(mut self) -> Self
-    where
-        T: IntoComponent<C>,
-    {
-        self.registration.copy_from_scene_fn =
-            |scene_world: &World,
-             destination_world: &mut World,
-             resources: &Resources,
-             scene_entity: Entity,
-             destination_entity: Entity| {
-                let scene_component = scene_world.get::<T>(scene_entity).unwrap();
-                let destination_component = scene_component.into_component(resources);
-                destination_world
-                    .insert_one(destination_entity, destination_component)
-                    .unwrap();
-            };
-
-        self
-    }
-
-    pub fn finish(self) -> ComponentRegistration {
-        self.registration
-    }
-}
-
-pub trait IntoComponent<ToComponent: Component> {
-    fn into_component(&self, resources: &Resources) -> ToComponent;
-}
diff --git a/crates/bevy_ui/Cargo.toml b/crates/bevy_ui/Cargo.toml
index b361ad2ff284d..7c39664d9f14d 100644
--- a/crates/bevy_ui/Cargo.toml
+++ b/crates/bevy_ui/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_ui"
-version = "0.3.0"
+version = "0.4.0"
 edition = "2018"
 authors = [
     "Bevy Contributors <bevyengine@gmail.com>",
@@ -14,20 +14,21 @@ keywords = ["bevy"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.3.0" }
-bevy_asset = { path = "../bevy_asset", version = "0.3.0" }
-bevy_core = { path = "../bevy_core", version = "0.3.0" }
-bevy_derive = { path = "../bevy_derive", version = "0.3.0" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.3.0" }
-bevy_input = { path = "../bevy_input", version = "0.3.0" }
-bevy_math = { path = "../bevy_math", version = "0.3.0" }
-bevy_render = { path = "../bevy_render", version = "0.3.0" }
-bevy_sprite = { path = "../bevy_sprite", version = "0.3.0" }
-bevy_text = { path = "../bevy_text", version = "0.3.0" }
-bevy_transform = { path = "../bevy_transform", version = "0.3.0" }
-bevy_type_registry = { path = "../bevy_type_registry", version = "0.3.0" }
-bevy_window = { path = "../bevy_window", version = "0.3.0" }
-bevy_utils = { path = "../bevy_utils", version = "0.3.0" }
+bevy_app = { path = "../bevy_app", version = "0.4.0" }
+bevy_asset = { path = "../bevy_asset", version = "0.4.0" }
+bevy_core = { path = "../bevy_core", version = "0.4.0" }
+bevy_derive = { path = "../bevy_derive", version = "0.4.0" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.4.0" }
+bevy_input = { path = "../bevy_input", version = "0.4.0" }
+bevy_math = { path = "../bevy_math", version = "0.4.0" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.4.0", features = ["bevy"] }
+bevy_render = { path = "../bevy_render", version = "0.4.0" }
+bevy_sprite = { path = "../bevy_sprite", version = "0.4.0" }
+bevy_text = { path = "../bevy_text", version = "0.4.0" }
+bevy_transform = { path = "../bevy_transform", version = "0.4.0" }
+bevy_window = { path = "../bevy_window", version = "0.4.0" }
+bevy_utils = { path = "../bevy_utils", version = "0.4.0" }
 
 # other
 stretch = "0.3"
+serde = {version = "1", features = ["derive"]}
diff --git a/crates/bevy_ui/src/entity.rs b/crates/bevy_ui/src/entity.rs
index 41c01b30e1175..f4bd26b7080e4 100644
--- a/crates/bevy_ui/src/entity.rs
+++ b/crates/bevy_ui/src/entity.rs
@@ -12,6 +12,7 @@ use bevy_render::{
     draw::Draw,
     mesh::Mesh,
     pipeline::{RenderPipeline, RenderPipelines},
+    prelude::Visible,
 };
 use bevy_sprite::{ColorMaterial, QUAD_HANDLE};
 use bevy_transform::prelude::{GlobalTransform, Transform};
@@ -23,6 +24,7 @@ pub struct NodeBundle {
     pub mesh: Handle<Mesh>, // TODO: maybe abstract this out
     pub material: Handle<ColorMaterial>,
     pub draw: Draw,
+    pub visible: Visible,
     pub render_pipelines: RenderPipelines,
     pub transform: Transform,
     pub global_transform: GlobalTransform,
@@ -31,10 +33,14 @@ pub struct NodeBundle {
 impl Default for NodeBundle {
     fn default() -> Self {
         NodeBundle {
-            mesh: QUAD_HANDLE,
+            mesh: QUAD_HANDLE.typed(),
             render_pipelines: RenderPipelines::from_pipelines(vec![RenderPipeline::new(
-                UI_PIPELINE_HANDLE,
+                UI_PIPELINE_HANDLE.typed(),
             )]),
+            visible: Visible {
+                is_transparent: true,
+                ..Default::default()
+            },
             node: Default::default(),
             style: Default::default(),
             material: Default::default(),
@@ -54,6 +60,7 @@ pub struct ImageBundle {
     pub mesh: Handle<Mesh>, // TODO: maybe abstract this out
     pub material: Handle<ColorMaterial>,
     pub draw: Draw,
+    pub visible: Visible,
     pub render_pipelines: RenderPipelines,
     pub transform: Transform,
     pub global_transform: GlobalTransform,
@@ -62,9 +69,9 @@ pub struct ImageBundle {
 impl Default for ImageBundle {
     fn default() -> Self {
         ImageBundle {
-            mesh: QUAD_HANDLE,
+            mesh: QUAD_HANDLE.typed(),
             render_pipelines: RenderPipelines::from_pipelines(vec![RenderPipeline::new(
-                UI_PIPELINE_HANDLE,
+                UI_PIPELINE_HANDLE.typed(),
             )]),
             node: Default::default(),
             image: Default::default(),
@@ -72,6 +79,10 @@ impl Default for ImageBundle {
             style: Default::default(),
             material: Default::default(),
             draw: Default::default(),
+            visible: Visible {
+                is_transparent: true,
+                ..Default::default()
+            },
             transform: Default::default(),
             global_transform: Default::default(),
         }
@@ -83,6 +94,7 @@ pub struct TextBundle {
     pub node: Node,
     pub style: Style,
     pub draw: Draw,
+    pub visible: Visible,
     pub text: Text,
     pub calculated_size: CalculatedSize,
     pub focus_policy: FocusPolicy,
@@ -95,6 +107,9 @@ impl Default for TextBundle {
         TextBundle {
             focus_policy: FocusPolicy::Pass,
             draw: Draw {
+                ..Default::default()
+            },
+            visible: Visible {
                 is_transparent: true,
                 ..Default::default()
             },
@@ -118,6 +133,7 @@ pub struct ButtonBundle {
     pub mesh: Handle<Mesh>, // TODO: maybe abstract this out
     pub material: Handle<ColorMaterial>,
     pub draw: Draw,
+    pub visible: Visible,
     pub render_pipelines: RenderPipelines,
     pub transform: Transform,
     pub global_transform: GlobalTransform,
@@ -127,9 +143,9 @@ impl Default for ButtonBundle {
     fn default() -> Self {
         ButtonBundle {
             button: Button,
-            mesh: QUAD_HANDLE,
+            mesh: QUAD_HANDLE.typed(),
             render_pipelines: RenderPipelines::from_pipelines(vec![RenderPipeline::new(
-                UI_PIPELINE_HANDLE,
+                UI_PIPELINE_HANDLE.typed(),
             )]),
             interaction: Default::default(),
             focus_policy: Default::default(),
@@ -137,6 +153,10 @@ impl Default for ButtonBundle {
             style: Default::default(),
             material: Default::default(),
             draw: Default::default(),
+            visible: Visible {
+                is_transparent: true,
+                ..Default::default()
+            },
             transform: Default::default(),
             global_transform: Default::default(),
         }
@@ -144,7 +164,7 @@ impl Default for ButtonBundle {
 }
 
 #[derive(Bundle, Debug)]
-pub struct UiCameraBundle {
+pub struct CameraUiBundle {
     pub camera: Camera,
     pub orthographic_projection: OrthographicProjection,
     pub visible_entities: VisibleEntities,
@@ -152,14 +172,14 @@ pub struct UiCameraBundle {
     pub global_transform: GlobalTransform,
 }
 
-impl Default for UiCameraBundle {
+impl Default for CameraUiBundle {
     fn default() -> Self {
         // we want 0 to be "closest" and +far to be "farthest" in 2d, so we offset
         // the camera's translation by far and use a right handed coordinate system
         let far = 1000.0;
-        UiCameraBundle {
+        CameraUiBundle {
             camera: Camera {
-                name: Some(crate::camera::UI_CAMERA.to_string()),
+                name: Some(crate::camera::CAMERA_UI.to_string()),
                 ..Default::default()
             },
             orthographic_projection: OrthographicProjection {
diff --git a/crates/bevy_ui/src/flex/convert.rs b/crates/bevy_ui/src/flex/convert.rs
index 30de4499983db..43bb7c839c0cb 100644
--- a/crates/bevy_ui/src/flex/convert.rs
+++ b/crates/bevy_ui/src/flex/convert.rs
@@ -4,68 +4,71 @@ use crate::{
 };
 use bevy_math::{Rect, Size};
 
-fn from_rect<T, U>(rect: Rect<U>) -> stretch::geometry::Rect<T>
-where
-    T: From<U>,
-{
+pub fn from_rect(
+    scale_factor: f64,
+    rect: Rect<Val>,
+) -> stretch::geometry::Rect<stretch::style::Dimension> {
     stretch::geometry::Rect {
-        start: rect.left.into(),
-        end: rect.right.into(),
+        start: from_val(scale_factor, rect.left),
+        end: from_val(scale_factor, rect.right),
         // NOTE: top and bottom are intentionally flipped. stretch has a flipped y-axis
-        top: rect.bottom.into(),
-        bottom: rect.top.into(),
+        top: from_val(scale_factor, rect.bottom),
+        bottom: from_val(scale_factor, rect.top),
     }
 }
 
-fn from_size<T, U>(size: Size<U>) -> stretch::geometry::Size<T>
-where
-    T: From<U>,
-{
+pub fn from_f32_size(scale_factor: f64, size: Size<f32>) -> stretch::geometry::Size<f32> {
     stretch::geometry::Size {
-        width: size.width.into(),
-        height: size.height.into(),
+        width: (scale_factor * size.width as f64) as f32,
+        height: (scale_factor * size.height as f64) as f32,
     }
 }
 
-impl From<&Style> for stretch::style::Style {
-    fn from(value: &Style) -> Self {
-        Self {
-            overflow: stretch::style::Overflow::Visible,
-            display: value.display.into(),
-            position_type: value.position_type.into(),
-            direction: value.direction.into(),
-            flex_direction: value.flex_direction.into(),
-            flex_wrap: value.flex_wrap.into(),
-            align_items: value.align_items.into(),
-            align_self: value.align_self.into(),
-            align_content: value.align_content.into(),
-            justify_content: value.justify_content.into(),
-            position: from_rect(value.position),
-            margin: from_rect(value.margin),
-            padding: from_rect(value.padding),
-            border: from_rect(value.border),
-            flex_grow: value.flex_grow,
-            flex_shrink: value.flex_shrink,
-            flex_basis: value.flex_basis.into(),
-            size: from_size(value.size),
-            min_size: from_size(value.min_size),
-            max_size: from_size(value.max_size),
-            aspect_ratio: match value.aspect_ratio {
-                Some(value) => stretch::number::Number::Defined(value),
-                None => stretch::number::Number::Undefined,
-            },
-        }
+pub fn from_val_size(
+    scale_factor: f64,
+    size: Size<Val>,
+) -> stretch::geometry::Size<stretch::style::Dimension> {
+    stretch::geometry::Size {
+        width: from_val(scale_factor, size.width),
+        height: from_val(scale_factor, size.height),
     }
 }
 
-impl From<Val> for stretch::style::Dimension {
-    fn from(val: Val) -> Self {
-        match val {
-            Val::Auto => stretch::style::Dimension::Auto,
-            Val::Percent(value) => stretch::style::Dimension::Percent(value / 100.0),
-            Val::Px(value) => stretch::style::Dimension::Points(value),
-            Val::Undefined => stretch::style::Dimension::Undefined,
-        }
+pub fn from_style(scale_factor: f64, value: &Style) -> stretch::style::Style {
+    stretch::style::Style {
+        overflow: stretch::style::Overflow::Visible,
+        display: value.display.into(),
+        position_type: value.position_type.into(),
+        direction: value.direction.into(),
+        flex_direction: value.flex_direction.into(),
+        flex_wrap: value.flex_wrap.into(),
+        align_items: value.align_items.into(),
+        align_self: value.align_self.into(),
+        align_content: value.align_content.into(),
+        justify_content: value.justify_content.into(),
+        position: from_rect(scale_factor, value.position),
+        margin: from_rect(scale_factor, value.margin),
+        padding: from_rect(scale_factor, value.padding),
+        border: from_rect(scale_factor, value.border),
+        flex_grow: value.flex_grow,
+        flex_shrink: value.flex_shrink,
+        flex_basis: from_val(scale_factor, value.flex_basis),
+        size: from_val_size(scale_factor, value.size),
+        min_size: from_val_size(scale_factor, value.min_size),
+        max_size: from_val_size(scale_factor, value.max_size),
+        aspect_ratio: match value.aspect_ratio {
+            Some(value) => stretch::number::Number::Defined(value),
+            None => stretch::number::Number::Undefined,
+        },
+    }
+}
+
+pub fn from_val(scale_factor: f64, val: Val) -> stretch::style::Dimension {
+    match val {
+        Val::Auto => stretch::style::Dimension::Auto,
+        Val::Percent(value) => stretch::style::Dimension::Percent(value / 100.0),
+        Val::Px(value) => stretch::style::Dimension::Points((scale_factor * value as f64) as f32),
+        Val::Undefined => stretch::style::Dimension::Undefined,
     }
 }
 
diff --git a/crates/bevy_ui/src/flex/mod.rs b/crates/bevy_ui/src/flex/mod.rs
index abc9bc6084c8c..5e514424f20af 100644
--- a/crates/bevy_ui/src/flex/mod.rs
+++ b/crates/bevy_ui/src/flex/mod.rs
@@ -35,10 +35,10 @@ impl Default for FlexSurface {
 }
 
 impl FlexSurface {
-    pub fn upsert_node(&mut self, entity: Entity, style: &Style) {
+    pub fn upsert_node(&mut self, entity: Entity, style: &Style, scale_factor: f64) {
         let mut added = false;
         let stretch = &mut self.stretch;
-        let stretch_style = style.into();
+        let stretch_style = convert::from_style(scale_factor, style);
         let stretch_node = self.entity_to_stretch.entry(entity).or_insert_with(|| {
             added = true;
             stretch.new_node(stretch_style, Vec::new()).unwrap()
@@ -51,14 +51,17 @@ impl FlexSurface {
         }
     }
 
-    pub fn upsert_leaf(&mut self, entity: Entity, style: &Style, calculated_size: CalculatedSize) {
+    pub fn upsert_leaf(
+        &mut self,
+        entity: Entity,
+        style: &Style,
+        calculated_size: CalculatedSize,
+        scale_factor: f64,
+    ) {
         let stretch = &mut self.stretch;
-        let stretch_style = style.into();
+        let stretch_style = convert::from_style(scale_factor, style);
         let measure = Box::new(move |constraints: stretch::geometry::Size<Number>| {
-            let mut size = stretch::geometry::Size {
-                width: calculated_size.size.width,
-                height: calculated_size.size.height,
-            };
+            let mut size = convert::from_f32_size(scale_factor, calculated_size.size);
             match (constraints.width, constraints.height) {
                 (Number::Undefined, Number::Undefined) => {}
                 (Number::Defined(width), Number::Undefined) => {
@@ -116,8 +119,8 @@ impl FlexSurface {
                 *node,
                 stretch::style::Style {
                     size: stretch::geometry::Size {
-                        width: stretch::style::Dimension::Points(window.width() as f32),
-                        height: stretch::style::Dimension::Points(window.height() as f32),
+                        width: stretch::style::Dimension::Points(window.physical_width() as f32),
+                        height: stretch::style::Dimension::Points(window.physical_height() as f32),
                     },
                     ..Default::default()
                 },
@@ -174,18 +177,25 @@ pub fn flex_node_system(
         flex_surface.update_window(window);
     }
 
+    // assume one window for time being...
+    let logical_to_physical_factor = if let Some(primary_window) = windows.get_primary() {
+        primary_window.scale_factor()
+    } else {
+        1.
+    };
+
     // update changed nodes
     for (entity, style, calculated_size) in node_query.iter() {
         // TODO: remove node from old hierarchy if its root has changed
         if let Some(calculated_size) = calculated_size {
-            flex_surface.upsert_leaf(entity, &style, *calculated_size);
+            flex_surface.upsert_leaf(entity, &style, *calculated_size, logical_to_physical_factor);
         } else {
-            flex_surface.upsert_node(entity, &style);
+            flex_surface.upsert_node(entity, &style, logical_to_physical_factor);
         }
     }
 
     for (entity, style, calculated_size) in changed_size_query.iter() {
-        flex_surface.upsert_leaf(entity, &style, *calculated_size);
+        flex_surface.upsert_leaf(entity, &style, *calculated_size, logical_to_physical_factor);
     }
 
     // TODO: handle removed nodes
@@ -203,16 +213,23 @@ pub fn flex_node_system(
     // compute layouts
     flex_surface.compute_window_layouts();
 
+    let physical_to_logical_factor = 1. / logical_to_physical_factor;
+
+    let to_logical = |v| (physical_to_logical_factor * v as f64) as f32;
+
     for (entity, mut node, mut transform, parent) in node_transform_query.iter_mut() {
         let layout = flex_surface.get_layout(entity).unwrap();
-        node.size = Vec2::new(layout.size.width, layout.size.height);
+        node.size = Vec2::new(
+            to_logical(layout.size.width),
+            to_logical(layout.size.height),
+        );
         let position = &mut transform.translation;
-        position.x = layout.location.x + layout.size.width / 2.0;
-        position.y = layout.location.y + layout.size.height / 2.0;
+        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 let Some(parent) = parent {
             if let Ok(parent_layout) = flex_surface.get_layout(parent.0) {
-                position.x -= parent_layout.size.width / 2.0;
-                position.y -= parent_layout.size.height / 2.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 5ced61ebd9571..663b27b4c63db 100644
--- a/crates/bevy_ui/src/focus.rs
+++ b/crates/bevy_ui/src/focus.rs
@@ -56,7 +56,7 @@ pub fn ui_focus_system(
         state.cursor_position = cursor_moved.position;
     }
     if let Some(touch) = touches_input.get_pressed(0) {
-        state.cursor_position = touch.position;
+        state.cursor_position = touch.position();
     }
 
     if mouse_button_input.just_released(MouseButton::Left) || touches_input.just_released(0) {
diff --git a/crates/bevy_ui/src/lib.rs b/crates/bevy_ui/src/lib.rs
index 9152ac306e91a..9e62e520a9407 100644
--- a/crates/bevy_ui/src/lib.rs
+++ b/crates/bevy_ui/src/lib.rs
@@ -25,6 +25,7 @@ pub mod prelude {
 }
 
 use bevy_app::prelude::*;
+use bevy_ecs::{IntoSystem, SystemStage};
 use bevy_render::render_graph::RenderGraph;
 use update::ui_z_system;
 
@@ -38,14 +39,18 @@ pub mod stage {
 impl Plugin for UiPlugin {
     fn build(&self, app: &mut AppBuilder) {
         app.init_resource::<FlexSurface>()
-            .add_stage_before(bevy_app::stage::POST_UPDATE, stage::UI)
-            .add_system_to_stage(bevy_app::stage::PRE_UPDATE, ui_focus_system)
+            .add_stage_before(
+                bevy_app::stage::POST_UPDATE,
+                stage::UI,
+                SystemStage::parallel(),
+            )
+            .add_system_to_stage(bevy_app::stage::PRE_UPDATE, ui_focus_system.system())
             // add these stages to front because these must run before transform update systems
-            .add_system_to_stage(stage::UI, widget::text_system)
-            .add_system_to_stage(stage::UI, widget::image_node_system)
-            .add_system_to_stage(stage::UI, ui_z_system)
-            .add_system_to_stage(stage::UI, flex_node_system)
-            .add_system_to_stage(bevy_render::stage::DRAW, widget::draw_text_system);
+            .add_system_to_stage(stage::UI, widget::text_system.system())
+            .add_system_to_stage(stage::UI, widget::image_node_system.system())
+            .add_system_to_stage(stage::UI, ui_z_system.system())
+            .add_system_to_stage(stage::UI, flex_node_system.system())
+            .add_system_to_stage(bevy_render::stage::DRAW, widget::draw_text_system.system());
 
         let resources = app.resources();
         let mut render_graph = resources.get_mut::<RenderGraph>().unwrap();
diff --git a/crates/bevy_ui/src/node.rs b/crates/bevy_ui/src/node.rs
index 6d2a3a30536a0..feb2bc89bb367 100644
--- a/crates/bevy_ui/src/node.rs
+++ b/crates/bevy_ui/src/node.rs
@@ -1,13 +1,17 @@
 use bevy_math::{Rect, Size, Vec2};
+use bevy_reflect::{Reflect, ReflectComponent, ReflectDeserialize};
 use bevy_render::renderer::RenderResources;
+use serde::{Deserialize, Serialize};
 use std::ops::{Add, AddAssign};
 
-#[derive(Debug, Clone, Default, RenderResources)]
+#[derive(Debug, Clone, Default, RenderResources, Reflect)]
+#[reflect(Component)]
 pub struct Node {
     pub size: Vec2,
 }
 
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone, PartialEq, Debug, Serialize, Deserialize, Reflect)]
+#[reflect_value(PartialEq, Serialize, Deserialize)]
 pub enum Val {
     Undefined,
     Auto,
@@ -49,7 +53,7 @@ pub struct CalculatedSize {
     pub size: Size,
 }
 
-#[derive(Clone, PartialEq, Debug)]
+#[derive(Clone, PartialEq, Debug, Reflect)]
 pub struct Style {
     pub display: Display,
     pub position_type: PositionType,
@@ -100,7 +104,8 @@ impl Default for Style {
     }
 }
 
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone, PartialEq, Debug, Serialize, Deserialize, Reflect)]
+#[reflect_value(PartialEq, Serialize, Deserialize)]
 pub enum AlignItems {
     FlexStart,
     FlexEnd,
@@ -115,7 +120,8 @@ impl Default for AlignItems {
     }
 }
 
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone, PartialEq, Debug, Serialize, Deserialize, Reflect)]
+#[reflect_value(PartialEq, Serialize, Deserialize)]
 pub enum AlignSelf {
     Auto,
     FlexStart,
@@ -131,7 +137,8 @@ impl Default for AlignSelf {
     }
 }
 
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone, PartialEq, Debug, Serialize, Deserialize, Reflect)]
+#[reflect_value(PartialEq, Serialize, Deserialize)]
 pub enum AlignContent {
     FlexStart,
     FlexEnd,
@@ -147,7 +154,8 @@ impl Default for AlignContent {
     }
 }
 
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone, PartialEq, Debug, Serialize, Deserialize, Reflect)]
+#[reflect_value(PartialEq, Serialize, Deserialize)]
 pub enum Direction {
     Inherit,
     LTR,
@@ -160,7 +168,8 @@ impl Default for Direction {
     }
 }
 
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone, PartialEq, Debug, Serialize, Deserialize, Reflect)]
+#[reflect_value(PartialEq, Serialize, Deserialize)]
 pub enum Display {
     Flex,
     None,
@@ -172,7 +181,8 @@ impl Default for Display {
     }
 }
 
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone, PartialEq, Debug, Serialize, Deserialize, Reflect)]
+#[reflect_value(PartialEq, Serialize, Deserialize)]
 pub enum FlexDirection {
     Row,
     Column,
@@ -186,7 +196,8 @@ impl Default for FlexDirection {
     }
 }
 
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone, PartialEq, Debug, Serialize, Deserialize, Reflect)]
+#[reflect_value(PartialEq, Serialize, Deserialize)]
 pub enum JustifyContent {
     FlexStart,
     FlexEnd,
@@ -216,7 +227,8 @@ impl Default for JustifyContent {
 //     }
 // }
 
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone, PartialEq, Debug, Serialize, Deserialize, Reflect)]
+#[reflect_value(PartialEq, Serialize, Deserialize)]
 pub enum PositionType {
     Relative,
     Absolute,
@@ -228,7 +240,8 @@ impl Default for PositionType {
     }
 }
 
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone, PartialEq, Debug, Serialize, Deserialize, Reflect)]
+#[reflect_value(PartialEq, Serialize, Deserialize)]
 pub enum FlexWrap {
     NoWrap,
     Wrap,
diff --git a/crates/bevy_ui/src/render/mod.rs b/crates/bevy_ui/src/render/mod.rs
index 1da738af8cba7..d95e41db4fb22 100644
--- a/crates/bevy_ui/src/render/mod.rs
+++ b/crates/bevy_ui/src/render/mod.rs
@@ -1,6 +1,7 @@
 use crate::Node;
-use bevy_asset::{Assets, Handle};
+use bevy_asset::{Assets, HandleUntyped};
 use bevy_ecs::Resources;
+use bevy_reflect::TypeUuid;
 use bevy_render::{
     camera::ActiveCameras,
     pass::{
@@ -16,10 +17,9 @@ use bevy_render::{
     shader::{Shader, ShaderStage, ShaderStages},
     texture::TextureFormat,
 };
-use bevy_type_registry::TypeUuid;
 
-pub const UI_PIPELINE_HANDLE: Handle<PipelineDescriptor> =
-    Handle::weak_from_u64(PipelineDescriptor::TYPE_UUID, 3234320022263993878);
+pub const UI_PIPELINE_HANDLE: HandleUntyped =
+    HandleUntyped::weak_from_u64(PipelineDescriptor::TYPE_UUID, 3234320022263993878);
 
 pub fn build_ui_pipeline(shaders: &mut Assets<Shader>) -> PipelineDescriptor {
     PipelineDescriptor {
@@ -70,13 +70,13 @@ pub fn build_ui_pipeline(shaders: &mut Assets<Shader>) -> PipelineDescriptor {
 }
 
 pub mod node {
-    pub const UI_CAMERA: &str = "ui_camera";
+    pub const CAMERA_UI: &str = "camera_ui";
     pub const NODE: &str = "node";
     pub const UI_PASS: &str = "ui_pass";
 }
 
 pub mod camera {
-    pub const UI_CAMERA: &str = "UiCamera";
+    pub const CAMERA_UI: &str = "CameraUi";
 }
 
 pub trait UiRenderGraphBuilder {
@@ -110,7 +110,7 @@ impl UiRenderGraphBuilder for RenderGraph {
             sample_count: msaa.samples,
         });
 
-        ui_pass_node.add_camera(camera::UI_CAMERA);
+        ui_pass_node.add_camera(camera::CAMERA_UI);
         self.add_node(node::UI_PASS, ui_pass_node);
 
         self.add_slot_edge(
@@ -148,12 +148,12 @@ impl UiRenderGraphBuilder for RenderGraph {
             .unwrap();
 
         // setup ui camera
-        self.add_system_node(node::UI_CAMERA, CameraNode::new(camera::UI_CAMERA));
-        self.add_node_edge(node::UI_CAMERA, node::UI_PASS).unwrap();
+        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::UI_CAMERA);
+        active_cameras.add(camera::CAMERA_UI);
         self
     }
 }
diff --git a/crates/bevy_ui/src/update.rs b/crates/bevy_ui/src/update.rs
index b0dde1566eede..928bcc60b555d 100644
--- a/crates/bevy_ui/src/update.rs
+++ b/crates/bevy_ui/src/update.rs
@@ -1,49 +1,149 @@
 use super::Node;
 use bevy_ecs::{Entity, Query, With, Without};
-use bevy_transform::{
-    hierarchy,
-    prelude::{Children, Parent, Transform},
-};
+use bevy_transform::prelude::{Children, Parent, Transform};
 
 pub const UI_Z_STEP: f32 = 0.001;
 
 pub fn ui_z_system(
     root_node_query: Query<Entity, (With<Node>, Without<Parent>)>,
-    mut node_query: Query<(Entity, &mut Transform), With<Node>>,
+    mut node_query: Query<&mut Transform, With<Node>>,
     children_query: Query<&Children>,
 ) {
     let mut current_global_z = 0.0;
-
     for entity in root_node_query.iter() {
-        if let Some(result) = hierarchy::run_on_hierarchy(
+        current_global_z = update_hierarchy(
             &children_query,
             &mut node_query,
             entity,
-            Some(current_global_z),
-            Some(current_global_z),
-            &mut update_node_entity,
-        ) {
-            current_global_z = result;
-        }
+            current_global_z,
+            current_global_z,
+        );
     }
 }
 
-fn update_node_entity(
-    node_query: &mut Query<(Entity, &mut Transform), With<Node>>,
+fn update_hierarchy(
+    children_query: &Query<&Children>,
+    node_query: &mut Query<&mut Transform, With<Node>>,
     entity: Entity,
-    parent_result: Option<f32>,
-    previous_result: Option<f32>,
-) -> Option<f32> {
-    let mut z = UI_Z_STEP;
-    let parent_global_z = parent_result.unwrap();
-    if let Some(previous_global_z) = previous_result {
-        z += previous_global_z - parent_global_z;
-    };
-    let global_z = z + parent_global_z;
-
-    if let Ok(mut transform) = node_query.get_component_mut::<Transform>(entity) {
-        transform.translation.z = z;
+    parent_global_z: f32,
+    mut current_global_z: f32,
+) -> f32 {
+    current_global_z += UI_Z_STEP;
+    if let Ok(mut transform) = node_query.get_mut(entity) {
+        transform.translation.z = current_global_z - parent_global_z;
+    }
+    if let Ok(children) = children_query.get(entity) {
+        let current_parent_global_z = current_global_z;
+        for child in children.iter().cloned() {
+            current_global_z = update_hierarchy(
+                children_query,
+                node_query,
+                child,
+                current_parent_global_z,
+                current_global_z,
+            );
+        }
+    }
+    current_global_z
+}
+#[cfg(test)]
+mod tests {
+    use bevy_ecs::{Commands, IntoSystem, Resources, Schedule, SystemStage, World};
+    use bevy_transform::{components::Transform, hierarchy::BuildChildren};
+
+    use crate::Node;
+
+    use super::{ui_z_system, UI_Z_STEP};
+
+    fn node_with_transform(name: &str) -> (String, Node, Transform) {
+        (name.to_owned(), Node::default(), Transform::default())
     }
 
-    Some(global_z)
+    fn node_without_transform(name: &str) -> (String, Node) {
+        (name.to_owned(), Node::default())
+    }
+
+    fn get_steps(transform: &Transform) -> u32 {
+        (transform.translation.z / UI_Z_STEP).round() as u32
+    }
+
+    #[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());
+
+        commands.spawn(node_with_transform("0"));
+
+        commands
+            .spawn(node_with_transform("1"))
+            .with_children(|parent| {
+                parent
+                    .spawn(node_with_transform("1-0"))
+                    .with_children(|parent| {
+                        parent.spawn(node_with_transform("1-0-0"));
+                        parent.spawn(node_without_transform("1-0-1"));
+                        parent.spawn(node_with_transform("1-0-2"));
+                    });
+                parent.spawn(node_with_transform("1-1"));
+                parent
+                    .spawn(node_without_transform("1-2"))
+                    .with_children(|parent| {
+                        parent.spawn(node_with_transform("1-2-0"));
+                        parent.spawn(node_with_transform("1-2-1"));
+                        parent
+                            .spawn(node_with_transform("1-2-2"))
+                            .with_children(|_| ());
+                        parent.spawn(node_with_transform("1-2-3"));
+                    });
+                parent.spawn(node_with_transform("1-3"));
+            });
+
+        commands
+            .spawn(node_without_transform("2"))
+            .with_children(|parent| {
+                parent
+                    .spawn(node_with_transform("2-0"))
+                    .with_children(|_parent| ());
+                parent
+                    .spawn(node_with_transform("2-1"))
+                    .with_children(|parent| {
+                        parent.spawn(node_with_transform("2-1-0"));
+                    });
+            });
+        commands.apply(&mut world, &mut resources);
+
+        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.initialize_and_run(&mut world, &mut resources);
+
+        let mut actual_result = world
+            .query::<(&String, &Transform)>()
+            .map(|(name, transform)| (name.clone(), get_steps(transform)))
+            .collect::<Vec<(String, u32)>>();
+        actual_result.sort_unstable_by_key(|(name, _)| name.clone());
+        let expected_result = vec![
+            ("0".to_owned(), 1),
+            ("1".to_owned(), 1),
+            ("1-0".to_owned(), 1),
+            ("1-0-0".to_owned(), 1),
+            // 1-0-1 has no transform
+            ("1-0-2".to_owned(), 3),
+            ("1-1".to_owned(), 5),
+            // 1-2 has no transform
+            ("1-2-0".to_owned(), 1),
+            ("1-2-1".to_owned(), 2),
+            ("1-2-2".to_owned(), 3),
+            ("1-2-3".to_owned(), 4),
+            ("1-3".to_owned(), 11),
+            // 2 has no transform
+            ("2-0".to_owned(), 1),
+            ("2-1".to_owned(), 2),
+            ("2-1-0".to_owned(), 1),
+        ];
+        assert_eq!(actual_result, expected_result);
+    }
 }
diff --git a/crates/bevy_ui/src/widget/image.rs b/crates/bevy_ui/src/widget/image.rs
index cde64fe0a320c..835d7a520b857 100644
--- a/crates/bevy_ui/src/widget/image.rs
+++ b/crates/bevy_ui/src/widget/image.rs
@@ -28,8 +28,8 @@ pub fn image_node_system(
             .and_then(|texture_handle| textures.get(texture_handle))
         {
             calculated_size.size = Size {
-                width: texture.size.x,
-                height: texture.size.y,
+                width: texture.size.width as f32,
+                height: texture.size.height as f32,
             };
         }
     }
diff --git a/crates/bevy_ui/src/widget/text.rs b/crates/bevy_ui/src/widget/text.rs
index c2dc9113c1540..c5dd8d389d606 100644
--- a/crates/bevy_ui/src/widget/text.rs
+++ b/crates/bevy_ui/src/widget/text.rs
@@ -5,8 +5,8 @@ use bevy_math::Size;
 use bevy_render::{
     draw::{Draw, DrawContext, Drawable},
     mesh::Mesh,
-    prelude::Msaa,
-    renderer::{AssetRenderResourceBindings, RenderResourceBindings},
+    prelude::{Msaa, Visible},
+    renderer::RenderResourceBindings,
     texture::Texture,
 };
 use bevy_sprite::{TextureAtlas, QUAD_HANDLE};
@@ -133,7 +133,7 @@ fn add_text_to_pipeline(
     ) {
         Err(TextError::NoSuchFont) => TextPipelineResult::Reschedule,
         Err(e @ TextError::FailedToAddGlyph(_)) => {
-            panic!("Fatal error when processing text: {}", e);
+            panic!("Fatal error when processing text: {}.", e);
         }
         Ok(()) => TextPipelineResult::Ok,
     }
@@ -145,20 +145,22 @@ pub fn draw_text_system(
     msaa: Res<Msaa>,
     meshes: Res<Assets<Mesh>>,
     mut render_resource_bindings: ResMut<RenderResourceBindings>,
-    mut asset_render_resource_bindings: ResMut<AssetRenderResourceBindings>,
     text_pipeline: Res<DefaultTextPipeline>,
-    mut query: Query<(Entity, &mut Draw, &Text, &Node, &GlobalTransform)>,
+    mut query: Query<(Entity, &mut Draw, &Visible, &Text, &Node, &GlobalTransform)>,
 ) {
     let font_quad = meshes.get(&QUAD_HANDLE).unwrap();
     let vertex_buffer_descriptor = font_quad.get_vertex_buffer_descriptor();
 
-    for (entity, mut draw, text, node, global_transform) in query.iter_mut() {
+    for (entity, mut draw, visible, text, node, global_transform) in query.iter_mut() {
+        if !visible.is_visible {
+            continue;
+        }
+
         if let Some(text_glyphs) = text_pipeline.get_glyphs(&entity) {
             let position = global_transform.translation - (node.size / 2.0).extend(0.0);
 
             let mut drawable_text = DrawableText {
                 render_resource_bindings: &mut render_resource_bindings,
-                asset_render_resource_bindings: &mut asset_render_resource_bindings,
                 position,
                 msaa: &msaa,
                 text_glyphs: &text_glyphs.glyphs,
diff --git a/crates/bevy_utils/Cargo.toml b/crates/bevy_utils/Cargo.toml
index 843b487a4e1b9..96ce6d8097bff 100644
--- a/crates/bevy_utils/Cargo.toml
+++ b/crates/bevy_utils/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_utils"
-version = "0.3.0"
+version = "0.4.0"
 edition = "2018"
 authors = [
     "Bevy Contributors <bevyengine@gmail.com>",
@@ -13,9 +13,11 @@ license = "MIT"
 keywords = ["bevy"]
 
 [dependencies]
-ahash = "0.5.3"
+ahash = "0.6.1"
 tracing = {version = "0.1", features = ["release_max_level_info"]}
 instant = { version = "0.1", features = ["wasm-bindgen"] }
+uuid = { version = "0.8", features = ["v4", "serde"] }
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 getrandom = {version = "0.2.0", features = ["js"]}
+uuid = { version = "0.8", features = ["wasm-bindgen"] }
diff --git a/crates/bevy_utils/src/lib.rs b/crates/bevy_utils/src/lib.rs
index 64ebf1da9543e..c1afc20bd365b 100644
--- a/crates/bevy_utils/src/lib.rs
+++ b/crates/bevy_utils/src/lib.rs
@@ -3,6 +3,7 @@ use ahash::RandomState;
 pub use instant::{Duration, Instant};
 use std::{future::Future, pin::Pin};
 pub use tracing;
+pub use uuid::Uuid;
 
 #[cfg(not(target_arch = "wasm32"))]
 pub type BoxedFuture<'a, T> = Pin<Box<dyn Future<Output = T> + Send + 'a>>;
diff --git a/crates/bevy_wgpu/Cargo.toml b/crates/bevy_wgpu/Cargo.toml
index aa96a3d8c21cf..31d9cc1d92698 100644
--- a/crates/bevy_wgpu/Cargo.toml
+++ b/crates/bevy_wgpu/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_wgpu"
-version = "0.3.0"
+version = "0.4.0"
 edition = "2018"
 authors = [
     "Bevy Contributors <bevyengine@gmail.com>",
@@ -18,15 +18,15 @@ trace = ["wgpu/trace"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.3.0" }
-bevy_asset = { path = "../bevy_asset", version = "0.3.0" }
-bevy_core = { path = "../bevy_core", version = "0.3.0" }
-bevy_diagnostic = { path = "../bevy_diagnostic", version = "0.3.0" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.3.0" }
-bevy_render = { path = "../bevy_render", version = "0.3.0" }
-bevy_window = { path = "../bevy_window", version = "0.3.0" }
-bevy_winit = { path = "../bevy_winit", optional = true, version = "0.3.0" }
-bevy_utils = { path = "../bevy_utils", version = "0.3.0" }
+bevy_app = { path = "../bevy_app", version = "0.4.0" }
+bevy_asset = { path = "../bevy_asset", version = "0.4.0" }
+bevy_core = { path = "../bevy_core", version = "0.4.0" }
+bevy_diagnostic = { path = "../bevy_diagnostic", version = "0.4.0" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.4.0" }
+bevy_render = { path = "../bevy_render", version = "0.4.0" }
+bevy_window = { path = "../bevy_window", version = "0.4.0" }
+bevy_winit = { path = "../bevy_winit", optional = true, version = "0.4.0" }
+bevy_utils = { path = "../bevy_utils", version = "0.4.0" }
 
 # other
 wgpu = "0.6"
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 0af3f94fc915c..079332c93cf89 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::{Res, ResMut};
+use bevy_ecs::{IntoSystem, Res, ResMut};
 use bevy_render::renderer::RenderResourceContext;
 
 #[derive(Default)]
@@ -9,8 +9,8 @@ pub struct WgpuResourceDiagnosticsPlugin;
 
 impl Plugin for WgpuResourceDiagnosticsPlugin {
     fn build(&self, app: &mut AppBuilder) {
-        app.add_startup_system(Self::setup_system)
-            .add_system(Self::diagnostic_system);
+        app.add_startup_system(Self::setup_system.system())
+            .add_system(Self::diagnostic_system.system());
     }
 }
 
diff --git a/crates/bevy_wgpu/src/lib.rs b/crates/bevy_wgpu/src/lib.rs
index 27c1b3e802575..1a3ca89c2b29d 100644
--- a/crates/bevy_wgpu/src/lib.rs
+++ b/crates/bevy_wgpu/src/lib.rs
@@ -11,8 +11,8 @@ pub use wgpu_renderer::*;
 pub use wgpu_resources::*;
 
 use bevy_app::prelude::*;
-use bevy_ecs::{Resources, World};
-use bevy_render::renderer::{free_shared_buffers_system, RenderResourceContext, SharedBuffers};
+use bevy_ecs::{IntoSystem, Resources, World};
+use bevy_render::renderer::{shared_buffers_update_system, RenderResourceContext, SharedBuffers};
 use renderer::WgpuRenderResourceContext;
 
 #[derive(Default)]
@@ -21,8 +21,11 @@ pub struct WgpuPlugin;
 impl Plugin for WgpuPlugin {
     fn build(&self, app: &mut AppBuilder) {
         let render_system = get_wgpu_render_system(app.resources_mut());
-        app.add_system_to_stage(bevy_render::stage::RENDER, render_system)
-            .add_system_to_stage(bevy_render::stage::POST_RENDER, free_shared_buffers_system);
+        app.add_system_to_stage(bevy_render::stage::RENDER, render_system.system())
+            .add_system_to_stage(
+                bevy_render::stage::POST_RENDER,
+                shared_buffers_update_system.system(),
+            );
     }
 }
 
@@ -32,8 +35,8 @@ pub fn get_wgpu_render_system(resources: &mut Resources) -> impl FnMut(&mut Worl
         .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.clone()));
-    resources.insert(SharedBuffers::new(Box::new(resource_context)));
+    resources.insert::<Box<dyn RenderResourceContext>>(Box::new(resource_context));
+    resources.insert(SharedBuffers::new(4096));
     move |world, resources| {
         wgpu_renderer.update(world, resources);
     }
@@ -41,7 +44,43 @@ pub fn get_wgpu_render_system(resources: &mut Resources) -> impl FnMut(&mut Worl
 
 #[derive(Default, Clone)]
 pub struct WgpuOptions {
-    power_pref: WgpuPowerOptions,
+    pub backend: WgpuBackend,
+    pub power_pref: WgpuPowerOptions,
+}
+
+#[derive(Clone)]
+pub enum WgpuBackend {
+    Auto,
+    Vulkan,
+    Metal,
+    Dx12,
+    Dx11,
+    GL,
+    BrowserWgpu,
+}
+
+impl WgpuBackend {
+    fn from_env() -> Self {
+        if let Ok(backend) = std::env::var("BEVY_WGPU_BACKEND") {
+            match backend.to_lowercase().as_str() {
+                "vulkan" => WgpuBackend::Vulkan,
+                "metal" => WgpuBackend::Metal,
+                "dx12" => WgpuBackend::Dx12,
+                "dx11" => WgpuBackend::Dx11,
+                "gl" => WgpuBackend::GL,
+                "webgpu" => WgpuBackend::BrowserWgpu,
+                other => panic!("Unknown backend: {}", other),
+            }
+        } else {
+            WgpuBackend::Auto
+        }
+    }
+}
+
+impl Default for WgpuBackend {
+    fn default() -> Self {
+        Self::from_env()
+    }
 }
 
 #[derive(Clone)]
diff --git a/crates/bevy_wgpu/src/renderer/wgpu_render_context.rs b/crates/bevy_wgpu/src/renderer/wgpu_render_context.rs
index b42f9722b307b..f4efbcad7b2a1 100644
--- a/crates/bevy_wgpu/src/renderer/wgpu_render_context.rs
+++ b/crates/bevy_wgpu/src/renderer/wgpu_render_context.rs
@@ -188,11 +188,11 @@ fn get_texture_view<'a>(
         TextureAttachment::Name(name) => match global_render_resource_bindings.get(&name) {
             Some(RenderResourceBinding::Texture(resource)) => refs.textures.get(&resource).unwrap(),
             _ => {
-                panic!("Color attachment {} does not exist", name);
+                panic!("Color attachment {} does not exist.", name);
             }
         },
         TextureAttachment::Id(render_resource) => refs.textures.get(&render_resource).unwrap_or_else(|| &refs.swap_chain_frames.get(&render_resource).unwrap().output.view),
-        TextureAttachment::Input(_) => panic!("Encountered unset TextureAttachment::Input. The RenderGraph executor should always set TextureAttachment::Inputs to TextureAttachment::RenderResource before running. This is a bug"),
+        TextureAttachment::Input(_) => panic!("Encountered unset `TextureAttachment::Input`. The `RenderGraph` executor should always set `TextureAttachment::Inputs` to `TextureAttachment::RenderResource` before running. This is a bug, please report it!"),
     }
 }
 
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 e8b864d9e38aa..b1fe146cfee74 100644
--- a/crates/bevy_wgpu/src/renderer/wgpu_render_graph_executor.rs
+++ b/crates/bevy_wgpu/src/renderer/wgpu_render_graph_executor.rs
@@ -60,14 +60,14 @@ impl WgpuRenderGraphExecutor {
                                 let outputs = if let Some(outputs) = node_outputs.get(output_node) {
                                     outputs
                                 } else {
-                                    panic!("node inputs not set")
+                                    panic!("Node inputs not set.")
                                 };
 
                                 let output_resource =
-                                    outputs.get(*output_index).expect("output should be set");
+                                    outputs.get(*output_index).expect("Output should be set.");
                                 input_slot.resource = Some(output_resource);
                             } else {
-                                panic!("no edge connected to input")
+                                panic!("No edge connected to input.")
                             }
                         }
                         node_state.node.update(
diff --git a/crates/bevy_wgpu/src/renderer/wgpu_render_resource_context.rs b/crates/bevy_wgpu/src/renderer/wgpu_render_resource_context.rs
index a2a7ae5d20df2..f235c359ce036 100644
--- a/crates/bevy_wgpu/src/renderer/wgpu_render_resource_context.rs
+++ b/crates/bevy_wgpu/src/renderer/wgpu_render_resource_context.rs
@@ -12,7 +12,7 @@ use bevy_render::{
         BindGroup, BufferId, BufferInfo, RenderResourceBinding, RenderResourceContext,
         RenderResourceId, SamplerId, TextureId,
     },
-    shader::{glsl_to_spirv, Shader, ShaderSource},
+    shader::{glsl_to_spirv, Shader, ShaderError, ShaderSource},
     texture::{Extent3d, SamplerDescriptor, TextureDescriptor},
 };
 use bevy_utils::tracing::trace;
@@ -88,7 +88,7 @@ impl WgpuRenderResourceContext {
                 layout: wgpu::TextureDataLayout {
                     offset: source_offset,
                     bytes_per_row: source_bytes_per_row,
-                    rows_per_image: 0, // NOTE: Example sets this to 0, but should it be height?
+                    rows_per_image: size.height,
                 },
             },
             wgpu::TextureCopyView {
@@ -227,8 +227,8 @@ impl RenderResourceContext for WgpuRenderResourceContext {
     }
 
     fn remove_buffer(&self, buffer: BufferId) {
-        let mut buffers = self.resources.buffers.write();
         let mut buffer_infos = self.resources.buffer_infos.write();
+        let mut buffers = self.resources.buffers.write();
 
         buffers.remove(&buffer);
         buffer_infos.remove(&buffer);
@@ -251,7 +251,7 @@ impl RenderResourceContext for WgpuRenderResourceContext {
 
     fn create_shader_module_from_source(&self, shader_handle: &Handle<Shader>, shader: &Shader) {
         let mut shader_modules = self.resources.shader_modules.write();
-        let spirv: Cow<[u32]> = shader.get_spirv(None).into();
+        let spirv: Cow<[u32]> = shader.get_spirv(None).unwrap().into();
         let shader_module = self
             .device
             .create_shader_module(wgpu::ShaderModuleSource::SpirV(spirv));
@@ -279,7 +279,7 @@ impl RenderResourceContext for WgpuRenderResourceContext {
         let swap_chain_descriptor: wgpu::SwapChainDescriptor = window.wgpu_into();
         let surface = surfaces
             .get(&window.id())
-            .expect("No surface found for window");
+            .expect("No surface found for window.");
         let swap_chain = self
             .device
             .create_swap_chain(surface, &swap_chain_descriptor);
@@ -522,6 +522,10 @@ impl RenderResourceContext for WgpuRenderResourceContext {
         self.resources.bind_groups.write().clear();
     }
 
+    fn remove_stale_bind_groups(&self) {
+        self.resources.remove_stale_bind_groups();
+    }
+
     fn get_buffer_info(&self, buffer: BufferId) -> Option<BufferInfo> {
         self.resources.buffer_infos.read().get(&buffer).cloned()
     }
@@ -548,7 +552,7 @@ impl RenderResourceContext for WgpuRenderResourceContext {
         let data = buffer_slice.map_async(wgpu::MapMode::Write);
         self.device.poll(wgpu::Maintain::Wait);
         if future::block_on(data).is_err() {
-            panic!("failed to map buffer to host");
+            panic!("Failed to map buffer to host.");
         }
     }
 
@@ -570,14 +574,18 @@ impl RenderResourceContext for WgpuRenderResourceContext {
         }
     }
 
-    fn get_specialized_shader(&self, shader: &Shader, macros: Option<&[String]>) -> Shader {
+    fn get_specialized_shader(
+        &self,
+        shader: &Shader,
+        macros: Option<&[String]>,
+    ) -> Result<Shader, ShaderError> {
         let spirv_data = match shader.source {
             ShaderSource::Spirv(ref bytes) => bytes.clone(),
-            ShaderSource::Glsl(ref source) => glsl_to_spirv(&source, shader.stage, macros),
+            ShaderSource::Glsl(ref source) => glsl_to_spirv(&source, shader.stage, macros)?,
         };
-        Shader {
+        Ok(Shader {
             source: ShaderSource::Spirv(spirv_data),
             ..*shader
-        }
+        })
     }
 }
diff --git a/crates/bevy_wgpu/src/wgpu_render_pass.rs b/crates/bevy_wgpu/src/wgpu_render_pass.rs
index ee94b0189986c..e68337df2b7fb 100644
--- a/crates/bevy_wgpu/src/wgpu_render_pass.rs
+++ b/crates/bevy_wgpu/src/wgpu_render_pass.rs
@@ -74,6 +74,10 @@ impl<'a> RenderPass for WgpuRenderPass<'a> {
                     } else {
                         EMPTY
                     };
+                self.wgpu_resources
+                    .used_bind_group_sender
+                    .send(bind_group)
+                    .unwrap();
 
                 trace!(
                     "set bind group {:?} {:?}: {:?}",
@@ -93,7 +97,7 @@ impl<'a> RenderPass for WgpuRenderPass<'a> {
             .render_pipelines
             .get(pipeline_handle)
             .expect(
-            "Attempted to use a pipeline that does not exist in this RenderPass's RenderContext",
+            "Attempted to use a pipeline that does not exist in this `RenderPass`'s `RenderContext`.",
         );
         self.render_pass.set_pipeline(pipeline);
     }
diff --git a/crates/bevy_wgpu/src/wgpu_renderer.rs b/crates/bevy_wgpu/src/wgpu_renderer.rs
index 7b39c2f5e6559..acd80b5f81776 100644
--- a/crates/bevy_wgpu/src/wgpu_renderer.rs
+++ b/crates/bevy_wgpu/src/wgpu_renderer.rs
@@ -1,6 +1,6 @@
 use crate::{
     renderer::{WgpuRenderGraphExecutor, WgpuRenderResourceContext},
-    WgpuOptions, WgpuPowerOptions,
+    WgpuBackend, WgpuOptions, WgpuPowerOptions,
 };
 use bevy_app::prelude::*;
 use bevy_ecs::{Resources, World};
@@ -22,7 +22,16 @@ pub struct WgpuRenderer {
 
 impl WgpuRenderer {
     pub async fn new(options: WgpuOptions) -> Self {
-        let instance = wgpu::Instance::new(wgpu::BackendBit::PRIMARY);
+        let backend = match options.backend {
+            WgpuBackend::Auto => wgpu::BackendBit::PRIMARY,
+            WgpuBackend::Vulkan => wgpu::BackendBit::VULKAN,
+            WgpuBackend::Metal => wgpu::BackendBit::METAL,
+            WgpuBackend::Dx12 => wgpu::BackendBit::DX12,
+            WgpuBackend::Dx11 => wgpu::BackendBit::DX11,
+            WgpuBackend::GL => wgpu::BackendBit::GL,
+            WgpuBackend::BrowserWgpu => wgpu::BackendBit::BROWSER_WEBGPU,
+        };
+        let instance = wgpu::Instance::new(backend);
 
         let adapter = instance
             .request_adapter(&wgpu::RequestAdapterOptions {
@@ -78,7 +87,7 @@ impl WgpuRenderer {
         {
             let window = windows
                 .get(window_created_event.id)
-                .expect("Received window created event for non-existent window");
+                .expect("Received window created event for non-existent window.");
             #[cfg(feature = "bevy_winit")]
             {
                 let winit_windows = resources.get::<bevy_winit::WinitWindows>().unwrap();
@@ -115,6 +124,6 @@ impl WgpuRenderer {
 
         let render_resource_context = resources.get::<Box<dyn RenderResourceContext>>().unwrap();
         render_resource_context.drop_all_swap_chain_textures();
-        render_resource_context.clear_bind_groups();
+        render_resource_context.remove_stale_bind_groups();
     }
 }
diff --git a/crates/bevy_wgpu/src/wgpu_resources.rs b/crates/bevy_wgpu/src/wgpu_resources.rs
index f36f3644882a3..aa3e76c6beb37 100644
--- a/crates/bevy_wgpu/src/wgpu_resources.rs
+++ b/crates/bevy_wgpu/src/wgpu_resources.rs
@@ -7,6 +7,7 @@ use bevy_render::{
 };
 use bevy_utils::HashMap;
 use bevy_window::WindowId;
+use crossbeam_channel::{Receiver, Sender, TryRecvError};
 use parking_lot::{RwLock, RwLockReadGuard};
 use std::sync::Arc;
 
@@ -45,6 +46,7 @@ pub struct WgpuResourcesReadLock<'a> {
     pub render_pipelines:
         RwLockReadGuard<'a, HashMap<Handle<PipelineDescriptor>, wgpu::RenderPipeline>>,
     pub bind_groups: RwLockReadGuard<'a, HashMap<BindGroupDescriptorId, WgpuBindGroupInfo>>,
+    pub used_bind_group_sender: Sender<BindGroupId>,
 }
 
 impl<'a> WgpuResourcesReadLock<'a> {
@@ -55,6 +57,7 @@ impl<'a> WgpuResourcesReadLock<'a> {
             swap_chain_frames: &self.swap_chain_frames,
             render_pipelines: &self.render_pipelines,
             bind_groups: &self.bind_groups,
+            used_bind_group_sender: &self.used_bind_group_sender,
         }
     }
 }
@@ -67,6 +70,7 @@ pub struct WgpuResourceRefs<'a> {
     pub swap_chain_frames: &'a HashMap<TextureId, wgpu::SwapChainFrame>,
     pub render_pipelines: &'a HashMap<Handle<PipelineDescriptor>, wgpu::RenderPipeline>,
     pub bind_groups: &'a HashMap<BindGroupDescriptorId, WgpuBindGroupInfo>,
+    pub used_bind_group_sender: &'a Sender<BindGroupId>,
 }
 
 #[derive(Default, Clone, Debug)]
@@ -85,6 +89,7 @@ pub struct WgpuResources {
     pub bind_groups: Arc<RwLock<HashMap<BindGroupDescriptorId, WgpuBindGroupInfo>>>,
     pub bind_group_layouts: Arc<RwLock<HashMap<BindGroupDescriptorId, wgpu::BindGroupLayout>>>,
     pub asset_resources: Arc<RwLock<HashMap<(HandleUntyped, u64), RenderResourceId>>>,
+    pub bind_group_counter: BindGroupCounter,
 }
 
 impl WgpuResources {
@@ -95,6 +100,7 @@ impl WgpuResources {
             swap_chain_frames: self.swap_chain_frames.read(),
             render_pipelines: self.render_pipelines.read(),
             bind_groups: self.bind_groups.read(),
+            used_bind_group_sender: self.bind_group_counter.used_bind_group_sender.clone(),
         }
     }
 
@@ -109,4 +115,64 @@ impl WgpuResources {
             false
         }
     }
+
+    pub fn remove_stale_bind_groups(&self) {
+        let mut bind_groups = self.bind_groups.write();
+        self.bind_group_counter
+            .remove_stale_bind_groups(&mut bind_groups);
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct BindGroupCounter {
+    pub used_bind_group_sender: Sender<BindGroupId>,
+    pub used_bind_group_receiver: Receiver<BindGroupId>,
+    pub bind_group_usage_counts: Arc<RwLock<HashMap<BindGroupId, u64>>>,
+}
+
+impl BindGroupCounter {
+    pub fn remove_stale_bind_groups(
+        &self,
+        bind_groups: &mut HashMap<BindGroupDescriptorId, WgpuBindGroupInfo>,
+    ) {
+        let mut bind_group_usage_counts = self.bind_group_usage_counts.write();
+        loop {
+            let bind_group = match self.used_bind_group_receiver.try_recv() {
+                Ok(bind_group) => bind_group,
+                Err(TryRecvError::Empty) => break,
+                Err(TryRecvError::Disconnected) => panic!("used bind group channel disconnected"),
+            };
+
+            let count = bind_group_usage_counts.entry(bind_group).or_insert(0);
+            // free every two frames
+            *count = 2;
+        }
+
+        for info in bind_groups.values_mut() {
+            info.bind_groups.retain(|id, _| {
+                let retain = {
+                    // if a value hasn't been counted yet, give it two frames of leeway
+                    let count = bind_group_usage_counts.entry(*id).or_insert(2);
+                    *count -= 1;
+                    *count > 0
+                };
+                if !retain {
+                    bind_group_usage_counts.remove(&id);
+                }
+
+                retain
+            })
+        }
+    }
+}
+
+impl Default for BindGroupCounter {
+    fn default() -> Self {
+        let (send, recv) = crossbeam_channel::unbounded();
+        BindGroupCounter {
+            used_bind_group_sender: send,
+            used_bind_group_receiver: recv,
+            bind_group_usage_counts: Default::default(),
+        }
+    }
 }
diff --git a/crates/bevy_wgpu/src/wgpu_type_converter.rs b/crates/bevy_wgpu/src/wgpu_type_converter.rs
index 8ffc846b63f44..e6e176263e045 100644
--- a/crates/bevy_wgpu/src/wgpu_type_converter.rs
+++ b/crates/bevy_wgpu/src/wgpu_type_converter.rs
@@ -564,10 +564,10 @@ impl WgpuFrom<&Window> for wgpu::SwapChainDescriptor {
         wgpu::SwapChainDescriptor {
             usage: wgpu::TextureUsage::OUTPUT_ATTACHMENT,
             format: TextureFormat::default().wgpu_into(),
-            width: window.width(),
-            height: window.height(),
+            width: window.physical_width(),
+            height: window.physical_height(),
             present_mode: if window.vsync() {
-                wgpu::PresentMode::Fifo
+                wgpu::PresentMode::Mailbox
             } else {
                 wgpu::PresentMode::Immediate
             },
diff --git a/crates/bevy_window/Cargo.toml b/crates/bevy_window/Cargo.toml
index cb211b1bb4c39..6c340562decfe 100644
--- a/crates/bevy_window/Cargo.toml
+++ b/crates/bevy_window/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_window"
-version = "0.3.0"
+version = "0.4.0"
 edition = "2018"
 authors = [
     "Bevy Contributors <bevyengine@gmail.com>",
@@ -14,14 +14,12 @@ keywords = ["bevy"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.3.0" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.3.0" }
-bevy_math = { path = "../bevy_math", version = "0.3.0" }
-bevy_utils = { path = "../bevy_utils", version = "0.3.0" }
+bevy_app = { path = "../bevy_app", version = "0.4.0" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.4.0" }
+bevy_math = { path = "../bevy_math", version = "0.4.0" }
+bevy_utils = { path = "../bevy_utils", version = "0.4.0" }
 
 # other
-uuid = { version = "0.8", features = ["v4", "serde"] }
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
-uuid = { version = "0.8", features = ["wasm-bindgen"] }
 web-sys = "0.3"
diff --git a/crates/bevy_window/src/event.rs b/crates/bevy_window/src/event.rs
index f441bdd6f7bd5..ddb77f666cdc0 100644
--- a/crates/bevy_window/src/event.rs
+++ b/crates/bevy_window/src/event.rs
@@ -5,8 +5,8 @@ use bevy_math::Vec2;
 #[derive(Debug, Clone)]
 pub struct WindowResized {
     pub id: WindowId,
-    pub width: usize,
-    pub height: usize,
+    pub width: f32,
+    pub height: f32,
 }
 
 /// An event that indicates that a new window should be created.
@@ -41,9 +41,26 @@ pub struct CursorMoved {
     pub position: Vec2,
 }
 
+#[derive(Debug, Clone)]
+pub struct CursorEntered {
+    pub id: WindowId,
+}
+
+#[derive(Debug, Clone)]
+pub struct CursorLeft {
+    pub id: WindowId,
+}
+
 /// An event that is sent whenever a window receives a character from the OS or underlying system.
 #[derive(Debug, Clone)]
 pub struct ReceivedCharacter {
     pub id: WindowId,
     pub char: char,
 }
+
+/// An event that indicates a window has received or lost focus.
+#[derive(Debug, Clone)]
+pub struct WindowFocused {
+    pub id: WindowId,
+    pub focused: bool,
+}
diff --git a/crates/bevy_window/src/lib.rs b/crates/bevy_window/src/lib.rs
index 0c07496c0028c..0ebfe3ad576b6 100644
--- a/crates/bevy_window/src/lib.rs
+++ b/crates/bevy_window/src/lib.rs
@@ -3,13 +3,17 @@ mod system;
 mod window;
 mod windows;
 
+use bevy_ecs::IntoSystem;
 pub use event::*;
 pub use system::*;
 pub use window::*;
 pub use windows::*;
 
 pub mod prelude {
-    pub use crate::{CursorMoved, ReceivedCharacter, Window, WindowDescriptor, Windows};
+    pub use crate::{
+        CursorEntered, CursorLeft, CursorMoved, ReceivedCharacter, Window, WindowDescriptor,
+        Windows,
+    };
 }
 
 use bevy_app::prelude::*;
@@ -36,7 +40,10 @@ impl Plugin for WindowPlugin {
             .add_event::<WindowCloseRequested>()
             .add_event::<CloseWindow>()
             .add_event::<CursorMoved>()
+            .add_event::<CursorEntered>()
+            .add_event::<CursorLeft>()
             .add_event::<ReceivedCharacter>()
+            .add_event::<WindowFocused>()
             .init_resource::<Windows>();
 
         if self.add_primary_window {
@@ -53,7 +60,7 @@ impl Plugin for WindowPlugin {
         }
 
         if self.exit_on_close {
-            app.add_system(exit_on_window_close_system);
+            app.add_system(exit_on_window_close_system.system());
         }
     }
 }
diff --git a/crates/bevy_window/src/window.rs b/crates/bevy_window/src/window.rs
index 0b6c45bdff2ad..ab173dd006e6f 100644
--- a/crates/bevy_window/src/window.rs
+++ b/crates/bevy_window/src/window.rs
@@ -1,4 +1,5 @@
-use uuid::Uuid;
+use bevy_math::Vec2;
+use bevy_utils::Uuid;
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
 pub struct WindowId(Uuid);
@@ -31,17 +32,36 @@ impl Default for WindowId {
     }
 }
 
+/// An operating system window that can present content and receive user input.
+///
+/// ## Window Sizes
+///
+/// There are three sizes associated with a window. The physical size which is
+/// the height and width in physical pixels on the monitor. The logical size
+/// which is the physical size scaled by an operating system provided factor to
+/// account for monitors with differing pixel densities or user preference. And
+/// the requested size, measured in logical pixels, which is the value submitted
+/// to the API when creating the window, or requesting that it be resized.
+///
+/// The actual size, in logical pixels, of the window may not match the
+/// requested size due to operating system limits on the window size, or the
+/// quantization of the logical size when converting the physical size to the
+/// logical size through the scaling factor.
 #[derive(Debug)]
 pub struct Window {
     id: WindowId,
-    width: u32,
-    height: u32,
+    requested_width: f32,
+    requested_height: f32,
+    physical_width: u32,
+    physical_height: u32,
+    scale_factor: f64,
     title: String,
     vsync: bool,
     resizable: bool,
     decorations: bool,
     cursor_visible: bool,
     cursor_locked: bool,
+    cursor_position: Option<Vec2>,
     mode: WindowMode,
     #[cfg(target_arch = "wasm32")]
     pub canvas: Option<String>,
@@ -58,8 +78,7 @@ pub enum WindowCommand {
         title: String,
     },
     SetResolution {
-        width: u32,
-        height: u32,
+        resolution: (f32, f32),
     },
     SetVsync {
         vsync: bool,
@@ -76,6 +95,12 @@ pub enum WindowCommand {
     SetCursorVisibility {
         visible: bool,
     },
+    SetCursorPosition {
+        position: Vec2,
+    },
+    SetMaximized {
+        maximized: bool,
+    },
 }
 
 /// Defines the way a window is displayed
@@ -91,17 +116,27 @@ pub enum WindowMode {
 }
 
 impl Window {
-    pub fn new(id: WindowId, window_descriptor: &WindowDescriptor) -> Self {
+    pub fn new(
+        id: WindowId,
+        window_descriptor: &WindowDescriptor,
+        physical_width: u32,
+        physical_height: u32,
+        scale_factor: f64,
+    ) -> Self {
         Window {
             id,
-            height: window_descriptor.height,
-            width: window_descriptor.width,
+            requested_width: window_descriptor.width,
+            requested_height: window_descriptor.height,
+            physical_width,
+            physical_height,
+            scale_factor,
             title: window_descriptor.title.clone(),
             vsync: window_descriptor.vsync,
             resizable: window_descriptor.resizable,
             decorations: window_descriptor.decorations,
             cursor_visible: window_descriptor.cursor_visible,
             cursor_locked: window_descriptor.cursor_locked,
+            cursor_position: None,
             mode: window_descriptor.mode,
             #[cfg(target_arch = "wasm32")]
             canvas: window_descriptor.canvas.clone(),
@@ -114,27 +149,85 @@ impl Window {
         self.id
     }
 
+    /// The current logical width of the window's client area.
+    #[inline]
+    pub fn width(&self) -> f32 {
+        (self.physical_width as f64 / self.scale_factor) as f32
+    }
+
+    /// The current logical height of the window's client area.
     #[inline]
-    pub fn width(&self) -> u32 {
-        self.width
+    pub fn height(&self) -> f32 {
+        (self.physical_height as f64 / self.scale_factor) as f32
     }
 
+    /// The requested window client area width in logical pixels from window
+    /// creation or the last call to [set_resolution](Window::set_resolution).
+    ///
+    /// This may differ from the actual width depending on OS size limits and
+    /// the scaling factor for high DPI monitors.
     #[inline]
-    pub fn height(&self) -> u32 {
-        self.height
+    pub fn requested_width(&self) -> f32 {
+        self.requested_width
     }
 
-    pub fn set_resolution(&mut self, width: u32, height: u32) {
-        self.width = width;
-        self.height = height;
+    /// The requested window client area height in logical pixels from window
+    /// creation or the last call to [set_resolution](Window::set_resolution).
+    ///
+    /// This may differ from the actual width depending on OS size limits and
+    /// the scaling factor for high DPI monitors.
+    #[inline]
+    pub fn requested_height(&self) -> f32 {
+        self.requested_height
+    }
+
+    /// The window's client area width in physical pixels.
+    #[inline]
+    pub fn physical_width(&self) -> u32 {
+        self.physical_width
+    }
+
+    /// The window's client area height in physical pixels.
+    #[inline]
+    pub fn physical_height(&self) -> u32 {
+        self.physical_height
+    }
+
+    #[inline]
+    pub fn set_maximized(&mut self, maximized: bool) {
         self.command_queue
-            .push(WindowCommand::SetResolution { width, height });
+            .push(WindowCommand::SetMaximized { maximized });
+    }
+
+    /// Request the OS to resize the window such the the client area matches the
+    /// specified width and height.
+    pub fn set_resolution(&mut self, width: f32, height: f32) {
+        self.requested_width = width;
+        self.requested_height = height;
+        self.command_queue.push(WindowCommand::SetResolution {
+            resolution: (self.requested_width, self.requested_height),
+        });
     }
 
-    #[doc(hidden)]
-    pub fn update_resolution_from_backend(&mut self, width: u32, height: u32) {
-        self.width = width;
-        self.height = height;
+    #[allow(missing_docs)]
+    #[inline]
+    pub fn update_scale_factor_from_backend(&mut self, scale_factor: f64) {
+        self.scale_factor = scale_factor;
+    }
+
+    #[allow(missing_docs)]
+    #[inline]
+    pub fn update_actual_size_from_backend(&mut self, physical_width: u32, physical_height: u32) {
+        self.physical_width = physical_width;
+        self.physical_height = physical_height;
+    }
+
+    /// The ratio of physical pixels to logical pixels
+    ///
+    /// `physical_pixels = logical_pixels * scale_factor`
+    #[inline]
+    pub fn scale_factor(&self) -> f64 {
+        self.scale_factor
     }
 
     #[inline]
@@ -203,6 +296,22 @@ impl Window {
         });
     }
 
+    #[inline]
+    pub fn cursor_position(&self) -> Option<Vec2> {
+        self.cursor_position
+    }
+
+    pub fn set_cursor_position(&mut self, position: Vec2) {
+        self.command_queue
+            .push(WindowCommand::SetCursorPosition { position });
+    }
+
+    #[allow(missing_docs)]
+    #[inline]
+    pub fn update_cursor_position_from_backend(&mut self, cursor_position: Option<Vec2>) {
+        self.cursor_position = cursor_position;
+    }
+
     #[inline]
     pub fn mode(&self) -> WindowMode {
         self.mode
@@ -212,7 +321,7 @@ impl Window {
         self.mode = mode;
         self.command_queue.push(WindowCommand::SetWindowMode {
             mode,
-            resolution: (self.width, self.height),
+            resolution: (self.physical_width, self.physical_height),
         });
     }
 
@@ -224,8 +333,8 @@ impl Window {
 
 #[derive(Debug, Clone)]
 pub struct WindowDescriptor {
-    pub width: u32,
-    pub height: u32,
+    pub width: f32,
+    pub height: f32,
     pub title: String,
     pub vsync: bool,
     pub resizable: bool,
@@ -241,8 +350,8 @@ impl Default for WindowDescriptor {
     fn default() -> Self {
         WindowDescriptor {
             title: "bevy".to_string(),
-            width: 1280,
-            height: 720,
+            width: 1280.,
+            height: 720.,
             vsync: true,
             resizable: true,
             decorations: true,
diff --git a/crates/bevy_winit/Cargo.toml b/crates/bevy_winit/Cargo.toml
index 7403b52396189..f9ef5394d147a 100644
--- a/crates/bevy_winit/Cargo.toml
+++ b/crates/bevy_winit/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_winit"
-version = "0.3.0"
+version = "0.4.0"
 edition = "2018"
 authors = [
     "Bevy Contributors <bevyengine@gmail.com>",
@@ -18,17 +18,17 @@ x11 = ["winit/x11"]
 
 [dependencies]
 # bevy
-bevy_app = { path = "../bevy_app", version = "0.3.0" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.3.0" }
-bevy_input = { path = "../bevy_input", version = "0.3.0" }
-bevy_math = { path = "../bevy_math", version = "0.3.0" }
-bevy_window = { path = "../bevy_window", version = "0.3.0" }
-bevy_utils = { path = "../bevy_utils", version = "0.3.0" }
+bevy_app = { path = "../bevy_app", version = "0.4.0" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.4.0" }
+bevy_input = { path = "../bevy_input", version = "0.4.0" }
+bevy_math = { path = "../bevy_math", version = "0.4.0" }
+bevy_window = { path = "../bevy_window", version = "0.4.0" }
+bevy_utils = { path = "../bevy_utils", version = "0.4.0" }
 
 # other
-winit = { version = "0.23.0", default-features = false }
+winit = { version = "0.24.0", default-features = false }
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
-winit = { version = "0.23.0", features = ["web-sys"], default-features = false }
+winit = { version = "0.24.0", features = ["web-sys"], default-features = false }
 wasm-bindgen = { version = "0.2" }
 web-sys = "0.3"
diff --git a/crates/bevy_winit/src/converters.rs b/crates/bevy_winit/src/converters.rs
index 060096de401c1..19d6ed903be5d 100644
--- a/crates/bevy_winit/src/converters.rs
+++ b/crates/bevy_winit/src/converters.rs
@@ -30,7 +30,10 @@ pub fn convert_mouse_button(mouse_button: winit::event::MouseButton) -> MouseBut
     }
 }
 
-pub fn convert_touch_input(touch_input: winit::event::Touch) -> TouchInput {
+pub fn convert_touch_input(
+    touch_input: winit::event::Touch,
+    location: winit::dpi::LogicalPosition<f32>,
+) -> TouchInput {
     TouchInput {
         phase: match touch_input.phase {
             winit::event::TouchPhase::Started => TouchPhase::Started,
@@ -38,7 +41,7 @@ pub fn convert_touch_input(touch_input: winit::event::Touch) -> TouchInput {
             winit::event::TouchPhase::Ended => TouchPhase::Ended,
             winit::event::TouchPhase::Cancelled => TouchPhase::Cancelled,
         },
-        position: Vec2::new(touch_input.location.x as f32, touch_input.location.y as f32),
+        position: Vec2::new(location.x as f32, location.y as f32),
         force: touch_input.force.map(|f| match f {
             winit::event::Force::Calibrated {
                 force,
diff --git a/crates/bevy_winit/src/lib.rs b/crates/bevy_winit/src/lib.rs
index f5c05e8db6ee2..9302bf46696d9 100644
--- a/crates/bevy_winit/src/lib.rs
+++ b/crates/bevy_winit/src/lib.rs
@@ -10,12 +10,12 @@ pub use winit_config::*;
 pub use winit_windows::*;
 
 use bevy_app::{prelude::*, AppExit};
-use bevy_ecs::{Resources, World};
+use bevy_ecs::{IntoSystem, Resources, World};
 use bevy_math::Vec2;
-use bevy_utils::tracing::trace;
+use bevy_utils::tracing::{error, trace};
 use bevy_window::{
-    CreateWindow, CursorMoved, ReceivedCharacter, Window, WindowCloseRequested, WindowCreated,
-    WindowResized, Windows,
+    CreateWindow, CursorEntered, CursorLeft, CursorMoved, ReceivedCharacter, WindowCloseRequested,
+    WindowCreated, WindowFocused, WindowResized, Windows,
 };
 use winit::{
     event::{self, DeviceEvent, Event, WindowEvent},
@@ -27,13 +27,9 @@ pub struct WinitPlugin;
 
 impl Plugin for WinitPlugin {
     fn build(&self, app: &mut AppBuilder) {
-        app
-            // TODO: It would be great to provide a raw winit WindowEvent here, but the lifetime on it is
-            // stopping us. there are plans to remove the lifetime: https://github.com/rust-windowing/winit/pull/1456
-            // .add_event::<winit::event::WindowEvent>()
-            .init_resource::<WinitWindows>()
+        app.init_resource::<WinitWindows>()
             .set_runner(winit_runner)
-            .add_system(change_window);
+            .add_system(change_window.system());
     }
 }
 
@@ -71,9 +67,14 @@ fn change_window(_: &mut World, resources: &mut Resources) {
                     let window = winit_windows.get_window(id).unwrap();
                     window.set_title(&title);
                 }
-                bevy_window::WindowCommand::SetResolution { width, height } => {
+                bevy_window::WindowCommand::SetResolution {
+                    resolution: (logical_width, logical_height),
+                } => {
                     let window = winit_windows.get_window(id).unwrap();
-                    window.set_inner_size(winit::dpi::PhysicalSize::new(width, height));
+                    window.set_inner_size(winit::dpi::LogicalSize::new(
+                        logical_width,
+                        logical_height,
+                    ));
                 }
                 bevy_window::WindowCommand::SetVsync { .. } => (),
                 bevy_window::WindowCommand::SetResizable { resizable } => {
@@ -86,12 +87,28 @@ fn change_window(_: &mut World, resources: &mut Resources) {
                 }
                 bevy_window::WindowCommand::SetCursorLockMode { locked } => {
                     let window = winit_windows.get_window(id).unwrap();
-                    window.set_cursor_grab(locked).unwrap();
+                    window
+                        .set_cursor_grab(locked)
+                        .unwrap_or_else(|e| error!("Unable to un/grab cursor: {}", e));
                 }
                 bevy_window::WindowCommand::SetCursorVisibility { visible } => {
                     let window = winit_windows.get_window(id).unwrap();
                     window.set_cursor_visible(visible);
                 }
+                bevy_window::WindowCommand::SetCursorPosition { position } => {
+                    let window = winit_windows.get_window(id).unwrap();
+                    let inner_size = window.inner_size().to_logical::<f32>(window.scale_factor());
+                    window
+                        .set_cursor_position(winit::dpi::LogicalPosition::new(
+                            position.x,
+                            inner_size.height - position.y,
+                        ))
+                        .unwrap_or_else(|e| error!("Unable to set cursor position: {}", e));
+                }
+                bevy_window::WindowCommand::SetMaximized { maximized } => {
+                    let window = winit_windows.get_window(id).unwrap();
+                    window.set_maximized(maximized)
+                }
             }
         }
     }
@@ -120,7 +137,7 @@ fn run_return<F>(event_loop: &mut EventLoop<()>, event_handler: F)
 where
     F: FnMut(Event<'_, ()>, &EventLoopWindowTarget<()>, &mut ControlFlow),
 {
-    use winit::platform::desktop::EventLoopExtDesktop;
+    use winit::platform::run_return::EventLoopExtRunReturn;
     event_loop.run_return(event_handler)
 }
 
@@ -147,8 +164,6 @@ pub fn winit_runner(mut app: App) {
 
     app.resources.insert_thread_local(event_loop.create_proxy());
 
-    app.initialize();
-
     trace!("Entering winit event loop");
 
     let should_return_from_run = app
@@ -168,29 +183,25 @@ pub fn winit_runner(mut app: App) {
         }
 
         match event {
-            event::Event::WindowEvent {
-                event: WindowEvent::Resized(size),
-                window_id: winit_window_id,
-                ..
-            } => {
-                let winit_windows = app.resources.get_mut::<WinitWindows>().unwrap();
-                let mut windows = app.resources.get_mut::<Windows>().unwrap();
-                let window_id = winit_windows.get_window_id(winit_window_id).unwrap();
-                let window = windows.get_mut(window_id).unwrap();
-                window.update_resolution_from_backend(size.width, size.height);
-
-                let mut resize_events = app.resources.get_mut::<Events<WindowResized>>().unwrap();
-                resize_events.send(WindowResized {
-                    id: window_id,
-                    height: window.height() as usize,
-                    width: window.width() as usize,
-                });
-            }
             event::Event::WindowEvent {
                 event,
                 window_id: winit_window_id,
                 ..
             } => match event {
+                WindowEvent::Resized(size) => {
+                    let winit_windows = app.resources.get_mut::<WinitWindows>().unwrap();
+                    let mut windows = app.resources.get_mut::<Windows>().unwrap();
+                    let window_id = winit_windows.get_window_id(winit_window_id).unwrap();
+                    let window = windows.get_mut(window_id).unwrap();
+                    window.update_actual_size_from_backend(size.width, size.height);
+                    let mut resize_events =
+                        app.resources.get_mut::<Events<WindowResized>>().unwrap();
+                    resize_events.send(WindowResized {
+                        id: window_id,
+                        width: window.width(),
+                        height: window.height(),
+                    });
+                }
                 WindowEvent::CloseRequested => {
                     let mut window_close_requested_events = app
                         .resources
@@ -209,16 +220,43 @@ pub fn winit_runner(mut app: App) {
                     let mut cursor_moved_events =
                         app.resources.get_mut::<Events<CursorMoved>>().unwrap();
                     let winit_windows = app.resources.get_mut::<WinitWindows>().unwrap();
+                    let mut windows = app.resources.get_mut::<Windows>().unwrap();
                     let window_id = winit_windows.get_window_id(winit_window_id).unwrap();
-                    let window = winit_windows.get_window(window_id).unwrap();
-                    let inner_size = window.inner_size();
+                    let winit_window = winit_windows.get_window(window_id).unwrap();
+                    let window = windows.get_mut(window_id).unwrap();
+                    let position = position.to_logical(winit_window.scale_factor());
+                    let inner_size = winit_window
+                        .inner_size()
+                        .to_logical::<f32>(winit_window.scale_factor());
+
                     // move origin to bottom left
-                    let y_position = inner_size.height as f32 - position.y as f32;
+                    let y_position = inner_size.height - position.y;
+
+                    let position = Vec2::new(position.x, y_position);
+                    window.update_cursor_position_from_backend(Some(position));
+
                     cursor_moved_events.send(CursorMoved {
                         id: window_id,
-                        position: Vec2::new(position.x as f32, y_position as f32),
+                        position,
                     });
                 }
+                WindowEvent::CursorEntered { .. } => {
+                    let mut cursor_entered_events =
+                        app.resources.get_mut::<Events<CursorEntered>>().unwrap();
+                    let winit_windows = app.resources.get_mut::<WinitWindows>().unwrap();
+                    let window_id = winit_windows.get_window_id(winit_window_id).unwrap();
+                    cursor_entered_events.send(CursorEntered { id: window_id });
+                }
+                WindowEvent::CursorLeft { .. } => {
+                    let mut cursor_left_events =
+                        app.resources.get_mut::<Events<CursorLeft>>().unwrap();
+                    let winit_windows = app.resources.get_mut::<WinitWindows>().unwrap();
+                    let mut windows = app.resources.get_mut::<Windows>().unwrap();
+                    let window_id = winit_windows.get_window_id(winit_window_id).unwrap();
+                    let window = windows.get_mut(window_id).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();
@@ -247,16 +285,22 @@ pub fn winit_runner(mut app: App) {
                         });
                     }
                 },
-                WindowEvent::Touch(mut touch) => {
+                WindowEvent::Touch(touch) => {
                     let mut touch_input_events =
                         app.resources.get_mut::<Events<TouchInput>>().unwrap();
+
+                    let winit_windows = app.resources.get_mut::<WinitWindows>().unwrap();
                     let windows = app.resources.get_mut::<Windows>().unwrap();
+                    let window_id = winit_windows.get_window_id(winit_window_id).unwrap();
+                    let winit_window = winit_windows.get_window(window_id).unwrap();
+                    let mut location = touch.location.to_logical(winit_window.scale_factor());
+
                     // FIXME?: On Android window start is top while on PC/Linux/OSX on bottom
                     if cfg!(target_os = "android") {
                         let window_height = windows.get_primary().unwrap().height();
-                        touch.location.y = window_height as f64 - touch.location.y;
+                        location.y = window_height - location.y;
                     }
-                    touch_input_events.send(converters::convert_touch_input(touch));
+                    touch_input_events.send(converters::convert_touch_input(touch, location));
                 }
                 WindowEvent::ReceivedCharacter(c) => {
                     let mut char_input_events = app
@@ -272,16 +316,51 @@ pub fn winit_runner(mut app: App) {
                         char: c,
                     })
                 }
+                WindowEvent::ScaleFactorChanged {
+                    scale_factor,
+                    new_inner_size,
+                } => {
+                    let winit_windows = app.resources.get_mut::<WinitWindows>().unwrap();
+                    let mut windows = app.resources.get_mut::<Windows>().unwrap();
+                    let window_id = winit_windows.get_window_id(winit_window_id).unwrap();
+                    let window = windows.get_mut(window_id).unwrap();
+                    window.update_actual_size_from_backend(
+                        new_inner_size.width,
+                        new_inner_size.height,
+                    );
+                    window.update_scale_factor_from_backend(scale_factor);
+                    // should we send a resize event to indicate the change in
+                    // logical size?
+                }
+                WindowEvent::Focused(focused) => {
+                    let mut focused_events =
+                        app.resources.get_mut::<Events<WindowFocused>>().unwrap();
+                    let winit_windows = app.resources.get_mut::<WinitWindows>().unwrap();
+                    match (winit_windows.get_window_id(winit_window_id), focused) {
+                        (Some(window_id), _) => focused_events.send(WindowFocused {
+                            id: window_id,
+                            focused,
+                        }),
+                        // unfocus event for an unknown window, ignore it
+                        (None, false) => (),
+                        // focus event on an unknown window, this is an error
+                        _ => panic!(
+                            "Focused(true) event on unknown window {:?}",
+                            winit_window_id
+                        ),
+                    }
+                }
                 _ => {}
             },
-            event::Event::DeviceEvent { ref event, .. } => {
-                if let DeviceEvent::MouseMotion { delta } = event {
-                    let mut mouse_motion_events =
-                        app.resources.get_mut::<Events<MouseMotion>>().unwrap();
-                    mouse_motion_events.send(MouseMotion {
-                        delta: Vec2::new(delta.0 as f32, delta.1 as f32),
-                    });
-                }
+            event::Event::DeviceEvent {
+                event: DeviceEvent::MouseMotion { delta },
+                ..
+            } => {
+                let mut mouse_motion_events =
+                    app.resources.get_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(
@@ -311,10 +390,14 @@ fn handle_create_window_events(
     let create_window_events = resources.get::<Events<CreateWindow>>().unwrap();
     let mut window_created_events = resources.get_mut::<Events<WindowCreated>>().unwrap();
     for create_window_event in create_window_event_reader.iter(&create_window_events) {
-        let window = Window::new(create_window_event.id, &create_window_event.descriptor);
-        winit_windows.create_window(event_loop, &window);
-        let window_id = window.id();
+        let window = winit_windows.create_window(
+            event_loop,
+            create_window_event.id,
+            &create_window_event.descriptor,
+        );
         windows.add(window);
-        window_created_events.send(WindowCreated { id: window_id });
+        window_created_events.send(WindowCreated {
+            id: create_window_event.id,
+        });
     }
 }
diff --git a/crates/bevy_winit/src/winit_windows.rs b/crates/bevy_winit/src/winit_windows.rs
index ec86a1a800dee..f2bee4c6d73f5 100644
--- a/crates/bevy_winit/src/winit_windows.rs
+++ b/crates/bevy_winit/src/winit_windows.rs
@@ -1,5 +1,5 @@
 use bevy_utils::HashMap;
-use bevy_window::{Window, WindowId, WindowMode};
+use bevy_window::{Window, WindowDescriptor, WindowId, WindowMode};
 
 #[derive(Debug, Default)]
 pub struct WinitWindows {
@@ -12,8 +12,9 @@ impl WinitWindows {
     pub fn create_window(
         &mut self,
         event_loop: &winit::event_loop::EventLoopWindowTarget<()>,
-        window: &Window,
-    ) {
+        window_id: WindowId,
+        window_descriptor: &WindowDescriptor,
+    ) -> Window {
         #[cfg(target_os = "windows")]
         let mut winit_window_builder = {
             use winit::platform::windows::WindowBuilderExtWindows;
@@ -23,7 +24,7 @@ impl WinitWindows {
         #[cfg(not(target_os = "windows"))]
         let mut winit_window_builder = winit::window::WindowBuilder::new();
 
-        winit_window_builder = match window.mode() {
+        winit_window_builder = match window_descriptor.mode {
             WindowMode::BorderlessFullscreen => winit_window_builder.with_fullscreen(Some(
                 winit::window::Fullscreen::Borderless(event_loop.primary_monitor()),
             )),
@@ -31,64 +32,62 @@ impl WinitWindows {
                 winit::window::Fullscreen::Exclusive(match use_size {
                     true => get_fitting_videomode(
                         &event_loop.primary_monitor().unwrap(),
-                        window.width(),
-                        window.height(),
+                        window_descriptor.width as u32,
+                        window_descriptor.height as u32,
                     ),
                     false => get_best_videomode(&event_loop.primary_monitor().unwrap()),
                 }),
             )),
             _ => winit_window_builder
-                .with_inner_size(winit::dpi::PhysicalSize::new(
-                    window.width(),
-                    window.height(),
+                .with_inner_size(winit::dpi::LogicalSize::new(
+                    window_descriptor.width,
+                    window_descriptor.height,
                 ))
-                .with_resizable(window.resizable())
-                .with_decorations(window.decorations()),
+                .with_resizable(window_descriptor.resizable)
+                .with_decorations(window_descriptor.decorations),
         };
 
         #[allow(unused_mut)]
-        let mut winit_window_builder = winit_window_builder.with_title(window.title());
+        let mut winit_window_builder = winit_window_builder.with_title(&window_descriptor.title);
 
         #[cfg(target_arch = "wasm32")]
         {
             use wasm_bindgen::JsCast;
             use winit::platform::web::WindowBuilderExtWebSys;
 
-            if let Some(selector) = &window.canvas {
+            if let Some(selector) = &window_descriptor.canvas {
                 let window = web_sys::window().unwrap();
                 let document = window.document().unwrap();
                 let canvas = document
                     .query_selector(&selector)
-                    .expect("Cannot query for canvas element");
+                    .expect("Cannot query for canvas element.");
                 if let Some(canvas) = canvas {
                     let canvas = canvas.dyn_into::<web_sys::HtmlCanvasElement>().ok();
                     winit_window_builder = winit_window_builder.with_canvas(canvas);
                 } else {
-                    panic!("Cannot find element: {}", selector);
+                    panic!("Cannot find element: {}.", selector);
                 }
             }
         }
 
         let winit_window = winit_window_builder.build(&event_loop).unwrap();
 
-        match winit_window.set_cursor_grab(window.cursor_locked()) {
+        match winit_window.set_cursor_grab(window_descriptor.cursor_locked) {
             Ok(_) => {}
             Err(winit::error::ExternalError::NotSupported(_)) => {}
             Err(err) => Err(err).unwrap(),
         }
 
-        winit_window.set_cursor_visible(window.cursor_visible());
+        winit_window.set_cursor_visible(window_descriptor.cursor_visible);
 
-        self.window_id_to_winit
-            .insert(window.id(), winit_window.id());
-        self.winit_to_window_id
-            .insert(winit_window.id(), window.id());
+        self.window_id_to_winit.insert(window_id, winit_window.id());
+        self.winit_to_window_id.insert(winit_window.id(), window_id);
 
         #[cfg(target_arch = "wasm32")]
         {
             use winit::platform::web::WindowExtWebSys;
 
-            if window.canvas.is_none() {
+            if window_descriptor.canvas.is_none() {
                 let canvas = winit_window.canvas();
 
                 let window = web_sys::window().unwrap();
@@ -96,11 +95,21 @@ impl WinitWindows {
                 let body = document.body().unwrap();
 
                 body.append_child(&canvas)
-                    .expect("Append canvas to HTML body");
+                    .expect("Append canvas to HTML body.");
             }
         }
 
+        let inner_size = winit_window.inner_size();
+        let scale_factor = winit_window.scale_factor();
         self.windows.insert(winit_window.id(), winit_window);
+
+        Window::new(
+            window_id,
+            &window_descriptor,
+            inner_size.width,
+            inner_size.height,
+            scale_factor,
+        )
     }
 
     pub fn get_window(&self, id: WindowId) -> Option<&winit::window::Window> {
diff --git a/docs/linux_dependencies.md b/docs/linux_dependencies.md
index 2992f1b9dcdf5..b620a1317e014 100644
--- a/docs/linux_dependencies.md
+++ b/docs/linux_dependencies.md
@@ -9,6 +9,11 @@ If you don't see your distro present in the list, feel free to add the instructi
 ```bash
 sudo apt-get install pkg-config libx11-dev libasound2-dev libudev-dev
 ```
+If you want to Enable Fast Compiles
+```bash
+sudo apt-get install clang
+```
+
 ### Windows Subsystem for Linux (WSL 2)
 
 Graphics and audio need to be configured for them to work with WSL 2 backend. 
diff --git a/examples/2d/contributors.rs b/examples/2d/contributors.rs
index 5941c82dad43b..b1f562737219d 100644
--- a/examples/2d/contributors.rs
+++ b/examples/2d/contributors.rs
@@ -9,11 +9,11 @@ use std::{
 fn main() {
     App::build()
         .add_plugins(DefaultPlugins)
-        .add_startup_system(setup)
-        .add_system(velocity_system)
-        .add_system(move_system)
-        .add_system(collision_system)
-        .add_system(select_system)
+        .add_startup_system(setup.system())
+        .add_system(velocity_system.system())
+        .add_system(move_system.system())
+        .add_system(collision_system.system())
+        .add_system(select_system.system())
         .run();
 }
 
@@ -56,7 +56,7 @@ fn setup(
 
     commands
         .spawn(Camera2dBundle::default())
-        .spawn(UiCameraBundle::default());
+        .spawn(CameraUiBundle::default());
 
     let mut sel = ContributorSelection {
         order: vec![],
@@ -134,10 +134,11 @@ fn select_system(
     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>,
 ) {
     let mut timer_fired = false;
     for mut t in tq.iter_mut() {
-        if !t.just_finished {
+        if !t.tick(time.delta_seconds()).just_finished() {
             continue;
         }
         t.reset();
@@ -217,7 +218,7 @@ fn deselect(
 
 /// Applies gravity to all entities with velocity
 fn velocity_system(time: Res<Time>, mut q: Query<Mut<Velocity>>) {
-    let delta = time.delta_seconds;
+    let delta = time.delta_seconds();
 
     for mut v in q.iter_mut() {
         v.translation += Vec3::new(0.0, GRAVITY * delta, 0.0);
@@ -237,11 +238,11 @@ fn collision_system(
 
     let win = wins.get_primary().unwrap();
 
-    let ceiling = (win.height() / 2) as f32;
-    let ground = -((win.height() / 2) as f32);
+    let ceiling = win.height() / 2.;
+    let ground = -(win.height() / 2.);
 
-    let wall_left = -((win.width() / 2) as f32);
-    let wall_right = (win.width() / 2) as f32;
+    let wall_left = -(win.width() / 2.);
+    let wall_right = win.width() / 2.;
 
     for (mut v, mut t) in q.iter_mut() {
         let left = t.translation.x - SPRITE_SIZE / 2.0;
@@ -274,7 +275,7 @@ fn collision_system(
 
 /// Apply velocity to positions and rotations.
 fn move_system(time: Res<Time>, mut q: Query<(&Velocity, Mut<Transform>)>) {
-    let delta = time.delta_seconds;
+    let delta = time.delta_seconds();
 
     for (v, mut t) in q.iter_mut() {
         t.translation += delta * v.translation;
@@ -289,16 +290,16 @@ fn move_system(time: Res<Time>, mut q: Query<(&Velocity, Mut<Transform>)>) {
 /// the program is run through `cargo`.
 fn contributors() -> Contributors {
     let manifest_dir = std::env::var("CARGO_MANIFEST_DIR")
-        .expect("This example needs to run through `cargo run --example`");
+        .expect("This example needs to run through `cargo run --example`.");
 
     let mut cmd = std::process::Command::new("git")
         .args(&["--no-pager", "log", "--pretty=format:%an"])
         .current_dir(manifest_dir)
         .stdout(Stdio::piped())
         .spawn()
-        .expect("git needs to be installed");
+        .expect("`git` needs to be installed.");
 
-    let stdout = cmd.stdout.take().expect("Child should have a stdout");
+    let stdout = cmd.stdout.take().expect("`Child` should have a stdout.");
 
     BufReader::new(stdout)
         .lines()
diff --git a/examples/2d/sprite.rs b/examples/2d/sprite.rs
index 9cd245cbf7a1d..2d8f298c3e1da 100644
--- a/examples/2d/sprite.rs
+++ b/examples/2d/sprite.rs
@@ -3,7 +3,7 @@ use bevy::prelude::*;
 fn main() {
     App::build()
         .add_plugins(DefaultPlugins)
-        .add_startup_system(setup)
+        .add_startup_system(setup.system())
         .run();
 }
 
diff --git a/examples/2d/sprite_sheet.rs b/examples/2d/sprite_sheet.rs
index 04fa883409820..e8c92c45df346 100644
--- a/examples/2d/sprite_sheet.rs
+++ b/examples/2d/sprite_sheet.rs
@@ -3,17 +3,19 @@ use bevy::prelude::*;
 fn main() {
     App::build()
         .add_plugins(DefaultPlugins)
-        .add_startup_system(setup)
-        .add_system(animate_sprite_system)
+        .add_startup_system(setup.system())
+        .add_system(animate_sprite_system.system())
         .run();
 }
 
 fn animate_sprite_system(
+    time: Res<Time>,
     texture_atlases: Res<Assets<TextureAtlas>>,
     mut query: Query<(&mut Timer, &mut TextureAtlasSprite, &Handle<TextureAtlas>)>,
 ) {
-    for (timer, mut sprite, texture_atlas_handle) in query.iter_mut() {
-        if timer.finished {
+    for (mut timer, mut sprite, texture_atlas_handle) in query.iter_mut() {
+        timer.tick(time.delta_seconds());
+        if timer.finished() {
             let texture_atlas = texture_atlases.get(texture_atlas_handle).unwrap();
             sprite.index = ((sprite.index as usize + 1) % texture_atlas.textures.len()) as u32;
         }
diff --git a/examples/2d/texture_atlas.rs b/examples/2d/texture_atlas.rs
index 4879641926e5d..b02c724e99332 100644
--- a/examples/2d/texture_atlas.rs
+++ b/examples/2d/texture_atlas.rs
@@ -5,70 +5,81 @@ fn main() {
     App::build()
         .init_resource::<RpgSpriteHandles>()
         .add_plugins(DefaultPlugins)
-        .add_startup_system(setup)
-        .add_system(load_atlas)
+        .add_resource(State::new(AppState::Setup))
+        .add_stage_after(stage::UPDATE, STAGE, StateStage::<AppState>::default())
+        .on_state_enter(STAGE, AppState::Setup, load_textures.system())
+        .on_state_update(STAGE, AppState::Setup, check_textures.system())
+        .on_state_enter(STAGE, AppState::Finshed, setup.system())
         .run();
 }
 
+const STAGE: &str = "app_state";
+
+#[derive(Clone)]
+enum AppState {
+    Setup,
+    Finshed,
+}
+
 #[derive(Default)]
-pub struct RpgSpriteHandles {
+struct RpgSpriteHandles {
     handles: Vec<HandleUntyped>,
-    atlas_loaded: bool,
 }
 
-fn setup(mut rpg_sprite_handles: ResMut<RpgSpriteHandles>, asset_server: Res<AssetServer>) {
+fn load_textures(mut rpg_sprite_handles: ResMut<RpgSpriteHandles>, asset_server: Res<AssetServer>) {
     rpg_sprite_handles.handles = asset_server.load_folder("textures/rpg").unwrap();
 }
 
-fn load_atlas(
+fn check_textures(
+    mut state: ResMut<State<AppState>>,
+    rpg_sprite_handles: ResMut<RpgSpriteHandles>,
+    asset_server: Res<AssetServer>,
+) {
+    if let LoadState::Loaded =
+        asset_server.get_group_load_state(rpg_sprite_handles.handles.iter().map(|handle| handle.id))
+    {
+        state.set_next(AppState::Finshed).unwrap();
+    }
+}
+
+fn setup(
     commands: &mut Commands,
-    mut rpg_sprite_handles: ResMut<RpgSpriteHandles>,
+    rpg_sprite_handles: Res<RpgSpriteHandles>,
     asset_server: Res<AssetServer>,
     mut texture_atlases: ResMut<Assets<TextureAtlas>>,
     mut textures: ResMut<Assets<Texture>>,
     mut materials: ResMut<Assets<ColorMaterial>>,
 ) {
-    if rpg_sprite_handles.atlas_loaded {
-        return;
-    }
-
     let mut texture_atlas_builder = TextureAtlasBuilder::default();
-    if let LoadState::Loaded =
-        asset_server.get_group_load_state(rpg_sprite_handles.handles.iter().map(|handle| handle.id))
-    {
-        for handle in rpg_sprite_handles.handles.iter() {
-            let texture = textures.get(handle).unwrap();
-            texture_atlas_builder.add_texture(handle.clone_weak().typed::<Texture>(), &texture);
-        }
+    for handle in rpg_sprite_handles.handles.iter() {
+        let texture = textures.get(handle).unwrap();
+        texture_atlas_builder.add_texture(handle.clone_weak().typed::<Texture>(), texture);
+    }
 
-        let texture_atlas = texture_atlas_builder.finish(&mut textures).unwrap();
-        let texture_atlas_texture = texture_atlas.texture.clone();
-        let vendor_handle =
-            asset_server.get_handle("textures/rpg/chars/vendor/generic-rpg-vendor.png");
-        let vendor_index = texture_atlas.get_texture_index(&vendor_handle).unwrap();
-        let atlas_handle = texture_atlases.add(texture_atlas);
+    let texture_atlas = texture_atlas_builder.finish(&mut textures).unwrap();
+    let texture_atlas_texture = texture_atlas.texture.clone();
+    let vendor_handle = asset_server.get_handle("textures/rpg/chars/vendor/generic-rpg-vendor.png");
+    let vendor_index = texture_atlas.get_texture_index(&vendor_handle).unwrap();
+    let atlas_handle = texture_atlases.add(texture_atlas);
 
-        // set up a scene to display our texture atlas
-        commands
-            .spawn(Camera2dBundle::default())
-            // draw a sprite from the atlas
-            .spawn(SpriteSheetBundle {
-                transform: Transform {
-                    translation: Vec3::new(150.0, 0.0, 0.0),
-                    scale: Vec3::splat(4.0),
-                    ..Default::default()
-                },
-                sprite: TextureAtlasSprite::new(vendor_index as u32),
-                texture_atlas: atlas_handle,
-                ..Default::default()
-            })
-            // draw the atlas itself
-            .spawn(SpriteBundle {
-                material: materials.add(texture_atlas_texture.into()),
-                transform: Transform::from_translation(Vec3::new(-300.0, 0.0, 0.0)),
+    // set up a scene to display our texture atlas
+    commands
+        .spawn(Camera2dBundle::default())
+        // draw a sprite from the atlas
+        .spawn(SpriteSheetBundle {
+            transform: Transform {
+                translation: Vec3::new(150.0, 0.0, 0.0),
+                scale: Vec3::splat(4.0),
                 ..Default::default()
-            });
-
-        rpg_sprite_handles.atlas_loaded = true;
-    }
+            },
+            sprite: TextureAtlasSprite::new(vendor_index as u32),
+            texture_atlas: atlas_handle,
+            ..Default::default()
+        })
+        // draw the atlas itself
+        .spawn(SpriteBundle {
+            material: materials.add(texture_atlas_texture.into()),
+            transform: Transform::from_translation(Vec3::new(-300.0, 0.0, 0.0)),
+            ..Default::default()
+        });
 }
diff --git a/examples/3d/3d_scene.rs b/examples/3d/3d_scene.rs
index 3ea3492f6bfb5..d9dee8b308d87 100644
--- a/examples/3d/3d_scene.rs
+++ b/examples/3d/3d_scene.rs
@@ -4,7 +4,7 @@ fn main() {
     App::build()
         .add_resource(Msaa { samples: 4 })
         .add_plugins(DefaultPlugins)
-        .add_startup_system(setup)
+        .add_startup_system(setup.system())
         .run();
 }
 
diff --git a/examples/3d/load_gltf.rs b/examples/3d/load_gltf.rs
index fb64e4cadeab9..e374970f3038d 100644
--- a/examples/3d/load_gltf.rs
+++ b/examples/3d/load_gltf.rs
@@ -4,7 +4,7 @@ fn main() {
     App::build()
         .add_resource(Msaa { samples: 4 })
         .add_plugins(DefaultPlugins)
-        .add_startup_system(setup)
+        .add_startup_system(setup.system())
         .run();
 }
 
diff --git a/examples/3d/msaa.rs b/examples/3d/msaa.rs
index d6dbea34b8e84..67bf1f45e35e7 100644
--- a/examples/3d/msaa.rs
+++ b/examples/3d/msaa.rs
@@ -7,7 +7,7 @@ fn main() {
     App::build()
         .add_resource(Msaa { samples: 4 })
         .add_plugins(DefaultPlugins)
-        .add_startup_system(setup)
+        .add_startup_system(setup.system())
         .run();
 }
 
diff --git a/examples/3d/parenting.rs b/examples/3d/parenting.rs
index a1125e5762df5..556bd1b30750b 100644
--- a/examples/3d/parenting.rs
+++ b/examples/3d/parenting.rs
@@ -6,8 +6,8 @@ fn main() {
     App::build()
         .add_resource(Msaa { samples: 4 })
         .add_plugins(DefaultPlugins)
-        .add_startup_system(setup)
-        .add_system(rotator_system)
+        .add_startup_system(setup.system())
+        .add_system(rotator_system.system())
         .run();
 }
 
@@ -17,7 +17,7 @@ struct Rotator;
 /// rotates the parent, which will result in the child also rotating
 fn rotator_system(time: Res<Time>, mut query: Query<&mut Transform, With<Rotator>>) {
     for mut transform in query.iter_mut() {
-        transform.rotation *= Quat::from_rotation_x(3.0 * time.delta_seconds);
+        transform.rotation *= Quat::from_rotation_x(3.0 * time.delta_seconds());
     }
 }
 
diff --git a/examples/3d/spawner.rs b/examples/3d/spawner.rs
index 20a7552bc43df..c2a5c7f045619 100644
--- a/examples/3d/spawner.rs
+++ b/examples/3d/spawner.rs
@@ -13,8 +13,8 @@ fn main() {
         .add_plugins(DefaultPlugins)
         .add_plugin(FrameTimeDiagnosticsPlugin::default())
         .add_plugin(PrintDiagnosticsPlugin::default())
-        .add_startup_system(setup)
-        .add_system(move_cubes)
+        .add_startup_system(setup.system())
+        .add_system(move_cubes.system())
         .run();
 }
 
@@ -25,9 +25,9 @@ fn move_cubes(
 ) {
     for (mut transform, material_handle) in query.iter_mut() {
         let material = materials.get_mut(material_handle).unwrap();
-        transform.translation += Vec3::new(1.0, 0.0, 0.0) * time.delta_seconds;
+        transform.translation += Vec3::new(1.0, 0.0, 0.0) * time.delta_seconds();
         material.albedo =
-            Color::BLUE * Vec3::splat((3.0 * time.seconds_since_startup as f32).sin());
+            Color::BLUE * Vec3::splat((3.0 * time.seconds_since_startup() as f32).sin());
     }
 }
 
diff --git a/examples/3d/texture.rs b/examples/3d/texture.rs
index 8d853eace397a..c2822ea891ee3 100644
--- a/examples/3d/texture.rs
+++ b/examples/3d/texture.rs
@@ -4,7 +4,7 @@ use bevy::prelude::*;
 fn main() {
     App::build()
         .add_plugins(DefaultPlugins)
-        .add_startup_system(setup)
+        .add_startup_system(setup.system())
         .run();
 }
 
@@ -58,7 +58,7 @@ fn setup(
                 rotation: Quat::from_rotation_x(-std::f32::consts::PI / 5.0),
                 ..Default::default()
             },
-            draw: Draw {
+            visible: Visible {
                 is_transparent: true,
                 ..Default::default()
             },
@@ -73,7 +73,7 @@ fn setup(
                 rotation: Quat::from_rotation_x(-std::f32::consts::PI / 5.0),
                 ..Default::default()
             },
-            draw: Draw {
+            visible: Visible {
                 is_transparent: true,
                 ..Default::default()
             },
@@ -88,7 +88,7 @@ fn setup(
                 rotation: Quat::from_rotation_x(-std::f32::consts::PI / 5.0),
                 ..Default::default()
             },
-            draw: Draw {
+            visible: Visible {
                 is_transparent: true,
                 ..Default::default()
             },
diff --git a/examples/3d/z_sort_debug.rs b/examples/3d/z_sort_debug.rs
index 73cc3c4ea5ec6..e1feccd9b0d07 100644
--- a/examples/3d/z_sort_debug.rs
+++ b/examples/3d/z_sort_debug.rs
@@ -10,9 +10,9 @@ use bevy::{
 fn main() {
     App::build()
         .add_plugins(DefaultPlugins)
-        .add_startup_system(setup)
-        .add_system(rotator_system)
-        .add_system(camera_order_color_system)
+        .add_startup_system(setup.system())
+        .add_system(rotator_system.system())
+        .add_system(camera_order_color_system.system())
         .run();
 }
 
@@ -21,7 +21,7 @@ struct Rotator;
 /// rotates the parent, which will result in the child also rotating
 fn rotator_system(time: Res<Time>, mut query: Query<&mut Transform, With<Rotator>>) {
     for mut transform in query.iter_mut() {
-        transform.rotation *= Quat::from_rotation_x(3.0 * time.delta_seconds);
+        transform.rotation *= Quat::from_rotation_x(3.0 * time.delta_seconds());
     }
 }
 
diff --git a/examples/README.md b/examples/README.md
index f543c32e952c6..ae229238f9776 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -33,6 +33,7 @@ git checkout v0.3.0
   - [ECS (Entity Component System)](#ecs-entity-component-system)
   - [Games](#games)
   - [Input](#input)
+  - [Reflection](#reflection)
   - [Scene](#scene)
   - [Shaders](#shaders)
   - [Tools](#tools)
@@ -117,7 +118,10 @@ Example | File | Description
 `event` | [`ecs/event.rs`](./ecs/event.rs) | Illustrates event creation, activation, and reception
 `hierarchy` | [`ecs/hierarchy.rs`](./ecs/hierarchy.rs) | Creates a hierarchy of parents and children entities
 `parallel_query` | [`ecs/parallel_query.rs`](./ecs/parallel_query.rs) | Illustrates parallel queries with `ParallelIterator`
+`removal_detection` | [`ecs/removal_detection.rs`](./ecs/removal_detection.rs) | Query for entities that had a specific component removed in a previous stage during the current frame.
 `startup_system` | [`ecs/startup_system.rs`](./ecs/startup_system.rs) | Demonstrates a startup system (one that runs once when the app starts up)
+`system_chaining` | [`ecs/system_chaining.rs`](./ecs/system_chaining.rs) | Chain two systems together, specifying a return type in a system (such as `Result`)
+`timers` | [`ecs/timers.rs`](./ecs/timers.rs) | Illustrates ticking `Timer` resources inside systems and handling their state
 
 ## Games
 
@@ -139,17 +143,26 @@ Example | File | Description
 `touch_input_events` | [`input/touch_input_events.rs`](./input/touch_input_input_events.rs) | Prints out all touch inputs
 `touch_input` | [`input/touch_input.rs`](./input/touch_input.rs) | Displays touch presses, releases, and cancels
 
+## Reflection
+
+Example | File | Description
+--- | --- | ---
+`generic_reflection` | [`reflection/generic_reflection.rs`](reflection/generic_reflection.rs) | Registers concrete instances of generic types that may be used with reflection
+`reflection_types` | [`reflection/reflection_types.rs`](reflection/reflection_types.rs) | Illustrates the various reflection types available
+`reflection` | [`reflection/reflection.rs`](reflection/reflection.rs) | Demonstrates how reflection in Bevy provides a way to dynamically interact with Rust types
+`trait_reflection` | [`reflection/trait_reflection.rs`](reflection/trait_reflection.rs) | Allows reflection with trait objects
+
 ## Scene
 
 Example | File | Description
 --- | --- | ---
-`properties` | [`scene/properties.rs`](./scene/properties.rs) | Demonstrates Properties (similar to reflections in other languages) in Bevy
 `scene` | [`scene/scene.rs`](./scene/scene.rs) | Demonstrates loading from and saving scenes to files
 
 ## Shaders
 
 Example | File | Description
 --- | --- | ---
+`array_texture` | [`shader/array_texture.rs`](./shader/array_texture.rs) | Illustrates how to create a texture for use with a texture2DArray shader uniform variable
 `mesh_custom_attribute` | [`shader/mesh_custom_attribute.rs`](./shader/mesh_custom_attribute.rs) | Illustrates how to add a custom attribute to a mesh and use it in a custom shader
 `shader_custom_material` | [`shader/shader_custom_material.rs`](./shader/shader_custom_material.rs) | Illustrates creating a custom material and a shader that uses it
 `shader_defs` | [`shader/shader_defs.rs`](./shader/shader_defs.rs) | Demonstrates creating a custom material that uses "shaders defs" (a tool to selectively toggle parts of a shader)
diff --git a/examples/android/android.rs b/examples/android/android.rs
index 0fa98018fda59..4970307a620e7 100644
--- a/examples/android/android.rs
+++ b/examples/android/android.rs
@@ -6,7 +6,7 @@ fn main() {
     App::build()
         .add_resource(Msaa { samples: 2 })
         .add_plugins(DefaultPlugins)
-        .add_startup_system(setup)
+        .add_startup_system(setup.system())
         .run();
 }
 
diff --git a/examples/app/custom_loop.rs b/examples/app/custom_loop.rs
index 647f23eaba89b..dd67bd583a515 100644
--- a/examples/app/custom_loop.rs
+++ b/examples/app/custom_loop.rs
@@ -6,8 +6,6 @@ struct Input(String);
 /// This example demonstrates you can create a custom runner (to update an app manually). It reads
 /// lines from stdin and prints them from within the ecs.
 fn my_runner(mut app: App) {
-    app.initialize();
-
     println!("Type stuff into the console");
     for line in io::stdin().lock().lines() {
         {
@@ -26,6 +24,6 @@ fn main() {
     App::build()
         .add_resource(Input(String::new()))
         .set_runner(my_runner)
-        .add_system(print_system)
+        .add_system(print_system.system())
         .run();
 }
diff --git a/examples/app/headless.rs b/examples/app/headless.rs
index 181d1b0082efa..b90de71b3c16e 100644
--- a/examples/app/headless.rs
+++ b/examples/app/headless.rs
@@ -13,7 +13,7 @@ fn main() {
     App::build()
         .add_resource(ScheduleRunnerSettings::run_once())
         .add_plugins(MinimalPlugins)
-        .add_system(hello_world_system)
+        .add_system(hello_world_system.system())
         .run();
 
     // this app loops forever at 60 fps
@@ -22,7 +22,7 @@ fn main() {
             1.0 / 60.0,
         )))
         .add_plugins(MinimalPlugins)
-        .add_system(counter)
+        .add_system(counter.system())
         .run();
 }
 
diff --git a/examples/app/logs.rs b/examples/app/logs.rs
index 3046a51fc2738..532e6932ebf46 100644
--- a/examples/app/logs.rs
+++ b/examples/app/logs.rs
@@ -9,7 +9,7 @@ fn main() {
         //     filter: "wgpu=warn,bevy_ecs=info".to_string(),
         // })
         .add_plugins(DefaultPlugins)
-        .add_system(log_system)
+        .add_system(log_system.system())
         .run();
 }
 
diff --git a/examples/app/plugin.rs b/examples/app/plugin.rs
index 2bc54550ca6bc..dee94567d5c77 100644
--- a/examples/app/plugin.rs
+++ b/examples/app/plugin.rs
@@ -28,7 +28,8 @@ impl Plugin for PrintMessagePlugin {
             message: self.message.clone(),
             timer: Timer::new(self.wait_duration, true),
         };
-        app.add_resource(state).add_system(print_message_system);
+        app.add_resource(state)
+            .add_system(print_message_system.system());
     }
 }
 
@@ -38,7 +39,7 @@ struct PrintMessageState {
 }
 
 fn print_message_system(mut state: ResMut<PrintMessageState>, time: Res<Time>) {
-    if state.timer.tick(time.delta_seconds).finished {
+    if state.timer.tick(time.delta_seconds()).finished() {
         println!("{}", state.message);
     }
 }
diff --git a/examples/app/plugin_group.rs b/examples/app/plugin_group.rs
index fbe533ea154e9..81cd0b2ef2201 100644
--- a/examples/app/plugin_group.rs
+++ b/examples/app/plugin_group.rs
@@ -29,7 +29,7 @@ pub struct PrintHelloPlugin;
 
 impl Plugin for PrintHelloPlugin {
     fn build(&self, app: &mut AppBuilder) {
-        app.add_system(print_hello_system);
+        app.add_system(print_hello_system.system());
     }
 }
 
@@ -41,7 +41,7 @@ pub struct PrintWorldPlugin;
 
 impl Plugin for PrintWorldPlugin {
     fn build(&self, app: &mut AppBuilder) {
-        app.add_system(print_world_system);
+        app.add_system(print_world_system.system());
     }
 }
 
diff --git a/examples/app/return_after_run.rs b/examples/app/return_after_run.rs
index ab951341a62dc..f35c29ba723f7 100644
--- a/examples/app/return_after_run.rs
+++ b/examples/app/return_after_run.rs
@@ -8,6 +8,7 @@ fn main() {
         })
         .add_resource(ClearColor(Color::rgb(0.2, 0.2, 0.8)))
         .add_plugins(DefaultPlugins)
+        .add_system(system1.system())
         .run();
     println!("Running another App.");
     App::build()
@@ -15,7 +16,18 @@ fn main() {
             return_from_run: true,
         })
         .add_resource(ClearColor(Color::rgb(0.2, 0.8, 0.2)))
-        .add_plugins(DefaultPlugins)
+        .add_plugins_with(DefaultPlugins, |group| {
+            group.disable::<bevy::log::LogPlugin>()
+        })
+        .add_system(system2.system())
         .run();
     println!("Done.");
 }
+
+fn system1() {
+    info!("logging from first app");
+}
+
+fn system2() {
+    info!("logging from second app");
+}
diff --git a/examples/asset/asset_loading.rs b/examples/asset/asset_loading.rs
index 5ad62e0af404a..793f4685046e0 100644
--- a/examples/asset/asset_loading.rs
+++ b/examples/asset/asset_loading.rs
@@ -5,7 +5,7 @@ fn main() {
     App::build()
         .add_resource(Msaa { samples: 4 })
         .add_plugins(DefaultPlugins)
-        .add_startup_system(setup)
+        .add_startup_system(setup.system())
         .run();
 }
 
diff --git a/examples/asset/custom_asset.rs b/examples/asset/custom_asset.rs
index c28c5f6bc8016..4169b364cce67 100644
--- a/examples/asset/custom_asset.rs
+++ b/examples/asset/custom_asset.rs
@@ -1,7 +1,7 @@
 use bevy::{
     asset::{AssetLoader, LoadContext, LoadedAsset},
     prelude::*,
-    type_registry::TypeUuid,
+    reflect::TypeUuid,
     utils::BoxedFuture,
 };
 use serde::Deserialize;
@@ -39,8 +39,8 @@ fn main() {
         .init_resource::<State>()
         .add_asset::<CustomAsset>()
         .init_asset_loader::<CustomAssetLoader>()
-        .add_startup_system(setup)
-        .add_system(print_on_load)
+        .add_startup_system(setup.system())
+        .add_system(print_on_load.system())
         .run();
 }
 
diff --git a/examples/asset/custom_asset_io.rs b/examples/asset/custom_asset_io.rs
new file mode 100644
index 0000000000000..7e986644e4be4
--- /dev/null
+++ b/examples/asset/custom_asset_io.rs
@@ -0,0 +1,104 @@
+use bevy::{
+    asset::{AssetIo, AssetIoError},
+    prelude::*,
+    utils::BoxedFuture,
+};
+use std::path::{Path, PathBuf};
+
+/// A custom asset io implementation that simply defers to the platform default
+/// implementation.
+///
+/// This can be used as a starting point for developing a useful implementation
+/// that can defer to the default when needed.
+struct CustomAssetIo(Box<dyn AssetIo>);
+
+impl AssetIo for CustomAssetIo {
+    fn load_path<'a>(&'a self, path: &'a Path) -> BoxedFuture<'a, Result<Vec<u8>, AssetIoError>> {
+        println!("load_path({:?})", path);
+        self.0.load_path(path)
+    }
+
+    fn read_directory(
+        &self,
+        path: &Path,
+    ) -> Result<Box<dyn Iterator<Item = PathBuf>>, AssetIoError> {
+        println!("read_directory({:?})", path);
+        self.0.read_directory(path)
+    }
+
+    fn is_directory(&self, path: &Path) -> bool {
+        println!("is_directory({:?})", path);
+        self.0.is_directory(path)
+    }
+
+    fn watch_path_for_changes(&self, path: &Path) -> Result<(), AssetIoError> {
+        println!("watch_path_for_changes({:?})", path);
+        self.0.watch_path_for_changes(path)
+    }
+
+    fn watch_for_changes(&self) -> Result<(), AssetIoError> {
+        println!("watch_for_changes()");
+        self.0.watch_for_changes()
+    }
+}
+
+/// A plugin used to execute the override of the asset io
+struct CustomAssetIoPlugin;
+
+impl Plugin for CustomAssetIoPlugin {
+    fn build(&self, app: &mut AppBuilder) {
+        // must get a hold of the task pool in order to create the asset server
+
+        let task_pool = app
+            .resources()
+            .get::<bevy::tasks::IoTaskPool>()
+            .expect("`IoTaskPool` resource not found.")
+            .0
+            .clone();
+
+        let asset_io = {
+            // the platform default asset io requires a reference to the app
+            // builder to find its configuration
+
+            let default_io = bevy::asset::create_platform_default_asset_io(app);
+
+            // create the custom asset io instance
+
+            CustomAssetIo(default_io)
+        };
+
+        // the asset server is constructed and added the resource manager
+
+        app.add_resource(AssetServer::new(asset_io, task_pool));
+    }
+}
+
+fn main() {
+    App::build()
+        .add_plugins_with(DefaultPlugins, |group| {
+            // the custom asset io plugin must be inserted in-between the
+            // `CorePlugin' and `AssetPlugin`. It needs to be after the
+            // CorePlugin, so that the IO task pool has already been constructed.
+            // And it must be before the `AssetPlugin` so that the asset plugin
+            // doesn't create another instance of an assert server. In general,
+            // the AssetPlugin should still run so that other aspects of the
+            // asset system are initialized correctly.
+            group.add_before::<bevy::asset::AssetPlugin, _>(CustomAssetIoPlugin)
+        })
+        .add_startup_system(setup.system())
+        .run();
+}
+
+fn setup(
+    commands: &mut Commands,
+    asset_server: Res<AssetServer>,
+    mut materials: ResMut<Assets<ColorMaterial>>,
+) {
+    let texture_handle = asset_server.load("branding/icon.png");
+    commands
+        .spawn(Camera2dBundle::default())
+        .spawn(SpriteBundle {
+            material: materials.add(texture_handle.into()),
+            ..Default::default()
+        });
+}
diff --git a/examples/asset/hot_asset_reloading.rs b/examples/asset/hot_asset_reloading.rs
index edcaa35dc56d1..cf542a48e9355 100644
--- a/examples/asset/hot_asset_reloading.rs
+++ b/examples/asset/hot_asset_reloading.rs
@@ -6,7 +6,7 @@ use bevy::prelude::*;
 fn main() {
     App::build()
         .add_plugins(DefaultPlugins)
-        .add_startup_system(setup)
+        .add_startup_system(setup.system())
         .run();
 }
 
diff --git a/examples/audio/audio.rs b/examples/audio/audio.rs
index ca72402afeea2..a8296ad95305b 100644
--- a/examples/audio/audio.rs
+++ b/examples/audio/audio.rs
@@ -4,7 +4,7 @@ use bevy::prelude::*;
 fn main() {
     App::build()
         .add_plugins(DefaultPlugins)
-        .add_startup_system(setup)
+        .add_startup_system(setup.system())
         .run();
 }
 
diff --git a/examples/diagnostics/custom_diagnostic.rs b/examples/diagnostics/custom_diagnostic.rs
index 58f22137fb7f1..4b2e832467a44 100644
--- a/examples/diagnostics/custom_diagnostic.rs
+++ b/examples/diagnostics/custom_diagnostic.rs
@@ -9,8 +9,8 @@ fn main() {
         .add_plugins(DefaultPlugins)
         // The "print diagnostics" plugin is optional. It just visualizes our diagnostics in the console
         .add_plugin(PrintDiagnosticsPlugin::default())
-        .add_startup_system(setup_diagnostic_system)
-        .add_system(my_system)
+        .add_startup_system(setup_diagnostic_system.system())
+        .add_system(my_system.system())
         .run();
 }
 
diff --git a/examples/ecs/ecs_guide.rs b/examples/ecs/ecs_guide.rs
index 7e67abab5b962..8f7159d3bd1e8 100644
--- a/examples/ecs/ecs_guide.rs
+++ b/examples/ecs/ecs_guide.rs
@@ -1,5 +1,6 @@
 use bevy::{
     app::{AppExit, ScheduleRunnerPlugin, ScheduleRunnerSettings},
+    ecs::SystemStage,
     prelude::*,
     utils::Duration,
 };
@@ -256,9 +257,9 @@ fn main() {
         .init_resource::<GameState>()
         // Startup systems run exactly once BEFORE all other systems. These are generally used for
         // app initialization code (ex: adding entities and resources)
-        .add_startup_system(startup_system)
+        .add_startup_system(startup_system.system())
         // my_system calls converts normal rust functions into ECS systems:
-        .add_system(print_message_system)
+        .add_system(print_message_system.system())
         //
         // SYSTEM EXECUTION ORDER
         //
@@ -277,17 +278,17 @@ fn main() {
         // and the next stage won't start until all systems in the current stage have finished.
         // add_system(system) adds systems to the UPDATE stage by default
         // However we can manually specify the stage if we want to. The following is equivalent to add_system(score_system)
-        .add_system_to_stage(stage::UPDATE, score_system)
+        .add_system_to_stage(stage::UPDATE, score_system.system())
         // We can also create new stages. Here is what our games stage order will look like:
         // "before_round": new_player_system, new_round_system
         // "update": print_message_system, score_system
         // "after_round": score_check_system, game_over_system
-        .add_stage_before(stage::UPDATE, "before_round")
-        .add_stage_after(stage::UPDATE, "after_round")
-        .add_system_to_stage("before_round", new_round_system)
-        .add_system_to_stage("before_round", new_player_system)
-        .add_system_to_stage("after_round", score_check_system)
-        .add_system_to_stage("after_round", game_over_system)
+        .add_stage_before(stage::UPDATE, "before_round", SystemStage::parallel())
+        .add_stage_after(stage::UPDATE, "after_round", SystemStage::parallel())
+        .add_system_to_stage("before_round", new_round_system.system())
+        .add_system_to_stage("before_round", new_player_system.system())
+        .add_system_to_stage("after_round", score_check_system.system())
+        .add_system_to_stage("after_round", game_over_system.system())
         // score_check_system will run before game_over_system because score_check_system modifies GameState and game_over_system
         // reads GameState. This works, but it's a bit confusing. In practice, it would be clearer to create a new stage that runs
         // before "after_round"
diff --git a/examples/ecs/event.rs b/examples/ecs/event.rs
index eb02927c064d6..f0e14a4c55253 100644
--- a/examples/ecs/event.rs
+++ b/examples/ecs/event.rs
@@ -7,8 +7,8 @@ fn main() {
         .add_plugins(DefaultPlugins)
         .add_event::<MyEvent>()
         .init_resource::<EventTriggerState>()
-        .add_system(event_trigger_system)
-        .add_system(event_listener_system)
+        .add_system(event_trigger_system.system())
+        .add_system(event_listener_system.system())
         .run();
 }
 
@@ -34,7 +34,7 @@ fn event_trigger_system(
     mut state: ResMut<EventTriggerState>,
     mut my_events: ResMut<Events<MyEvent>>,
 ) {
-    if state.event_timer.tick(time.delta_seconds).finished {
+    if state.event_timer.tick(time.delta_seconds()).finished() {
         my_events.send(MyEvent {
             message: "MyEvent just happened!".to_string(),
         });
diff --git a/examples/ecs/fixed_timestep.rs b/examples/ecs/fixed_timestep.rs
new file mode 100644
index 0000000000000..cd97079d0d790
--- /dev/null
+++ b/examples/ecs/fixed_timestep.rs
@@ -0,0 +1,46 @@
+use bevy::{
+    core::{FixedTimestep, FixedTimesteps},
+    prelude::*,
+};
+
+const LABEL: &str = "my_fixed_timestep";
+
+fn main() {
+    App::build()
+        .add_plugins(DefaultPlugins)
+        // this system will run once every update (it should match your screen's refresh rate)
+        .add_system(update.system())
+        // add a new stage that runs every two seconds
+        .add_stage_after(
+            stage::UPDATE,
+            "fixed_update",
+            SystemStage::parallel()
+                .with_run_criteria(
+                    FixedTimestep::step(2.0)
+                        // labels are optional. they provide a way to access the current FixedTimestep state from within a system
+                        .with_label(LABEL),
+                )
+                .with_system(fixed_update.system()),
+        )
+        .run();
+}
+
+fn update(mut last_time: Local<f64>, time: Res<Time>) {
+    println!("update: {}", time.seconds_since_startup() - *last_time);
+    *last_time = time.seconds_since_startup();
+}
+
+fn fixed_update(mut last_time: Local<f64>, time: Res<Time>, fixed_timesteps: Res<FixedTimesteps>) {
+    println!(
+        "fixed_update: {}",
+        time.seconds_since_startup() - *last_time,
+    );
+
+    let fixed_timestep = fixed_timesteps.get(LABEL).unwrap();
+    println!(
+        "  overstep_percentage: {}",
+        fixed_timestep.overstep_percentage()
+    );
+
+    *last_time = time.seconds_since_startup();
+}
diff --git a/examples/ecs/hierarchy.rs b/examples/ecs/hierarchy.rs
index 9dbbccf19c07c..5d0f49a03388a 100644
--- a/examples/ecs/hierarchy.rs
+++ b/examples/ecs/hierarchy.rs
@@ -3,8 +3,8 @@ use bevy::prelude::*;
 fn main() {
     App::build()
         .add_plugins(DefaultPlugins)
-        .add_startup_system(setup)
-        .add_system(rotate)
+        .add_startup_system(setup.system())
+        .add_system(rotate.system())
         .run();
 }
 
@@ -91,33 +91,30 @@ fn setup(
 fn rotate(
     commands: &mut Commands,
     time: Res<Time>,
-    mut parents_query: Query<(Entity, &mut Children), With<Sprite>>,
+    mut parents_query: Query<(Entity, &Children), With<Sprite>>,
     mut transform_query: Query<&mut Transform, With<Sprite>>,
 ) {
     let angle = std::f32::consts::PI / 2.0;
-    for (parent, mut children) in parents_query.iter_mut() {
+    for (parent, children) in parents_query.iter_mut() {
         if let Ok(mut transform) = transform_query.get_mut(parent) {
-            transform.rotate(Quat::from_rotation_z(-angle * time.delta_seconds));
+            transform.rotate(Quat::from_rotation_z(-angle * time.delta_seconds()));
         }
 
         // To iterate through the entities children, just treat the Children component as a Vec
         // Alternatively, you could query entities that have a Parent component
         for child in children.iter() {
             if let Ok(mut transform) = transform_query.get_mut(*child) {
-                transform.rotate(Quat::from_rotation_z(angle * 2.0 * time.delta_seconds));
+                transform.rotate(Quat::from_rotation_z(angle * 2.0 * time.delta_seconds()));
             }
         }
 
         // To demonstrate removing children, we'll start to remove the children after a couple of seconds
-        if time.seconds_since_startup >= 2.0 && children.len() == 3 {
-            // Using .despawn() on an entity does not remove it from its parent's list of children!
-            // It must be done manually if using .despawn()
-            // NOTE: This is a bug. Eventually Bevy will update the children list automatically
-            let child = children.pop().unwrap();
+        if time.seconds_since_startup() >= 2.0 && children.len() == 3 {
+            let child = children.last().copied().unwrap();
             commands.despawn(child);
         }
 
-        if time.seconds_since_startup >= 4.0 {
+        if time.seconds_since_startup() >= 4.0 {
             // This will remove the entity from its parent's list of children, as well as despawn
             // any children the entity has.
             commands.despawn_recursive(parent);
diff --git a/examples/ecs/parallel_query.rs b/examples/ecs/parallel_query.rs
index 3beb470d42887..b590a2c0460a8 100644
--- a/examples/ecs/parallel_query.rs
+++ b/examples/ecs/parallel_query.rs
@@ -47,13 +47,13 @@ fn bounce_system(
     windows: Res<Windows>,
     mut sprites: Query<(&Transform, &mut Velocity)>,
 ) {
-    let window = windows.get_primary().expect("No primary window");
+    let window = windows.get_primary().expect("No primary window.");
     let width = window.width();
     let height = window.height();
-    let left = width as f32 / -2.0;
-    let right = width as f32 / 2.0;
-    let bottom = height as f32 / -2.0;
-    let top = height as f32 / 2.0;
+    let left = width / -2.0;
+    let right = width / 2.0;
+    let bottom = height / -2.0;
+    let top = height / 2.0;
     sprites
         // Batch size of 32 is chosen to limit the overhead of
         // ParallelIterator, since negating a vector is very inexpensive.
@@ -74,8 +74,8 @@ fn bounce_system(
 fn main() {
     App::build()
         .add_plugins(DefaultPlugins)
-        .add_startup_system(spawn_system)
-        .add_system(move_system)
-        .add_system(bounce_system)
+        .add_startup_system(spawn_system.system())
+        .add_system(move_system.system())
+        .add_system(bounce_system.system())
         .run();
 }
diff --git a/examples/ecs/removal_detection.rs b/examples/ecs/removal_detection.rs
new file mode 100644
index 0000000000000..6709f940477e3
--- /dev/null
+++ b/examples/ecs/removal_detection.rs
@@ -0,0 +1,74 @@
+// This example shows how you can know when a `Component` has been removed, so you can react to it.
+
+use bevy::prelude::*;
+
+fn main() {
+    // Information regarding removed `Component`s is discarded at the end of each frame, so you need
+    // to react to the removal before the frame is over.
+    //
+    // Also, `Components` are removed via a `Command`. `Command`s are applied after a stage has
+    // finished executing. So you need to react to the removal at some stage after the
+    // `Component` is removed.
+    //
+    // With these constraints in mind we make sure to place the system that removes a `Component` on
+    // the `stage::UPDATE` stage, and the system that reacts on the removal on the
+    // `stage::POST_UPDATE` stage.
+    App::build()
+        .add_plugins(DefaultPlugins)
+        .add_startup_system(setup.system())
+        .add_system_to_stage(stage::UPDATE, remove_component.system())
+        .add_system_to_stage(stage::POST_UPDATE, react_on_removal.system())
+        .run();
+}
+
+// This `Struct` is just used for convenience in this example. This is the `Component` we'll be
+// giving to the `Entity` so we have a `Component` to remove in `remove_component()`.
+struct MyComponent;
+
+fn setup(
+    commands: &mut Commands,
+    asset_server: Res<AssetServer>,
+    mut materials: ResMut<Assets<ColorMaterial>>,
+) {
+    let texture = asset_server.load("branding/icon.png");
+
+    commands
+        .spawn(Camera2dBundle::default())
+        .spawn(SpriteBundle {
+            material: materials.add(texture.into()),
+            ..Default::default()
+        })
+        .with(MyComponent); // Add the `Component`.
+}
+
+fn remove_component(
+    time: Res<Time>,
+    commands: &mut 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);
+        }
+    }
+}
+
+fn react_on_removal(
+    mut materials: ResMut<Assets<ColorMaterial>>,
+    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
+    // `Component` `T` (in this case `MyComponent`) removed at some point earlier during the frame.
+    for entity in query.removed::<MyComponent>() {
+        // 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 {
+            materials.get_mut(material).unwrap().color.set_r(0.0);
+        }
+    }
+}
diff --git a/examples/ecs/startup_system.rs b/examples/ecs/startup_system.rs
index 682eb7a7cfc40..395d69322b12d 100644
--- a/examples/ecs/startup_system.rs
+++ b/examples/ecs/startup_system.rs
@@ -2,8 +2,8 @@ use bevy::prelude::*;
 
 fn main() {
     App::build()
-        .add_startup_system(startup_system)
-        .add_system(normal_system)
+        .add_startup_system(startup_system.system())
+        .add_system(normal_system.system())
         .run();
 }
 
diff --git a/examples/ecs/state.rs b/examples/ecs/state.rs
new file mode 100644
index 0000000000000..5d7c31d779eb0
--- /dev/null
+++ b/examples/ecs/state.rs
@@ -0,0 +1,169 @@
+use bevy::prelude::*;
+
+/// This example illustrates how to use States to control transitioning from a Menu state to an InGame state.
+fn main() {
+    App::build()
+        .add_plugins(DefaultPlugins)
+        .init_resource::<ButtonMaterials>()
+        .add_resource(State::new(AppState::Menu))
+        .add_stage_after(stage::UPDATE, STAGE, StateStage::<AppState>::default())
+        .on_state_enter(STAGE, AppState::Menu, setup_menu.system())
+        .on_state_update(STAGE, AppState::Menu, menu.system())
+        .on_state_exit(STAGE, AppState::Menu, cleanup_menu.system())
+        .on_state_enter(STAGE, AppState::InGame, setup_game.system())
+        .on_state_update(STAGE, AppState::InGame, movement.system())
+        .on_state_update(STAGE, AppState::InGame, change_color.system())
+        .run();
+}
+
+const STAGE: &str = "app_state";
+
+#[derive(Clone)]
+enum AppState {
+    Menu,
+    InGame,
+}
+
+struct MenuData {
+    button_entity: Entity,
+}
+
+fn setup_menu(
+    commands: &mut Commands,
+    asset_server: Res<AssetServer>,
+    button_materials: Res<ButtonMaterials>,
+) {
+    commands
+        // ui camera
+        .spawn(CameraUiBundle::default())
+        .spawn(ButtonBundle {
+            style: Style {
+                size: Size::new(Val::Px(150.0), Val::Px(65.0)),
+                // center button
+                margin: Rect::all(Val::Auto),
+                // horizontally center child text
+                justify_content: JustifyContent::Center,
+                // vertically center child text
+                align_items: AlignItems::Center,
+                ..Default::default()
+            },
+            material: button_materials.normal.clone(),
+            ..Default::default()
+        })
+        .with_children(|parent| {
+            parent.spawn(TextBundle {
+                text: Text {
+                    value: "Play".to_string(),
+                    font: asset_server.load("fonts/FiraSans-Bold.ttf"),
+                    style: TextStyle {
+                        font_size: 40.0,
+                        color: Color::rgb(0.9, 0.9, 0.9),
+                        ..Default::default()
+                    },
+                },
+                ..Default::default()
+            });
+        });
+    commands.insert_resource(MenuData {
+        button_entity: commands.current_entity().unwrap(),
+    });
+}
+
+fn menu(
+    mut state: ResMut<State<AppState>>,
+    button_materials: Res<ButtonMaterials>,
+    mut interaction_query: Query<
+        (&Interaction, &mut Handle<ColorMaterial>),
+        (Mutated<Interaction>, With<Button>),
+    >,
+) {
+    for (interaction, mut material) in interaction_query.iter_mut() {
+        match *interaction {
+            Interaction::Clicked => {
+                *material = button_materials.pressed.clone();
+                state.set_next(AppState::InGame).unwrap();
+            }
+            Interaction::Hovered => {
+                *material = button_materials.hovered.clone();
+            }
+            Interaction::None => {
+                *material = button_materials.normal.clone();
+            }
+        }
+    }
+}
+
+fn cleanup_menu(commands: &mut Commands, menu_data: Res<MenuData>) {
+    commands.despawn_recursive(menu_data.button_entity);
+}
+
+fn setup_game(
+    commands: &mut Commands,
+    asset_server: Res<AssetServer>,
+    mut materials: ResMut<Assets<ColorMaterial>>,
+) {
+    let texture_handle = asset_server.load("branding/icon.png");
+    commands
+        .spawn(Camera2dBundle::default())
+        .spawn(SpriteBundle {
+            material: materials.add(texture_handle.into()),
+            ..Default::default()
+        });
+}
+
+const SPEED: f32 = 100.0;
+fn movement(
+    time: Res<Time>,
+    input: Res<Input<KeyCode>>,
+    mut query: Query<&mut Transform, With<Sprite>>,
+) {
+    for mut transform in query.iter_mut() {
+        let mut direction = Vec3::default();
+        if input.pressed(KeyCode::Left) {
+            direction.x += 1.0;
+        }
+        if input.pressed(KeyCode::Right) {
+            direction.x -= 1.0;
+        }
+        if input.pressed(KeyCode::Up) {
+            direction.y += 1.0;
+        }
+        if input.pressed(KeyCode::Down) {
+            direction.y -= 1.0;
+        }
+
+        if direction != Vec3::default() {
+            transform.translation += direction.normalize() * SPEED * time.delta_seconds();
+        }
+    }
+}
+
+fn change_color(
+    time: Res<Time>,
+    mut assets: ResMut<Assets<ColorMaterial>>,
+    query: Query<&Handle<ColorMaterial>, With<Sprite>>,
+) {
+    for handle in query.iter() {
+        let material = assets.get_mut(handle).unwrap();
+        material
+            .color
+            .set_b((time.seconds_since_startup() * 5.0).sin() as f32 + 2.0);
+    }
+}
+
+struct ButtonMaterials {
+    normal: Handle<ColorMaterial>,
+    hovered: Handle<ColorMaterial>,
+    pressed: Handle<ColorMaterial>,
+}
+
+impl FromResources for ButtonMaterials {
+    fn from_resources(resources: &Resources) -> Self {
+        let mut materials = resources.get_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()),
+            pressed: materials.add(Color::rgb(0.35, 0.75, 0.35).into()),
+        }
+    }
+}
diff --git a/examples/ecs/system_chaining.rs b/examples/ecs/system_chaining.rs
index b68229e2e35b8..4a21dec20f308 100644
--- a/examples/ecs/system_chaining.rs
+++ b/examples/ecs/system_chaining.rs
@@ -4,7 +4,7 @@ use bevy::prelude::*;
 fn main() {
     App::build()
         .add_resource(Message("42".to_string()))
-        .add_system(parse_message_system.chain(handler_system))
+        .add_system(parse_message_system.system().chain(handler_system.system()))
         .run();
 }
 
diff --git a/examples/ecs/timers.rs b/examples/ecs/timers.rs
new file mode 100644
index 0000000000000..0a2bee125a241
--- /dev/null
+++ b/examples/ecs/timers.rs
@@ -0,0 +1,73 @@
+use bevy::{log::info, prelude::*};
+
+fn main() {
+    App::build()
+        .add_plugins(DefaultPlugins)
+        .add_resource(Countdown::default())
+        .add_startup_system(setup_system.system())
+        .add_system(countdown_system.system())
+        .add_system(timer_system.system())
+        .run();
+}
+
+pub struct Countdown {
+    pub percent_trigger: Timer,
+    pub main_timer: Timer,
+}
+
+impl Countdown {
+    pub fn new() -> Self {
+        Self {
+            percent_trigger: Timer::from_seconds(4.0, true),
+            main_timer: Timer::from_seconds(20.0, false),
+        }
+    }
+}
+
+impl Default for Countdown {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+fn setup_system(commands: &mut Commands) {
+    // Add an entity to the world with a timer
+    commands.spawn((Timer::from_seconds(5.0, false),));
+}
+
+/// This system ticks all the `Timer` components on entities within the scene
+/// using bevy's `Time` resource to get the delta between each update.
+fn timer_system(time: Res<Time>, mut query: Query<&mut Timer>) {
+    for mut timer in query.iter_mut() {
+        if timer.tick(time.delta_seconds()).just_finished() {
+            info!("Entity timer just finished")
+        }
+    }
+}
+
+/// This system controls ticking the timer within the countdown resource and
+/// handling its state.
+fn countdown_system(time: Res<Time>, mut countdown: ResMut<Countdown>) {
+    countdown.main_timer.tick(time.delta_seconds());
+
+    // The API encourages this kind of timer state checking (if you're only checking for one value)
+    // Additionally, `finished()` would accomplish the same thing as `just_finished` due to the timer
+    // being repeating, however this makes more sense visually.
+    if countdown
+        .percent_trigger
+        .tick(time.delta_seconds())
+        .just_finished()
+    {
+        if !countdown.main_timer.finished() {
+            // Print the percent complete the main timer is.
+            info!(
+                "Timer is {:0.0}% complete!",
+                countdown.main_timer.percent() * 100.0
+            );
+        } else {
+            // The timer has finished so we pause the percent output timer
+            countdown.percent_trigger.pause();
+            info!("Paused percent trigger timer")
+        }
+    }
+}
diff --git a/examples/game/breakout.rs b/examples/game/breakout.rs
index 6fb27c6e11fef..29e4532e3c81a 100644
--- a/examples/game/breakout.rs
+++ b/examples/game/breakout.rs
@@ -10,11 +10,11 @@ fn main() {
         .add_plugins(DefaultPlugins)
         .add_resource(Scoreboard { score: 0 })
         .add_resource(ClearColor(Color::rgb(0.9, 0.9, 0.9)))
-        .add_startup_system(setup)
-        .add_system(paddle_movement_system)
-        .add_system(ball_collision_system)
-        .add_system(ball_movement_system)
-        .add_system(scoreboard_system)
+        .add_startup_system(setup.system())
+        .add_system(paddle_movement_system.system())
+        .add_system(ball_collision_system.system())
+        .add_system(ball_movement_system.system())
+        .add_system(scoreboard_system.system())
         .run();
 }
 
@@ -45,7 +45,7 @@ fn setup(
     commands
         // cameras
         .spawn(Camera2dBundle::default())
-        .spawn(UiCameraBundle::default())
+        .spawn(CameraUiBundle::default())
         // paddle
         .spawn(SpriteBundle {
             material: materials.add(Color::rgb(0.5, 0.5, 1.0).into()),
@@ -174,7 +174,7 @@ fn paddle_movement_system(
 
         let translation = &mut transform.translation;
         // move the paddle horizontally
-        translation.x += time.delta_seconds * direction * paddle.speed;
+        translation.x += time.delta_seconds() * direction * paddle.speed;
         // bound the paddle within the walls
         translation.x = translation.x.min(380.0).max(-380.0);
     }
@@ -182,7 +182,7 @@ fn paddle_movement_system(
 
 fn ball_movement_system(time: Res<Time>, mut ball_query: Query<(&Ball, &mut Transform)>) {
     // clamp the timestep to stop the ball from escaping when the game starts
-    let delta_seconds = f32::min(0.2, time.delta_seconds);
+    let delta_seconds = f32::min(0.2, time.delta_seconds());
 
     for (ball, mut transform) in ball_query.iter_mut() {
         transform.translation += ball.velocity * delta_seconds;
diff --git a/examples/hello_world.rs b/examples/hello_world.rs
index 6cdfa3e0489e8..5078ebb2e22d1 100644
--- a/examples/hello_world.rs
+++ b/examples/hello_world.rs
@@ -1,7 +1,7 @@
 use bevy::prelude::*;
 
 fn main() {
-    App::build().add_system(hello_world_system).run();
+    App::build().add_system(hello_world_system.system()).run();
 }
 
 fn hello_world_system() {
diff --git a/examples/input/char_input_events.rs b/examples/input/char_input_events.rs
index 73c163e17b17b..207fe1c91caee 100644
--- a/examples/input/char_input_events.rs
+++ b/examples/input/char_input_events.rs
@@ -3,7 +3,7 @@ use bevy::{prelude::*, window::ReceivedCharacter};
 fn main() {
     App::build()
         .add_plugins(DefaultPlugins)
-        .add_system(print_char_event_system)
+        .add_system(print_char_event_system.system())
         .run();
 }
 
diff --git a/examples/input/gamepad_input.rs b/examples/input/gamepad_input.rs
index dd8630c51d840..dccf64b2def26 100644
--- a/examples/input/gamepad_input.rs
+++ b/examples/input/gamepad_input.rs
@@ -8,8 +8,8 @@ fn main() {
     App::build()
         .add_plugins(DefaultPlugins)
         .init_resource::<GamepadLobby>()
-        .add_system_to_stage(stage::PRE_UPDATE, connection_system)
-        .add_system(gamepad_system)
+        .add_system_to_stage(stage::PRE_UPDATE, connection_system.system())
+        .add_system(gamepad_system.system())
         .run();
 }
 
diff --git a/examples/input/gamepad_input_events.rs b/examples/input/gamepad_input_events.rs
index ce6cb8012b43b..3f4db960d718f 100644
--- a/examples/input/gamepad_input_events.rs
+++ b/examples/input/gamepad_input_events.rs
@@ -6,7 +6,7 @@ use bevy::{
 fn main() {
     App::build()
         .add_plugins(DefaultPlugins)
-        .add_system(gamepad_events)
+        .add_system(gamepad_events.system())
         .run();
 }
 
diff --git a/examples/input/keyboard_input.rs b/examples/input/keyboard_input.rs
index 86828ae652b4d..65a5072635624 100644
--- a/examples/input/keyboard_input.rs
+++ b/examples/input/keyboard_input.rs
@@ -6,7 +6,7 @@ use bevy::{
 fn main() {
     App::build()
         .add_plugins(DefaultPlugins)
-        .add_system(keyboard_input_system)
+        .add_system(keyboard_input_system.system())
         .run();
 }
 
diff --git a/examples/input/keyboard_input_events.rs b/examples/input/keyboard_input_events.rs
index 0c8f172933490..fc0fe43c7090c 100644
--- a/examples/input/keyboard_input_events.rs
+++ b/examples/input/keyboard_input_events.rs
@@ -3,7 +3,7 @@ use bevy::{input::keyboard::KeyboardInput, prelude::*};
 fn main() {
     App::build()
         .add_plugins(DefaultPlugins)
-        .add_system(print_keyboard_event_system)
+        .add_system(print_keyboard_event_system.system())
         .run();
 }
 
diff --git a/examples/input/mouse_input.rs b/examples/input/mouse_input.rs
index 6c19d05d24307..61fcac5d75c3f 100644
--- a/examples/input/mouse_input.rs
+++ b/examples/input/mouse_input.rs
@@ -3,7 +3,7 @@ use bevy::prelude::*;
 fn main() {
     App::build()
         .add_plugins(DefaultPlugins)
-        .add_system(mouse_click_system)
+        .add_system(mouse_click_system.system())
         .run();
 }
 
diff --git a/examples/input/mouse_input_events.rs b/examples/input/mouse_input_events.rs
index 5d539315c6887..f9bab2fca06f1 100644
--- a/examples/input/mouse_input_events.rs
+++ b/examples/input/mouse_input_events.rs
@@ -7,7 +7,7 @@ use bevy::{
 fn main() {
     App::build()
         .add_plugins(DefaultPlugins)
-        .add_system(print_mouse_events_system)
+        .add_system(print_mouse_events_system.system())
         .run();
 }
 
diff --git a/examples/input/touch_input.rs b/examples/input/touch_input.rs
index 2c9873a16ce55..bd1a5312c99e8 100644
--- a/examples/input/touch_input.rs
+++ b/examples/input/touch_input.rs
@@ -3,7 +3,7 @@ use bevy::{input::touch::*, prelude::*};
 fn main() {
     App::build()
         .add_plugins(DefaultPlugins)
-        .add_system(touch_system)
+        .add_system(touch_system.system())
         .run();
 }
 
@@ -11,24 +11,26 @@ fn touch_system(touches: Res<Touches>) {
     for touch in touches.iter_just_pressed() {
         println!(
             "just pressed touch with id: {:?}, at: {:?}",
-            touch.id, touch.position
+            touch.id(),
+            touch.position()
         );
     }
 
     for touch in touches.iter_just_released() {
         println!(
             "just released touch with id: {:?}, at: {:?}",
-            touch.id, touch.position
+            touch.id(),
+            touch.position()
         );
     }
 
     for touch in touches.iter_just_cancelled() {
-        println!("cancelled touch with id: {:?}", touch.id);
+        println!("cancelled touch with id: {:?}", touch.id());
     }
 
     // you can also iterate all current touches and retrieve their state like this:
     for touch in touches.iter() {
         println!("active touch: {:?}", touch);
-        println!("  just_pressed: {}", touches.just_pressed(touch.id));
+        println!("  just_pressed: {}", touches.just_pressed(touch.id()));
     }
 }
diff --git a/examples/input/touch_input_events.rs b/examples/input/touch_input_events.rs
index 474ef2b60209b..bb6b57b33b8cd 100644
--- a/examples/input/touch_input_events.rs
+++ b/examples/input/touch_input_events.rs
@@ -3,7 +3,7 @@ use bevy::{input::touch::*, prelude::*};
 fn main() {
     App::build()
         .add_plugins(DefaultPlugins)
-        .add_system(touch_event_system)
+        .add_system(touch_event_system.system())
         .run();
 }
 
diff --git a/examples/ios/src/lib.rs b/examples/ios/src/lib.rs
index 803752e0d6672..3801169dd9ad8 100644
--- a/examples/ios/src/lib.rs
+++ b/examples/ios/src/lib.rs
@@ -12,7 +12,7 @@ fn main() {
         })
         .add_resource(Msaa { samples: 4 })
         .add_plugins(DefaultPlugins)
-        .add_startup_system(setup)
+        .add_startup_system(setup.system())
         .run();
 }
 /// set up a simple 3D scene
diff --git a/examples/reflection/generic_reflection.rs b/examples/reflection/generic_reflection.rs
new file mode 100644
index 0000000000000..085e89e90e90d
--- /dev/null
+++ b/examples/reflection/generic_reflection.rs
@@ -0,0 +1,28 @@
+use std::any::TypeId;
+
+pub use bevy::prelude::*;
+use bevy::reflect::TypeRegistry;
+
+/// You must manually register each instance of a generic type
+fn main() {
+    App::build()
+        .add_plugins(DefaultPlugins)
+        .register_type::<MyType<u32>>()
+        .add_startup_system(setup.system())
+        .run();
+}
+
+#[derive(Reflect)]
+struct MyType<T: Reflect> {
+    value: T,
+}
+
+fn setup(type_registry: Res<TypeRegistry>) {
+    let type_registry = type_registry.read();
+
+    let registration = type_registry.get(TypeId::of::<MyType<u32>>()).unwrap();
+    println!("Registration for {} exists", registration.short_name());
+
+    // MyType<String> was not manually registered, so it does not exist
+    assert!(type_registry.get(TypeId::of::<MyType<String>>()).is_none());
+}
diff --git a/examples/reflection/reflection.rs b/examples/reflection/reflection.rs
new file mode 100644
index 0000000000000..154dc3ec5930a
--- /dev/null
+++ b/examples/reflection/reflection.rs
@@ -0,0 +1,94 @@
+use bevy::{
+    prelude::*,
+    reflect::{
+        serde::{ReflectDeserializer, ReflectSerializer},
+        DynamicStruct, TypeRegistry,
+    },
+};
+use serde::de::DeserializeSeed;
+
+/// This example illustrates how "reflection" works in Bevy. Reflection provide a way to dynamically interact with Rust types,
+/// such as accessing fields by their string name. Reflection is a core part of Bevy and enables a number of interesting scenarios
+/// (like scenes).
+fn main() {
+    App::build()
+        .add_plugins(DefaultPlugins)
+        .register_type::<Foo>()
+        .register_type::<Bar>()
+        .add_startup_system(setup.system())
+        .run();
+}
+
+/// Deriving `Reflect` implements the relevant reflection traits. In this case, it implements the `Reflect` trait and the `Struct` trait
+/// `derive(Reflect)` assumes that all fields also implement Reflect.
+#[derive(Reflect)]
+pub struct Foo {
+    a: usize,
+    nested: Bar,
+    #[reflect(ignore)]
+    _ignored: NonReflectedValue,
+}
+
+/// This `Bar` type is used in the `nested` field on the `Test` type. We must derive `Reflect` here too (or ignore it)
+#[derive(Reflect)]
+pub struct Bar {
+    b: usize,
+}
+
+pub struct NonReflectedValue {
+    _a: usize,
+}
+
+fn setup(type_registry: Res<TypeRegistry>) {
+    let mut value = Foo {
+        a: 1,
+        _ignored: NonReflectedValue { _a: 10 },
+        nested: Bar { b: 8 },
+    };
+
+    // You can set field values like this. The type must match exactly or this will fail.
+    *value.get_field_mut("a").unwrap() = 2usize;
+    assert_eq!(value.a, 2);
+    assert_eq!(*value.get_field::<usize>("a").unwrap(), 2);
+
+    // You can also get the &dyn Reflect value of a field like this
+    let field = value.field("a").unwrap();
+
+    // you can downcast Reflect values like this:
+    assert_eq!(*field.downcast_ref::<usize>().unwrap(), 2);
+
+    // DynamicStruct also implements the `Struct` and `Reflect` traits.
+    let mut patch = DynamicStruct::default();
+    patch.insert("a", 4usize);
+
+    // You can "apply" Reflect implementations on top of other Reflect implementations.
+    // This will only set fields with the same name, and it will fail if the types don't match.
+    // You can use this to "patch" your types with new values.
+    value.apply(&patch);
+    assert_eq!(value.a, 4);
+
+    let type_registry = type_registry.read();
+    // By default, all derived `Reflect` types can be Serialized using serde. No need to derive Serialize!
+    let serializer = ReflectSerializer::new(&value, &type_registry);
+    let ron_string =
+        ron::ser::to_string_pretty(&serializer, ron::ser::PrettyConfig::default()).unwrap();
+    println!("{}\n", ron_string);
+
+    // Dynamic properties can be deserialized
+    let reflect_deserializer = ReflectDeserializer::new(&type_registry);
+    let mut deserializer = ron::de::Deserializer::from_str(&ron_string).unwrap();
+    let reflect_value = reflect_deserializer.deserialize(&mut deserializer).unwrap();
+
+    // Deserializing returns a Box<dyn Reflect> value. Generally, deserializing a value will return the "dynamic" variant
+    // of a type. For example, deserializing a struct will return the DynamicStruct type. "Value types" will be deserialized
+    // as themselves.
+    let _deserialized_struct = reflect_value.downcast_ref::<DynamicStruct>();
+
+    // Reflect has its own `partial_eq` implementation, named `reflect_partial_eq`. This behaves like normal `partial_eq`, but it treats "dynamic" and
+    // "non-dynamic" types the same. The `Foo` struct and deserialized `DynamicStruct` are considered equal for this reason:
+    assert!(reflect_value.reflect_partial_eq(&value).unwrap());
+
+    // By "patching" `Foo` with the deserialized DynamicStruct, we can "Deserialize" Foo.
+    // This means we can serialize and deserialize with a single `Reflect` derive!
+    value.apply(&*reflect_value);
+}
diff --git a/examples/reflection/reflection_types.rs b/examples/reflection/reflection_types.rs
new file mode 100644
index 0000000000000..3759f3bfbf5f0
--- /dev/null
+++ b/examples/reflection/reflection_types.rs
@@ -0,0 +1,95 @@
+use bevy::{
+    prelude::*,
+    reflect::{DynamicList, ReflectRef},
+    utils::HashMap,
+};
+use serde::{Deserialize, Serialize};
+
+/// This example illustrates the various reflection types available
+fn main() {
+    App::build()
+        .add_plugins(DefaultPlugins)
+        .add_startup_system(setup.system())
+        .run();
+}
+
+/// Deriving reflect on a struct will implement the `Reflect` and `Struct` traits
+#[derive(Reflect)]
+pub struct A {
+    x: usize,
+    y: Vec<u32>,
+    z: HashMap<String, f32>,
+}
+
+/// Deriving reflect on a unit struct will implement `Reflect` and `Struct` traits
+#[derive(Reflect)]
+pub struct B;
+
+/// Deriving reflect on a tuple struct will implement `Reflect` and `TupleStruct` traits
+#[derive(Reflect)]
+pub struct C(usize);
+
+/// Reflect has "built in" support for some common traits like `PartialEq`, `Hash`, and `Serialize`.
+/// These are exposed via methods like `Reflect::hash()`, `Reflect::partial_eq()`, and `Reflect::serialize()`.
+/// You can force these implementations to use the actual trait implementations (instead of their defaults) like this:
+#[derive(Reflect, Hash, Serialize, PartialEq)]
+#[reflect(Hash, Serialize, PartialEq)]
+pub struct D {
+    x: usize,
+}
+
+/// By default, deriving with Reflect assumes the type is a "struct". You can tell reflect to treat your type as a
+/// "value type" by using the `reflect_value` attribute instead of `reflect`. It is generally a good idea to implement
+/// (and reflect) the PartialEq, Serialize, and Deserialize traits on `reflect_value` types to ensure that these values
+/// behave as expected when nested underneath Reflect-ed structs.
+#[derive(Reflect, Copy, Clone, PartialEq, Serialize, Deserialize)]
+#[reflect_value(PartialEq, Serialize, Deserialize)]
+pub enum E {
+    X,
+    Y,
+}
+
+fn setup() {
+    let mut z = HashMap::default();
+    z.insert("Hello".to_string(), 1.0);
+    let value: Box<dyn Reflect> = Box::new(A {
+        x: 1,
+        y: vec![1, 2],
+        z,
+    });
+
+    // There are a number of different "reflect traits", which each expose different operations on the underlying type
+    match value.reflect_ref() {
+        // `Struct` is a trait automatically implemented for structs that derive Reflect. This trait allows you to interact
+        // with fields via their string names or indices
+        ReflectRef::Struct(value) => {
+            println!(
+                "This is a 'struct' type with an 'x' value of {}",
+                value.get_field::<usize>("x").unwrap()
+            )
+        }
+        // `TupleStruct` is a trait automatically implemented for tuple structs that derive Reflect. This trait allows you
+        // to interact with fields via their indices
+        ReflectRef::TupleStruct(_) => {}
+        // `List` is a special trait that can be manually implemented (instead of deriving Reflect). This exposes "list"
+        // operations on your type, such as indexing and insertion. List is automatically implemented for relevant core
+        // types like Vec<T>
+        ReflectRef::List(_) => {}
+        // `Map` is a special trait that can be manually implemented (instead of deriving Reflect). This exposes "map"
+        // operations on your type, such as getting / inserting by key. Map is automatically implemented for relevant core
+        // types like HashMap<K, V>
+        ReflectRef::Map(_) => {}
+        // `Value` types do not implement any of the other traits above. They are simply a Reflect implementation. Value
+        // is implemented for core types like i32, usize, f32, and String.
+        ReflectRef::Value(_) => {}
+    }
+
+    let mut dynamic_list = DynamicList::default();
+    dynamic_list.push(3u32);
+    dynamic_list.push(4u32);
+    dynamic_list.push(5u32);
+
+    let mut value: A = value.take::<A>().unwrap();
+    value.y.apply(&dynamic_list);
+    assert_eq!(value.y, vec![3u32, 4u32, 5u32]);
+}
diff --git a/examples/reflection/trait_reflection.rs b/examples/reflection/trait_reflection.rs
new file mode 100644
index 0000000000000..0171db9e76555
--- /dev/null
+++ b/examples/reflection/trait_reflection.rs
@@ -0,0 +1,56 @@
+use bevy::{prelude::*, reflect::TypeRegistry};
+
+fn main() {
+    App::build()
+        .add_plugins(DefaultPlugins)
+        .add_startup_system(setup.system())
+        .register_type::<MyType>()
+        .run();
+}
+
+#[derive(Reflect)]
+#[reflect(DoThing)]
+struct MyType {
+    value: String,
+}
+
+impl DoThing for MyType {
+    fn do_thing(&self) -> String {
+        format!("{} World!", self.value)
+    }
+}
+
+#[reflect_trait]
+pub trait DoThing {
+    fn do_thing(&self) -> String;
+}
+
+fn setup(type_registry: Res<TypeRegistry>) {
+    // First, lets box our type as a Box<dyn Reflect>
+    let reflect_value: Box<dyn Reflect> = Box::new(MyType {
+        value: "Hello".to_string(),
+    });
+
+    // This means we no longer have direct access to MyType or its methods. We can only call Reflect methods on reflect_value.
+    // What if we want to call `do_thing` on our type? We could downcast using reflect_value.downcast_ref::<MyType>(), but what if we
+    // don't know the type at compile time?
+
+    // Normally in rust we would be out of luck at this point. Lets use our new reflection powers to do something cool!
+    let type_registry = type_registry.read();
+
+    // The #[reflect] attribute we put on our DoThing trait generated a new `ReflectDoThing` struct, which implements TypeData.
+    // This was added to MyType's TypeRegistration.
+    let reflect_do_thing = type_registry
+        .get_type_data::<ReflectDoThing>(reflect_value.type_id())
+        .unwrap();
+
+    // We can use this generated type to convert our `&dyn Reflect` reference to a `&dyn DoThing` reference
+    let my_trait: &dyn DoThing = reflect_do_thing.get(&*reflect_value).unwrap();
+
+    // Which means we can now call do_thing(). Magic!
+    println!("{}", my_trait.do_thing());
+
+    // This works because the #[reflect(MyTrait)] we put on MyType informed the Reflect derive to insert a new instance
+    // of ReflectDoThing into MyType's registration. The instance knows how to cast &dyn Reflect to &dyn MyType, because it
+    // knows that &dyn Reflect should first be downcasted to &MyType, which can then be safely casted to &dyn MyType
+}
diff --git a/examples/scene/properties.rs b/examples/scene/properties.rs
deleted file mode 100644
index 89b6274ea433e..0000000000000
--- a/examples/scene/properties.rs
+++ /dev/null
@@ -1,102 +0,0 @@
-use bevy::{
-    prelude::*,
-    property::{ron::deserialize_dynamic_properties, PropertyTypeRegistry},
-    scene::serialize_ron,
-    type_registry::TypeRegistry,
-};
-use serde::{Deserialize, Serialize};
-
-/// This example illustrates how Properties work. Properties provide a way to dynamically interact with Rust struct fields using
-/// their names. Properties are a core part of Bevy and enable a number of interesting scenarios (like scenes). If you are
-/// familiar with "reflection" in other languages, Properties are very similar to that concept.
-fn main() {
-    App::build()
-        .add_plugins(DefaultPlugins)
-        // If you need to deserialize custom property types, register them like this:
-        .register_property::<Test>()
-        .register_property::<Nested>()
-        .register_property::<CustomProperty>()
-        .add_startup_system(setup)
-        .run();
-}
-
-#[derive(Properties, Default)]
-pub struct Test {
-    a: usize,
-    custom: CustomProperty,
-    nested: Nested,
-}
-
-#[derive(Properties, Default)]
-pub struct Nested {
-    b: usize,
-}
-
-#[derive(Serialize, Deserialize, Default, Clone, Property)]
-pub struct CustomProperty {
-    a: usize,
-}
-
-fn setup(type_registry: Res<TypeRegistry>) {
-    let mut test = Test {
-        a: 1,
-        custom: CustomProperty { a: 10 },
-        nested: Nested { b: 8 },
-    };
-
-    // You can set a property value like this. The type must match exactly or this will fail.
-    test.set_prop_val::<usize>("a", 2);
-    assert_eq!(test.a, 2);
-    assert_eq!(*test.prop_val::<usize>("a").unwrap(), 2);
-
-    // You can also set properties dynamically. set_prop accepts any type that implements Property
-    let x: u32 = 3;
-    test.set_prop("a", &x);
-    assert_eq!(test.a, 3);
-
-    // DynamicProperties also implements the Properties trait.
-    let mut patch = DynamicProperties::map();
-    patch.set::<usize>("a", 4);
-
-    // You can "apply" Properties on top of other Properties. This will only set properties with the same name and type.
-    // You can use this to "patch" your properties with new values.
-    test.apply(&patch);
-    assert_eq!(test.a, 4);
-
-    // All properties can be serialized.
-    // If you #[derive(Properties)] your type doesn't even need to directly implement the Serde trait!
-    let registry = type_registry.property.read();
-    let ron_string = serialize_property(&test, &registry);
-    println!("{}\n", ron_string);
-
-    // Dynamic properties can be deserialized
-    let dynamic_properties = deserialize_dynamic_properties(&ron_string, &registry).unwrap();
-
-    let round_tripped = serialize_property(&dynamic_properties, &registry);
-    println!("{}", round_tripped);
-    assert_eq!(ron_string, round_tripped);
-
-    // This means you can patch Properties with dynamic properties deserialized from a string
-    test.apply(&dynamic_properties);
-
-    // Properties can also be sequences.
-    // Sequences from std::collections (Vec, VecDeque) already implement the Properties trait
-    let mut seq = vec![1u32, 2u32];
-    let mut patch = DynamicProperties::seq();
-    patch.push(Box::new(3u32), None);
-    seq.apply(&patch);
-    assert_eq!(seq[0], 3);
-
-    let ron_string = serialize_property(&patch, &registry);
-    println!("{}\n", ron_string);
-    let dynamic_properties = deserialize_dynamic_properties(&ron_string, &registry).unwrap();
-    let round_tripped = serialize_property(&dynamic_properties, &registry);
-    assert_eq!(ron_string, round_tripped);
-}
-
-fn serialize_property<T>(property: &T, registry: &PropertyTypeRegistry) -> String
-where
-    T: Property,
-{
-    serialize_ron(property.serializable(registry).borrow()).unwrap()
-}
diff --git a/examples/scene/scene.rs b/examples/scene/scene.rs
index 06bee2ff82575..b44282871ad26 100644
--- a/examples/scene/scene.rs
+++ b/examples/scene/scene.rs
@@ -1,42 +1,39 @@
-use bevy::{prelude::*, type_registry::TypeRegistry, utils::Duration};
+use bevy::{prelude::*, reflect::TypeRegistry, utils::Duration};
 
 /// This example illustrates loading and saving scenes from files
 fn main() {
     App::build()
         .add_plugins(DefaultPlugins)
-        // Registering components informs Bevy that they exist. This allows them to be used when loading scenes
-        // This step is only required if you want to load your components from scene files.
-        // Unregistered components can still be used in your code, but they will be ignored during scene save/load.
-        // In the future registering components will also make them usable from the Bevy editor.
-        // The core Bevy plugins already register their components, so you only need this step for custom components.
-        .register_component::<ComponentA>()
-        .register_component::<ComponentB>()
-        .add_startup_system(save_scene_system)
-        .add_startup_system(load_scene_system)
-        .add_startup_system(infotext_system)
-        .add_system(print_system)
+        .register_type::<ComponentA>()
+        .register_type::<ComponentB>()
+        .add_startup_system(save_scene_system.system())
+        .add_startup_system(load_scene_system.system())
+        .add_startup_system(infotext_system.system())
+        .add_system(print_system.system())
         .run();
 }
 
-// Registered components must implement the `Properties` and `FromResources` traits.
-// The `Properties` trait enables serialization, deserialization, dynamic property access, and change detection.
-// `Properties` enable a bunch of cool behaviors, so its worth checking out the dedicated `properties.rs` example.
+// Registered components must implement the `Reflect` and `FromResources` traits.
+// The `Reflect` trait enables serialization, deserialization, and dynamic property access.
+// `Reflect` enable a bunch of cool behaviors, so its worth checking out the dedicated `reflect.rs` example.
 // The `FromResources` trait determines how your component is constructed when it loads. For simple use cases you can just
 // implement the `Default` trait (which automatically implements FromResources). The simplest registered component just needs
 // these two derives:
-#[derive(Properties, Default)]
+#[derive(Reflect, Default)]
+#[reflect(Component)] // this tells the reflect derive to also reflect component behaviors
 struct ComponentA {
     pub x: f32,
     pub y: f32,
 }
 
 // Some components have fields that cannot (or should not) be written to scene files. These can be ignored with
-// the #[property(ignore)] attribute. This is also generally where the `FromResources` trait comes into play.
+// the #[reflect(ignore)] attribute. This is also generally where the `FromResources` trait comes into play.
 // `FromResources` gives you access to your App's current ECS `Resources` when you construct your component.
-#[derive(Properties)]
+#[derive(Reflect)]
+#[reflect(Component)]
 struct ComponentB {
     pub value: String,
-    #[property(ignore)]
+    #[reflect(ignore)]
     pub time_since_startup: Duration,
 }
 
@@ -84,25 +81,23 @@ fn save_scene_system(_world: &mut World, resources: &mut Resources) {
             value: "hello".to_string(),
             ..ComponentB::from_resources(resources)
         },
+        Transform::default(),
     ));
     world.spawn((ComponentA { x: 3.0, y: 4.0 },));
 
-    // The component registry resource contains information about all registered components. This is used to construct scenes.
+    // 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.component.read());
+    let scene = DynamicScene::from_world(&world, &type_registry);
 
     // Scenes can be serialized like this:
-    println!(
-        "{}",
-        scene.serialize_ron(&type_registry.property.read()).unwrap()
-    );
+    println!("{}", scene.serialize_ron(&type_registry).unwrap());
 
     // TODO: save scene
 }
 
 // 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>) {
-    commands.spawn(UiCameraBundle::default()).spawn(TextBundle {
+    commands.spawn(CameraUiBundle::default()).spawn(TextBundle {
         style: Style {
             align_self: AlignSelf::FlexEnd,
             ..Default::default()
diff --git a/examples/shader/array_texture.rs b/examples/shader/array_texture.rs
new file mode 100644
index 0000000000000..6e6308613ab5f
--- /dev/null
+++ b/examples/shader/array_texture.rs
@@ -0,0 +1,153 @@
+use bevy::{
+    prelude::*,
+    reflect::TypeUuid,
+    render::{
+        mesh::shape,
+        pipeline::{PipelineDescriptor, RenderPipeline},
+        render_graph::{base, AssetRenderResourcesNode, RenderGraph},
+        renderer::RenderResources,
+        shader::{ShaderStage, ShaderStages},
+    },
+};
+
+/// This example illustrates how to create a texture for use with a texture2DArray shader uniform variable.
+fn main() {
+    App::build()
+        .add_plugins(DefaultPlugins)
+        .add_asset::<MyArrayTexture>()
+        .add_startup_system(setup.system())
+        .add_system(create_array_texture.system())
+        .run();
+}
+
+#[derive(RenderResources, Default, TypeUuid)]
+#[uuid = "93fb26fc-6c05-489b-9029-601edf703b6b"]
+struct MyArrayTexture {
+    pub texture: Handle<Texture>,
+}
+
+const VERTEX_SHADER: &str = r#"
+#version 450
+
+layout(location = 0) in vec3 Vertex_Position;
+layout(location = 0) out vec4 v_Position;
+
+layout(set = 0, binding = 0) uniform Camera {
+    mat4 ViewProj;
+};
+layout(set = 1, binding = 0) uniform Transform {
+    mat4 Model;
+};
+
+void main() {
+    v_Position = ViewProj * Model * vec4(Vertex_Position, 1.0);
+    gl_Position = v_Position;
+}
+"#;
+
+const FRAGMENT_SHADER: &str = r#"
+#version 450
+
+layout(location = 0) in vec4 v_Position;
+layout(location = 0) out vec4 o_Target;
+
+layout(set = 2, binding = 0) uniform texture2DArray MyArrayTexture_texture;
+layout(set = 2, binding = 1) uniform sampler MyArrayTexture_texture_sampler;
+
+void main() {
+    // Screen-space coordinates determine which layer of the array texture we sample.
+    vec2 ss = v_Position.xy / v_Position.w;
+    float layer = 0.0;
+    if (ss.x > 0.0 && ss.y > 0.0) {
+        layer = 0.0;
+    } else if (ss.x < 0.0 && ss.y > 0.0) {
+        layer = 1.0;
+    } else if (ss.x > 0.0 && ss.y < 0.0) {
+        layer = 2.0;
+    } else {
+        layer = 3.0;
+    }
+
+    // Convert to texture coordinates.
+    vec2 uv = (ss + vec2(1.0)) / 2.0;
+
+    o_Target = texture(sampler2DArray(MyArrayTexture_texture, MyArrayTexture_texture_sampler), vec3(uv, layer));
+}
+"#;
+
+struct LoadingTexture(Option<Handle<Texture>>);
+
+struct MyPipeline(Handle<PipelineDescriptor>);
+
+fn setup(
+    commands: &mut Commands,
+    asset_server: Res<AssetServer>,
+    mut pipelines: ResMut<Assets<PipelineDescriptor>>,
+    mut shaders: ResMut<Assets<Shader>>,
+    mut render_graph: ResMut<RenderGraph>,
+) {
+    // Start loading the texture.
+    commands.insert_resource(LoadingTexture(Some(
+        asset_server.load("textures/array_texture.png"),
+    )));
+
+    // Create a new shader pipeline.
+    let pipeline_handle = pipelines.add(PipelineDescriptor::default_config(ShaderStages {
+        vertex: shaders.add(Shader::from_glsl(ShaderStage::Vertex, VERTEX_SHADER)),
+        fragment: Some(shaders.add(Shader::from_glsl(ShaderStage::Fragment, FRAGMENT_SHADER))),
+    }));
+    commands.insert_resource(MyPipeline(pipeline_handle));
+
+    // Add an AssetRenderResourcesNode to our Render Graph. This will bind MyArrayTexture resources to our shader.
+    render_graph.add_system_node(
+        "my_array_texture",
+        AssetRenderResourcesNode::<MyArrayTexture>::new(true),
+    );
+    // Add a Render Graph edge connecting our new "my_array_texture" node to the main pass node. This ensures "my_array_texture"
+    // runs before the main pass.
+    render_graph
+        .add_node_edge("my_array_texture", base::node::MAIN_PASS)
+        .unwrap();
+
+    commands.spawn(Camera3dBundle {
+        transform: Transform::from_translation(Vec3::new(2.0, 2.0, 2.0))
+            .looking_at(Vec3::default(), Vec3::unit_y()),
+        ..Default::default()
+    });
+}
+
+fn create_array_texture(
+    commands: &mut Commands,
+    my_pipeline: Res<MyPipeline>,
+    mut loading_texture: ResMut<LoadingTexture>,
+    mut textures: ResMut<Assets<Texture>>,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut array_textures: ResMut<Assets<MyArrayTexture>>,
+) {
+    let (handle, texture) = match loading_texture.0.as_ref() {
+        Some(handle) => {
+            if let Some(texture) = textures.get_mut(handle) {
+                (loading_texture.0.take().unwrap(), texture)
+            } else {
+                return;
+            }
+        }
+        None => return,
+    };
+
+    // Create a new array texture asset from the loaded texture.
+    let array_layers = 4;
+    texture.reinterpret_stacked_2d_as_array(array_layers);
+    let array_texture = array_textures.add(MyArrayTexture { texture: handle });
+
+    // Spawn a cube that's shaded using the array texture.
+    commands
+        .spawn(MeshBundle {
+            mesh: meshes.add(Mesh::from(shape::Cube { size: 1.0 })),
+            render_pipelines: RenderPipelines::from_pipelines(vec![RenderPipeline::new(
+                my_pipeline.0.clone(),
+            )]),
+            ..Default::default()
+        })
+        .with(array_texture);
+}
diff --git a/examples/shader/hot_shader_reloading.rs b/examples/shader/hot_shader_reloading.rs
new file mode 100644
index 0000000000000..df72952603ea7
--- /dev/null
+++ b/examples/shader/hot_shader_reloading.rs
@@ -0,0 +1,80 @@
+use bevy::{
+    prelude::*,
+    reflect::TypeUuid,
+    render::{
+        mesh::shape,
+        pipeline::{PipelineDescriptor, RenderPipeline},
+        render_graph::{base, AssetRenderResourcesNode, RenderGraph},
+        renderer::RenderResources,
+        shader::ShaderStages,
+    },
+};
+
+/// This example illustrates how to load shaders such that they can be
+/// edited while the example is still running.
+fn main() {
+    App::build()
+        .add_plugins(DefaultPlugins)
+        .add_asset::<MyMaterial>()
+        .add_startup_system(setup.system())
+        .run();
+}
+
+#[derive(RenderResources, Default, TypeUuid)]
+#[uuid = "3bf9e364-f29d-4d6c-92cf-93298466c620"]
+struct MyMaterial {
+    pub color: Color,
+}
+
+fn setup(
+    commands: &mut Commands,
+    asset_server: ResMut<AssetServer>,
+    mut pipelines: ResMut<Assets<PipelineDescriptor>>,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<MyMaterial>>,
+    mut render_graph: ResMut<RenderGraph>,
+) {
+    // Watch for changes
+    asset_server.watch_for_changes().unwrap();
+
+    // Create a new shader pipeline with shaders loaded from the asset directory
+    let pipeline_handle = pipelines.add(PipelineDescriptor::default_config(ShaderStages {
+        vertex: asset_server.load::<Shader, _>("shaders/hot.vert"),
+        fragment: Some(asset_server.load::<Shader, _>("shaders/hot.frag")),
+    }));
+
+    // Add an AssetRenderResourcesNode to our Render Graph. This will bind MyMaterial resources to our shader
+    render_graph.add_system_node(
+        "my_material",
+        AssetRenderResourcesNode::<MyMaterial>::new(true),
+    );
+
+    // Add a Render Graph edge connecting our new "my_material" node to the main pass node. This ensures "my_material" runs before the main pass
+    render_graph
+        .add_node_edge("my_material", base::node::MAIN_PASS)
+        .unwrap();
+
+    // Create a new material
+    let material = materials.add(MyMaterial {
+        color: Color::rgb(0.0, 0.8, 0.0),
+    });
+
+    // Setup our world
+    commands
+        // cube
+        .spawn(MeshBundle {
+            mesh: meshes.add(Mesh::from(shape::Cube { size: 2.0 })),
+            render_pipelines: RenderPipelines::from_pipelines(vec![RenderPipeline::new(
+                pipeline_handle,
+            )]),
+            transform: Transform::from_translation(Vec3::new(0.0, 0.0, 0.0)),
+            ..Default::default()
+        })
+        .with(material)
+        // camera
+        .spawn(Camera3dBundle {
+            transform: Transform::from_translation(Vec3::new(3.0, 5.0, -8.0))
+                .looking_at(Vec3::default(), Vec3::unit_y()),
+            ..Default::default()
+        });
+}
diff --git a/examples/shader/mesh_custom_attribute.rs b/examples/shader/mesh_custom_attribute.rs
index 98ea547636459..e6f822b42e975 100644
--- a/examples/shader/mesh_custom_attribute.rs
+++ b/examples/shader/mesh_custom_attribute.rs
@@ -1,5 +1,6 @@
 use bevy::{
     prelude::*,
+    reflect::TypeUuid,
     render::{
         mesh::{shape, VertexAttributeValues},
         pipeline::{PipelineDescriptor, RenderPipeline},
@@ -7,7 +8,6 @@ use bevy::{
         renderer::RenderResources,
         shader::{ShaderStage, ShaderStages},
     },
-    type_registry::TypeUuid,
 };
 
 /// This example illustrates how to add a custom attribute to a mesh and use it in a custom shader.
@@ -15,7 +15,7 @@ fn main() {
     App::build()
         .add_plugins(DefaultPlugins)
         .add_asset::<MyMaterialWithVertexColorSupport>()
-        .add_startup_system(setup)
+        .add_startup_system(setup.system())
         .run();
 }
 
diff --git a/examples/shader/shader_custom_material.rs b/examples/shader/shader_custom_material.rs
index ddaae959ac848..346a2c8338a80 100644
--- a/examples/shader/shader_custom_material.rs
+++ b/examples/shader/shader_custom_material.rs
@@ -1,5 +1,6 @@
 use bevy::{
     prelude::*,
+    reflect::TypeUuid,
     render::{
         mesh::shape,
         pipeline::{PipelineDescriptor, RenderPipeline},
@@ -7,7 +8,6 @@ use bevy::{
         renderer::RenderResources,
         shader::{ShaderStage, ShaderStages},
     },
-    type_registry::TypeUuid,
 };
 
 /// This example illustrates how to create a custom material asset and a shader that uses that material
@@ -15,7 +15,7 @@ fn main() {
     App::build()
         .add_plugins(DefaultPlugins)
         .add_asset::<MyMaterial>()
-        .add_startup_system(setup)
+        .add_startup_system(setup.system())
         .run();
 }
 
@@ -42,7 +42,7 @@ void main() {
 const FRAGMENT_SHADER: &str = r#"
 #version 450
 layout(location = 0) out vec4 o_Target;
-layout(set = 1, binding = 1) uniform MyMaterial_color {
+layout(set = 2, binding = 0) uniform MyMaterial_color {
     vec4 color;
 };
 void main() {
diff --git a/examples/shader/shader_defs.rs b/examples/shader/shader_defs.rs
index f3426160513bd..e8b429c420875 100644
--- a/examples/shader/shader_defs.rs
+++ b/examples/shader/shader_defs.rs
@@ -1,5 +1,6 @@
 use bevy::{
     prelude::*,
+    reflect::TypeUuid,
     render::{
         mesh::shape,
         pipeline::{PipelineDescriptor, RenderPipeline},
@@ -7,7 +8,6 @@ use bevy::{
         renderer::RenderResources,
         shader::{asset_shader_defs_system, ShaderDefs, ShaderStage, ShaderStages},
     },
-    type_registry::TypeUuid,
 };
 
 /// This example illustrates how to create a custom material asset that uses "shader defs" and a shader that uses that material.
@@ -16,8 +16,11 @@ fn main() {
     App::build()
         .add_plugins(DefaultPlugins)
         .add_asset::<MyMaterial>()
-        .add_startup_system(setup)
-        .add_system_to_stage(stage::POST_UPDATE, asset_shader_defs_system::<MyMaterial>)
+        .add_startup_system(setup.system())
+        .add_system_to_stage(
+            stage::POST_UPDATE,
+            asset_shader_defs_system::<MyMaterial>.system(),
+        )
         .run();
 }
 
@@ -47,7 +50,7 @@ void main() {
 const FRAGMENT_SHADER: &str = r#"
 #version 450
 layout(location = 0) out vec4 o_Target;
-layout(set = 1, binding = 1) uniform MyMaterial_color {
+layout(set = 2, binding = 0) uniform MyMaterial_color {
     vec4 color;
 };
 void main() {
diff --git a/examples/tools/bevymark.rs b/examples/tools/bevymark.rs
index da9dab64b8938..a2983947b9d50 100644
--- a/examples/tools/bevymark.rs
+++ b/examples/tools/bevymark.rs
@@ -30,8 +30,8 @@ fn main() {
     App::build()
         .add_resource(WindowDescriptor {
             title: "BevyMark".to_string(),
-            width: 800,
-            height: 600,
+            width: 800.,
+            height: 600.,
             vsync: true,
             resizable: false,
             ..Default::default()
@@ -40,18 +40,18 @@ fn main() {
         .add_plugin(FrameTimeDiagnosticsPlugin::default())
         .add_resource(BevyCounter { count: 0 })
         .init_resource::<BirdMaterial>()
-        .add_startup_system(setup)
-        .add_system(mouse_handler)
-        .add_system(movement_system)
-        .add_system(collision_system)
-        .add_system(counter_system)
+        .add_startup_system(setup.system())
+        .add_system(mouse_handler.system())
+        .add_system(movement_system.system())
+        .add_system(collision_system.system())
+        .add_system(counter_system.system())
         .run();
 }
 
 fn setup(commands: &mut Commands, asset_server: Res<AssetServer>) {
     commands
         .spawn(Camera2dBundle::default())
-        .spawn(UiCameraBundle::default())
+        .spawn(CameraUiBundle::default())
         .spawn(TextBundle {
             text: Text {
                 font: asset_server.load("fonts/FiraSans-Bold.ttf"),
@@ -84,21 +84,18 @@ fn mouse_handler(
     mut counter: ResMut<BevyCounter>,
 ) {
     if mouse_button_input.pressed(MouseButton::Left) {
-        let spawn_count = (BIRDS_PER_SECOND as f32 * time.delta_seconds) as u128;
-        let bird_x = (window.width as i32 / -2) as f32 + HALF_BIRD_SIZE;
-        let bird_y = (window.height / 2) as f32 - HALF_BIRD_SIZE;
+        let spawn_count = (BIRDS_PER_SECOND as f32 * time.delta_seconds()) as u128;
+        let bird_x = (window.width / -2.) + HALF_BIRD_SIZE;
+        let bird_y = (window.height / 2.) - HALF_BIRD_SIZE;
 
         for count in 0..spawn_count {
-            let bird_position = Vec3::new(bird_x, bird_y, (counter.count + count) as f32 * 0.00001);
-            let mut transform = Transform::from_translation(bird_position);
-            transform.scale = Vec3::new(BIRD_SCALE, BIRD_SCALE, BIRD_SCALE);
-
+            let bird_z = (counter.count + count) as f32 * 0.00001;
             commands
                 .spawn(SpriteBundle {
                     material: bird_material.0.clone(),
-                    transform,
-                    draw: Draw {
-                        is_transparent: true,
+                    transform: Transform {
+                        translation: Vec3::new(bird_x, bird_y, bird_z),
+                        scale: Vec3::splat(BIRD_SCALE),
                         ..Default::default()
                     },
                     ..Default::default()
@@ -118,9 +115,9 @@ fn mouse_handler(
 
 fn movement_system(time: Res<Time>, mut bird_query: Query<(&mut Bird, &mut Transform)>) {
     for (mut bird, mut transform) in bird_query.iter_mut() {
-        transform.translation.x += bird.velocity.x * time.delta_seconds;
-        transform.translation.y += bird.velocity.y * time.delta_seconds;
-        bird.velocity.y += GRAVITY * time.delta_seconds;
+        transform.translation.x += bird.velocity.x * time.delta_seconds();
+        transform.translation.y += bird.velocity.y * time.delta_seconds();
+        bird.velocity.y += GRAVITY * time.delta_seconds();
     }
 }
 
diff --git a/examples/ui/button.rs b/examples/ui/button.rs
index 48be106c3ab5e..d67762853957b 100644
--- a/examples/ui/button.rs
+++ b/examples/ui/button.rs
@@ -5,8 +5,8 @@ fn main() {
     App::build()
         .add_plugins(DefaultPlugins)
         .init_resource::<ButtonMaterials>()
-        .add_startup_system(setup)
-        .add_system(button_system)
+        .add_startup_system(setup.system())
+        .add_system(button_system.system())
         .run();
 }
 
@@ -61,7 +61,7 @@ fn setup(
 ) {
     commands
         // ui camera
-        .spawn(UiCameraBundle::default())
+        .spawn(CameraUiBundle::default())
         .spawn(ButtonBundle {
             style: Style {
                 size: Size::new(Val::Px(150.0), Val::Px(65.0)),
diff --git a/examples/ui/font_atlas_debug.rs b/examples/ui/font_atlas_debug.rs
index c4b991b752662..92be9e7a7e408 100644
--- a/examples/ui/font_atlas_debug.rs
+++ b/examples/ui/font_atlas_debug.rs
@@ -5,9 +5,9 @@ fn main() {
     App::build()
         .init_resource::<State>()
         .add_plugins(DefaultPlugins)
-        .add_startup_system(setup)
-        .add_system(text_update_system)
-        .add_system(atlas_render_system)
+        .add_startup_system(setup.system())
+        .add_system(text_update_system.system())
+        .add_system(atlas_render_system.system())
         .run();
 }
 
@@ -62,7 +62,7 @@ fn atlas_render_system(
 }
 
 fn text_update_system(mut state: ResMut<State>, time: Res<Time>, mut query: Query<&mut Text>) {
-    if state.timer.tick(time.delta_seconds).finished {
+    if state.timer.tick(time.delta_seconds()).finished() {
         for mut text in query.iter_mut() {
             let c = rand::random::<u8>() as char;
             if !text.value.contains(c) {
@@ -77,7 +77,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>) {
     let font_handle = asset_server.load("fonts/FiraSans-Bold.ttf");
     state.handle = font_handle.clone();
-    commands.spawn(UiCameraBundle::default()).spawn(TextBundle {
+    commands.spawn(CameraUiBundle::default()).spawn(TextBundle {
         text: Text {
             value: "a".to_string(),
             font: font_handle,
diff --git a/examples/ui/text.rs b/examples/ui/text.rs
index 6c98e482cbcb5..3a991075e5f5f 100644
--- a/examples/ui/text.rs
+++ b/examples/ui/text.rs
@@ -8,8 +8,8 @@ fn main() {
     App::build()
         .add_plugins(DefaultPlugins)
         .add_plugin(FrameTimeDiagnosticsPlugin::default())
-        .add_startup_system(setup)
-        .add_system(text_update_system)
+        .add_startup_system(setup.system())
+        .add_system(text_update_system.system())
         .run();
 }
 
@@ -29,7 +29,7 @@ fn text_update_system(diagnostics: Res<Diagnostics>, mut query: Query<&mut Text,
 fn setup(commands: &mut Commands, asset_server: Res<AssetServer>) {
     commands
         // 2d camera
-        .spawn(UiCameraBundle::default())
+        .spawn(CameraUiBundle::default())
         // texture
         .spawn(TextBundle {
             style: Style {
diff --git a/examples/ui/text_debug.rs b/examples/ui/text_debug.rs
index 856e934efd0a8..b89c7b724a87c 100644
--- a/examples/ui/text_debug.rs
+++ b/examples/ui/text_debug.rs
@@ -1,12 +1,19 @@
-use bevy::prelude::*;
-extern crate rand;
+use bevy::{
+    diagnostic::{Diagnostics, FrameTimeDiagnosticsPlugin},
+    prelude::*,
+};
 
 /// This example is for debugging text layout
 fn main() {
     App::build()
+        .add_resource(WindowDescriptor {
+            vsync: false,
+            ..Default::default()
+        })
         .add_plugins(DefaultPlugins)
-        .add_startup_system(infotext_system)
-        .add_system(change_text_system)
+        .add_plugin(FrameTimeDiagnosticsPlugin)
+        .add_startup_system(infotext_system.system())
+        .add_system(change_text_system.system())
         .run();
 }
 
@@ -14,7 +21,8 @@ struct TextChanges;
 
 fn infotext_system(commands: &mut Commands, asset_server: Res<AssetServer>) {
     let font = asset_server.load("fonts/FiraSans-Bold.ttf");
-    commands.spawn(UiCameraBundle::default()).spawn(TextBundle {
+    commands.spawn(CameraUiBundle::default());
+    commands.spawn(TextBundle {
         style: Style {
             align_self: AlignSelf::FlexEnd,
             position_type: PositionType::Absolute,
@@ -36,7 +44,7 @@ fn infotext_system(commands: &mut Commands, asset_server: Res<AssetServer>) {
         },
         ..Default::default()
     });
-    commands.spawn(UiCameraBundle::default()).spawn(TextBundle {
+    commands.spawn(TextBundle {
         style: Style {
             align_self: AlignSelf::FlexEnd,
             position_type: PositionType::Absolute,
@@ -67,7 +75,6 @@ fn infotext_system(commands: &mut Commands, asset_server: Res<AssetServer>) {
         ..Default::default()
     });
     commands
-        .spawn(UiCameraBundle::default())
         .spawn(TextBundle {
             style: Style {
                 align_self: AlignSelf::FlexEnd,
@@ -83,7 +90,7 @@ fn infotext_system(commands: &mut Commands, asset_server: Res<AssetServer>) {
                 value: "This text changes in the bottom right".to_string(),
                 font: font.clone(),
                 style: TextStyle {
-                    font_size: 50.0,
+                    font_size: 30.0,
                     color: Color::WHITE,
                     alignment: TextAlignment::default(),
                 },
@@ -91,7 +98,7 @@ fn infotext_system(commands: &mut Commands, asset_server: Res<AssetServer>) {
             ..Default::default()
         })
         .with(TextChanges);
-    commands.spawn(UiCameraBundle::default()).spawn(TextBundle {
+    commands.spawn(TextBundle {
         style: Style {
             align_self: AlignSelf::FlexEnd,
             position_type: PositionType::Absolute,
@@ -120,11 +127,31 @@ fn infotext_system(commands: &mut Commands, asset_server: Res<AssetServer>) {
     });
 }
 
-fn change_text_system(mut query: Query<(&mut Text, &TextChanges)>) {
-    for (mut text, _text_changes) in query.iter_mut() {
+fn change_text_system(
+    time: Res<Time>,
+    diagnostics: Res<Diagnostics>,
+    mut query: Query<&mut Text, With<TextChanges>>,
+) {
+    for mut text in query.iter_mut() {
+        let mut fps = 0.0;
+        if let Some(fps_diagnostic) = diagnostics.get(FrameTimeDiagnosticsPlugin::FPS) {
+            if let Some(fps_avg) = fps_diagnostic.average() {
+                fps = fps_avg;
+            }
+        }
+
+        let mut frame_time = time.delta_seconds_f64();
+        if let Some(frame_time_diagnostic) = diagnostics.get(FrameTimeDiagnosticsPlugin::FRAME_TIME)
+        {
+            if let Some(frame_time_avg) = frame_time_diagnostic.average() {
+                frame_time = frame_time_avg;
+            }
+        }
+
         text.value = format!(
-            "This text changes in the bottom right {}",
-            rand::random::<u16>(),
+            "This text changes in the bottom right - {:.1} fps, {:.3} ms/frame",
+            fps,
+            frame_time * 1000.0,
         );
     }
 }
diff --git a/examples/ui/ui.rs b/examples/ui/ui.rs
index 7c4e45c5bd526..e7aed775b7ffb 100644
--- a/examples/ui/ui.rs
+++ b/examples/ui/ui.rs
@@ -4,7 +4,7 @@ use bevy::prelude::*;
 fn main() {
     App::build()
         .add_plugins(DefaultPlugins)
-        .add_startup_system(setup)
+        .add_startup_system(setup.system())
         .run();
 }
 
@@ -15,7 +15,7 @@ fn setup(
 ) {
     commands
         // ui camera
-        .spawn(UiCameraBundle::default())
+        .spawn(CameraUiBundle::default())
         // root node
         .spawn(NodeBundle {
             style: Style {
@@ -115,10 +115,6 @@ fn setup(
                         ..Default::default()
                     },
                     material: materials.add(Color::NONE.into()),
-                    draw: Draw {
-                        is_transparent: true,
-                        ..Default::default()
-                    },
                     ..Default::default()
                 })
                 .with_children(|parent| {
@@ -188,10 +184,6 @@ fn setup(
                                         ..Default::default()
                                     },
                                     material: materials.add(Color::rgba(1.0, 0.9, 0.9, 0.4).into()),
-                                    draw: Draw {
-                                        is_transparent: true,
-                                        ..Default::default()
-                                    },
                                     ..Default::default()
                                 });
                         });
@@ -206,10 +198,6 @@ fn setup(
                         ..Default::default()
                     },
                     material: materials.add(Color::NONE.into()),
-                    draw: Draw {
-                        is_transparent: true,
-                        ..Default::default()
-                    },
                     ..Default::default()
                 })
                 .with_children(|parent| {
@@ -221,10 +209,6 @@ fn setup(
                         },
                         material: materials
                             .add(asset_server.load("branding/bevy_logo_dark_big.png").into()),
-                        draw: Draw {
-                            is_transparent: true,
-                            ..Default::default()
-                        },
                         ..Default::default()
                     });
                 });
diff --git a/examples/wasm/assets_wasm.rs b/examples/wasm/assets_wasm.rs
index 6f9fbac34c625..803f3d64ff90d 100644
--- a/examples/wasm/assets_wasm.rs
+++ b/examples/wasm/assets_wasm.rs
@@ -1,7 +1,7 @@
 use bevy::{
     asset::{AssetLoader, AssetServerSettings, LoadContext, LoadedAsset},
     prelude::*,
-    type_registry::TypeUuid,
+    reflect::TypeUuid,
     utils::BoxedFuture,
 };
 
@@ -13,8 +13,8 @@ fn main() {
         .add_plugins(DefaultPlugins)
         .add_asset::<RustSourceCode>()
         .init_asset_loader::<RustSourceCodeLoader>()
-        .add_startup_system(load_asset)
-        .add_system(print_asset)
+        .add_startup_system(load_asset.system())
+        .add_system(print_asset.system())
         .run();
 }
 
diff --git a/examples/wasm/headless_wasm.rs b/examples/wasm/headless_wasm.rs
index 9efbf7d3eea06..df4a381636ab6 100644
--- a/examples/wasm/headless_wasm.rs
+++ b/examples/wasm/headless_wasm.rs
@@ -12,8 +12,8 @@ fn main() {
         )))
         .add_plugin(ScheduleRunnerPlugin::default())
         .add_plugin(LogPlugin::default())
-        .add_startup_system(hello_world_system)
-        .add_system(counter)
+        .add_startup_system(hello_world_system.system())
+        .add_system(counter.system())
         .run();
 }
 
diff --git a/examples/wasm/hello_wasm.rs b/examples/wasm/hello_wasm.rs
index 22c6f0960bb48..c3fbef4bdaa84 100644
--- a/examples/wasm/hello_wasm.rs
+++ b/examples/wasm/hello_wasm.rs
@@ -3,7 +3,7 @@ use bevy::{log::LogPlugin, prelude::*};
 fn main() {
     App::build()
         .add_plugin(LogPlugin::default())
-        .add_system(hello_wasm_system)
+        .add_system(hello_wasm_system.system())
         .run();
 }
 
diff --git a/examples/wasm/winit_wasm.rs b/examples/wasm/winit_wasm.rs
index cc63adc23438e..b3913c237951c 100644
--- a/examples/wasm/winit_wasm.rs
+++ b/examples/wasm/winit_wasm.rs
@@ -9,18 +9,18 @@ use bevy::{
 fn main() {
     App::build()
         .add_resource(WindowDescriptor {
-            width: 300,
-            height: 300,
+            width: 300.,
+            height: 300.,
             ..Default::default()
         })
         .add_plugins(DefaultPlugins)
         // One time greet
-        .add_startup_system(hello_wasm_system)
+        .add_startup_system(hello_wasm_system.system())
         // Track ticks (sanity check, whether game loop is running)
-        .add_system(counter)
+        .add_system(counter.system())
         // Track input events
         .init_resource::<TrackInputState>()
-        .add_system(track_input_events)
+        .add_system(track_input_events.system())
         .run();
 }
 
@@ -34,7 +34,7 @@ fn counter(mut state: Local<CounterState>, time: Res<Time>) {
             "tick {} @ {:?} [Δ{}]",
             state.count,
             time.time_since_startup(),
-            time.delta_seconds
+            time.delta_seconds()
         );
     }
     state.count += 1;
diff --git a/examples/window/multiple_windows.rs b/examples/window/multiple_windows.rs
index e86cbd55e832c..f8f91434da89f 100644
--- a/examples/window/multiple_windows.rs
+++ b/examples/window/multiple_windows.rs
@@ -16,18 +16,31 @@ use bevy::{
 fn main() {
     App::build()
         .add_resource(Msaa { samples: 4 })
+        .add_resource(State::new(AppState::CreateWindow))
         .add_plugins(DefaultPlugins)
-        .add_startup_system(setup)
+        .add_stage_after(
+            stage::UPDATE,
+            STATE_STAGE,
+            StateStage::<AppState>::default(),
+        )
+        .on_state_update(STATE_STAGE, AppState::CreateWindow, setup_window.system())
+        .on_state_enter(STATE_STAGE, AppState::Setup, setup_pipeline.system())
         .run();
 }
 
-fn setup(
-    commands: &mut Commands,
+const STATE_STAGE: &str = "state";
+
+// NOTE: this "state based" approach to multiple windows is a short term workaround.
+// Future Bevy releases shouldn't require such a strict order of operations.
+#[derive(Clone)]
+enum AppState {
+    CreateWindow,
+    Setup,
+}
+
+fn setup_window(
+    mut app_state: ResMut<State<AppState>>,
     mut create_window_events: ResMut<Events<CreateWindow>>,
-    mut active_cameras: ResMut<ActiveCameras>,
-    mut render_graph: ResMut<RenderGraph>,
-    asset_server: Res<AssetServer>,
-    msaa: Res<Msaa>,
 ) {
     let window_id = WindowId::new();
 
@@ -35,14 +48,32 @@ fn setup(
     create_window_events.send(CreateWindow {
         id: window_id,
         descriptor: WindowDescriptor {
-            width: 800,
-            height: 600,
+            width: 800.,
+            height: 600.,
             vsync: false,
             title: "second window".to_string(),
             ..Default::default()
         },
     });
 
+    app_state.set_next(AppState::Setup).unwrap();
+}
+
+fn setup_pipeline(
+    commands: &mut Commands,
+    windows: Res<Windows>,
+    mut active_cameras: ResMut<ActiveCameras>,
+    mut render_graph: ResMut<RenderGraph>,
+    asset_server: Res<AssetServer>,
+    msaa: Res<Msaa>,
+) {
+    // get the non-default window id
+    let window_id = windows
+        .iter()
+        .find(|w| w.id() != WindowId::default())
+        .map(|w| w.id())
+        .unwrap();
+
     // here we setup our render graph to draw our second camera to the new window's swap chain
 
     // add a swapchain node for our new window
diff --git a/examples/window/window_settings.rs b/examples/window/window_settings.rs
index 5e35f0df2d811..a01f67181bb5d 100644
--- a/examples/window/window_settings.rs
+++ b/examples/window/window_settings.rs
@@ -5,15 +5,15 @@ fn main() {
     App::build()
         .add_resource(WindowDescriptor {
             title: "I am a window!".to_string(),
-            width: 500,
-            height: 300,
+            width: 500.,
+            height: 300.,
             vsync: true,
             resizable: false,
             ..Default::default()
         })
         .add_plugins(DefaultPlugins)
-        .add_system(change_title)
-        .add_system(toggle_cursor)
+        .add_system(change_title.system())
+        .add_system(toggle_cursor.system())
         .run();
 }
 
@@ -22,7 +22,7 @@ fn change_title(time: Res<Time>, mut windows: ResMut<Windows>) {
     let window = windows.get_primary_mut().unwrap();
     window.set_title(format!(
         "Seconds since startup: {}",
-        time.seconds_since_startup.round()
+        time.seconds_since_startup().round()
     ));
 }
 
diff --git a/tools/publish.sh b/tools/publish.sh
index 133ef1375fea9..6d827feaf6214 100644
--- a/tools/publish.sh
+++ b/tools/publish.sh
@@ -4,14 +4,13 @@ crates=(
     bevy_derive
     bevy_math
     bevy_tasks
-    bevy_ecs/hecs/macros
-    bevy_ecs/hecs
+    bevy_ecs/macros
     bevy_ecs
     bevy_app
+    bevy_log
     bevy_dynamic_plugin
-    bevy_property/bevy_property_derive
-    bevy_property
-    bevy_type_registry
+    bevy_reflect/bevy_reflect_derive
+    bevy_reflect
     bevy_asset
     bevy_audio
     bevy_core
@@ -29,6 +28,8 @@ crates=(
     bevy_ui
     bevy_winit
     bevy_wgpu
+    bevy_internal
+    bevy_dylib
 )
 
 cd crates