diff --git a/Cargo.toml b/Cargo.toml
index ee26789e927da..bc85084c68c6f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -75,7 +75,7 @@ bevy_internal = {path = "crates/bevy_internal", version = "0.3.0", default-featu
 [dev-dependencies]
 anyhow = "1.0"
 rand = "0.7.3"
-ron = "0.6"
+ron = "0.6.2"
 serde = {version = "1", features = ["derive"]}
 
 [[example]]
@@ -255,12 +255,24 @@ name = "touch_input_events"
 path = "examples/input/touch_input_events.rs"
 
 [[example]]
-name = "scene"
-path = "examples/scene/scene.rs"
+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 = "properties"
-path = "examples/scene/properties.rs"
+name = "scene"
+path = "examples/scene/scene.rs"
 
 [[example]]
 name = "mesh_custom_attribute"
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/crates/bevy_asset/Cargo.toml b/crates/bevy_asset/Cargo.toml
index d0ef595e9434d..31b5d9f075935 100644
--- a/crates/bevy_asset/Cargo.toml
+++ b/crates/bevy_asset/Cargo.toml
@@ -20,13 +20,11 @@ filesystem_watcher = ["notify"]
 # bevy
 bevy_app = { path = "../bevy_app", version = "0.3.0" }
 bevy_ecs = { path = "../bevy_ecs", version = "0.3.0" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.3.0", features = ["bevy"] }
 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" }
 
 # 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 eebda681cb369..90d1bc910bb93 100644
--- a/crates/bevy_asset/src/asset_server.rs
+++ b/crates/bevy_asset/src/asset_server.rs
@@ -7,12 +7,11 @@ 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)]
diff --git a/crates/bevy_asset/src/assets.rs b/crates/bevy_asset/src/assets.rs
index e3fd86c20a478..83cbeccc9433d 100644
--- a/crates/bevy_asset/src/assets.rs
+++ b/crates/bevy_asset/src/assets.rs
@@ -3,7 +3,6 @@ use crate::{
 };
 use bevy_app::{prelude::Events, AppBuilder};
 use bevy_ecs::{FromResources, ResMut};
-use bevy_type_registry::RegisterType;
 use bevy_utils::HashMap;
 use crossbeam_channel::Sender;
 use std::fmt::Debug;
@@ -218,7 +217,6 @@ 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_event::<AssetEvent<T>>()
diff --git a/crates/bevy_asset/src/handle.rs b/crates/bevy_asset/src/handle.rs
index f028309197d37..f14aa5d228d88 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, 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,15 @@ 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)]
 pub struct Handle<T>
 where
     T: 'static,
 {
     pub id: HandleId,
-    #[property(ignore)]
+    #[reflect(ignore)]
     handle_type: HandleType,
-    #[property(ignore)]
+    #[reflect(ignore)]
     marker: PhantomData<T>,
 }
 
@@ -184,7 +184,7 @@ impl<T> From<&Handle<T>> for HandleId {
 
 impl<T> Hash for Handle<T> {
     fn hash<H: Hasher>(&self, state: &mut H) {
-        self.id.hash(state);
+        Hash::hash(&self.id, state);
     }
 }
 
@@ -311,7 +311,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/lib.rs b/crates/bevy_asset/src/lib.rs
index f97abe5e1826e..20941024edd70 100644
--- a/crates/bevy_asset/src/lib.rs
+++ b/crates/bevy_asset/src/lib.rs
@@ -13,6 +13,7 @@ mod path;
 
 pub use asset_server::*;
 pub use assets::*;
+use bevy_reflect::RegisterTypeBuilder;
 use bevy_tasks::IoTaskPool;
 pub use handle::*;
 pub use info::*;
@@ -31,7 +32,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
@@ -76,7 +76,7 @@ impl Plugin for AssetPlugin {
         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>()
+            .register_type::<HandleId>()
             .add_system_to_stage(
                 bevy_app::stage::PRE_UPDATE,
                 asset_server::free_unused_assets_system,
diff --git a/crates/bevy_asset/src/loader.rs b/crates/bevy_asset/src/loader.rs
index 903f5efca9ec5..68bca038d055b 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};
diff --git a/crates/bevy_asset/src/path.rs b/crates/bevy_asset/src/path.rs
index 89abed1547a6d..5a116c3608eb7 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 {
diff --git a/crates/bevy_audio/Cargo.toml b/crates/bevy_audio/Cargo.toml
index 5dac2083c43b5..b4517d9ef829b 100644
--- a/crates/bevy_audio/Cargo.toml
+++ b/crates/bevy_audio/Cargo.toml
@@ -17,7 +17,7 @@ keywords = ["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_reflect = { path = "../bevy_reflect", version = "0.3.0", features = ["bevy"] }
 bevy_utils = { path = "../bevy_utils", version = "0.3.0" }
 
 # other
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_core/Cargo.toml b/crates/bevy_core/Cargo.toml
index 57d677473a418..2e419c07a4d8b 100644
--- a/crates/bevy_core/Cargo.toml
+++ b/crates/bevy_core/Cargo.toml
@@ -17,8 +17,7 @@ keywords = ["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_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_reflect = { path = "../bevy_reflect", version = "0.3.0", features = ["bevy"] }
 bevy_tasks = { path = "../bevy_tasks", version = "0.3.0" }
+bevy_utils = { path = "../bevy_utils", version = "0.3.0" }
diff --git a/crates/bevy_core/src/label.rs b/crates/bevy_core/src/label.rs
index e01aa170a536d..ebcceb490bc1e 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;
 use bevy_utils::{HashMap, HashSet};
 use std::{
     borrow::Cow,
@@ -8,7 +8,7 @@ use std::{
 };
 
 /// A collection of labels
-#[derive(Default, Properties)]
+#[derive(Default, Reflect)]
 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 03edeef476a94..01339438be2f2 100644
--- a/crates/bevy_core/src/lib.rs
+++ b/crates/bevy_core/src/lib.rs
@@ -4,6 +4,9 @@ mod label;
 mod task_pool_options;
 mod time;
 
+use std::ops::Range;
+
+use bevy_reflect::RegisterTypeBuilder;
 pub use bytes::*;
 pub use float_ord::*;
 pub use label::*;
@@ -15,8 +18,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,13 +33,9 @@ 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>>()
+            .register_type::<Option<String>>()
+            .register_type::<Range<f32>>()
+            .register_type::<Timer>()
             .add_system_to_stage(stage::FIRST, time_system)
             .add_system_to_stage(stage::PRE_UPDATE, entity_labels_system);
     }
diff --git a/crates/bevy_core/src/time/timer.rs b/crates/bevy_core/src/time/timer.rs
index b3f3fdd33edc6..318531b286247 100644
--- a/crates/bevy_core/src/time/timer.rs
+++ b/crates/bevy_core/src/time/timer.rs
@@ -1,4 +1,4 @@
-use bevy_property::Properties;
+use bevy_reflect::{Reflect, ReflectComponent};
 use bevy_utils::Duration;
 
 /// Tracks elapsed time. Enters the finished state once `duration` is reached.
@@ -7,7 +7,8 @@ use bevy_utils::Duration;
 /// 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.
 ///
 /// Paused timers will not have elapsed time increased.
-#[derive(Clone, Debug, Default, Properties)]
+#[derive(Clone, Debug, Default, Reflect)]
+#[reflect(Component)]
 pub struct Timer {
     elapsed: f32,
     duration: f32,
diff --git a/crates/bevy_derive/Cargo.toml b/crates/bevy_derive/Cargo.toml
index 70410888aab81..f8f7aa4ee802b 100644
--- a/crates/bevy_derive/Cargo.toml
+++ b/crates/bevy_derive/Cargo.toml
@@ -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/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_diagnostic/Cargo.toml b/crates/bevy_diagnostic/Cargo.toml
index 93b6c7e0e57d4..50f01f3dd12f9 100644
--- a/crates/bevy_diagnostic/Cargo.toml
+++ b/crates/bevy_diagnostic/Cargo.toml
@@ -21,5 +21,4 @@ bevy_ecs = { path = "../bevy_ecs", version = "0.3.0" }
 bevy_utils = { path = "../bevy_utils", version = "0.3.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_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_gltf/Cargo.toml b/crates/bevy_gltf/Cargo.toml
index 65f7f9563a8bd..9b6f6a9a06d02 100644
--- a/crates/bevy_gltf/Cargo.toml
+++ b/crates/bevy_gltf/Cargo.toml
@@ -18,11 +18,11 @@ 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_reflect = { path = "../bevy_reflect", version = "0.3.0", features = ["bevy"] }
 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" }
 
 # other
 gltf = { version = "0.15.2", default-features = false, features = ["utils"] }
diff --git a/crates/bevy_internal/Cargo.toml b/crates/bevy_internal/Cargo.toml
index 41bc4ffdbab47..4475b06e80eff 100644
--- a/crates/bevy_internal/Cargo.toml
+++ b/crates/bevy_internal/Cargo.toml
@@ -38,7 +38,6 @@ x11 = ["bevy_winit/x11"]
 # 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" }
@@ -46,7 +45,7 @@ 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_reflect = { path = "../bevy_reflect", version = "0.3.0", features = ["bevy"] }
 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" }
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_math/Cargo.toml b/crates/bevy_math/Cargo.toml
index 22870fc6677f7..8534d5b5cb92a 100644
--- a/crates/bevy_math/Cargo.toml
+++ b/crates/bevy_math/Cargo.toml
@@ -14,3 +14,4 @@ keywords = ["bevy"]
 
 [dependencies]
 glam = { version = "0.10.0", features = ["serde"] }
+bevy_reflect = { path = "../bevy_reflect", version = "0.3.0", features = ["bevy"] }
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..419bb8fe4a069 100644
--- a/crates/bevy_pbr/Cargo.toml
+++ b/crates/bevy_pbr/Cargo.toml
@@ -19,8 +19,7 @@ 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_reflect = { path = "../bevy_reflect", version = "0.3.0", features = ["bevy"] }
 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" }
diff --git a/crates/bevy_pbr/src/lib.rs b/crates/bevy_pbr/src/lib.rs
index bf9577efce75f..c5aa76be1261b 100644
--- a/crates/bevy_pbr/src/lib.rs
+++ b/crates/bevy_pbr/src/lib.rs
@@ -14,9 +14,8 @@ pub mod prelude {
 
 use bevy_app::prelude::*;
 use bevy_asset::{AddAsset, Assets, Handle};
+use bevy_reflect::RegisterTypeBuilder;
 use bevy_render::{prelude::Color, render_graph::RenderGraph, shader};
-use bevy_type_registry::RegisterType;
-use light::Light;
 use material::StandardMaterial;
 use render_graph::add_pbr_graph;
 
@@ -27,7 +26,7 @@ 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>,
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/mod.rs b/crates/bevy_pbr/src/render_graph/forward_pipeline/mod.rs
index e87425ecb5f83..b8dbd80204bb0 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_reflect::TypeUuid;
 use bevy_render::{
     pipeline::{
         BlendDescriptor, BlendFactor, BlendOperation, ColorStateDescriptor, ColorWrite,
@@ -8,7 +9,6 @@ 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);
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..60e7dc512b8a6
--- /dev/null
+++ b/crates/bevy_reflect/Cargo.toml
@@ -0,0 +1,36 @@
+[package]
+name = "bevy_reflect"
+version = "0.3.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.3.0" }
+bevy_utils = { path = "../bevy_utils", version = "0.3.0" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.3.0", optional = true }
+bevy_app = { path = "../bevy_app", version = "0.3.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.10.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..30eea5ea19606
--- /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.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)
\ No newline at end of file
diff --git a/crates/bevy_property/bevy_property_derive/Cargo.toml b/crates/bevy_reflect/bevy_reflect_derive/Cargo.toml
similarity index 73%
rename from crates/bevy_property/bevy_property_derive/Cargo.toml
rename to crates/bevy_reflect/bevy_reflect_derive/Cargo.toml
index 0468aea134eca..26110df1a66af 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"
+name = "bevy_reflect_derive"
 version = "0.3.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"
@@ -20,3 +20,4 @@ syn = "1.0"
 proc-macro2 = "1.0"
 quote = "1.0"
 find-crate = "0.5"
+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..cf6655453ff99
--- /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.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 hash(&self) -> Option<u64> {
+                #hash_fn
+            }
+
+            fn 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.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 hash(&self) -> Option<u64> {
+                #hash_fn
+            }
+
+            fn 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 hash(&self) -> Option<u64> {
+                #hash_fn
+            }
+
+            fn 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 {
+    hash: TraitImpl,
+    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.partial_eq = TraitImpl::Implemented,
+                                "Hash" => attrs.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.partial_eq =
+                                                        TraitImpl::Custom(segment.ident.clone())
+                                                }
+                                                "Hash" => {
+                                                    attrs.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.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.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 90%
rename from crates/bevy_derive/src/type_uuid.rs
rename to crates/bevy_reflect/bevy_reflect_derive/src/type_uuid.rs
index 9078ff3be1353..b8389e2854cb9 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;
@@ -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 ),*
             ]);
         }
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..abe11706098d8
--- /dev/null
+++ b/crates/bevy_reflect/src/impls/bevy_ecs.rs
@@ -0,0 +1,217 @@
+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 mut component in &mut world.query_mut::<&mut C>() {
+                    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..0aa938e2a3956
--- /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 hash(&self) -> Option<u64> {
+        None
+    }
+
+    fn 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..c4a62b11960c1
--- /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 hash(&self) -> Option<u64> {
+        None
+    }
+
+    fn 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 hash(&self) -> Option<u64> {
+        None
+    }
+
+    fn 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..f75ad00fd5712
--- /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.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..936cd6704489e
--- /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 hash(&self) -> Option<u64> {
+        None
+    }
+
+    fn 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.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..1931b13ae1119
--- /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.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.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.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 hash(&self) -> Option<u64> {
+        None
+    }
+
+    fn 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.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..7d76fc7f8d094
--- /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..cb09703bb6f01
--- /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 hash(&self) -> Option<u64>;
+    /// Returns a "partial equal" comparison result if comparison is supported. Otherwise `None` will be returned.
+    fn 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..9d38838dcccc7
--- /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 hash(&self) -> Option<u64> {
+        None
+    }
+
+    fn 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.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..4b2c338ab8f6a
--- /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 hash(&self) -> Option<u64> {
+        None
+    }
+
+    fn 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.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 5b5beb28af844..1cd40a8e94406 100644
--- a/crates/bevy_render/Cargo.toml
+++ b/crates/bevy_render/Cargo.toml
@@ -20,9 +20,8 @@ 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_reflect = { path = "../bevy_reflect", version = "0.3.0", features = ["bevy"] }
 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" }
 
@@ -30,7 +29,6 @@ bevy_utils = { path = "../bevy_utils", version = "0.3.0" }
 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"
diff --git a/crates/bevy_render/src/camera/camera.rs b/crates/bevy_render/src/camera/camera.rs
index becec6b88cc3f..0818b18d40c1e 100644
--- a/crates/bevy_render/src/camera/camera.rs
+++ b/crates/bevy_render/src/camera/camera.rs
@@ -2,16 +2,16 @@ 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;
 use bevy_window::{WindowCreated, WindowId, WindowResized, Windows};
 
-#[derive(Default, Debug, Properties)]
+#[derive(Default, Debug, Reflect)]
 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,
 }
 
diff --git a/crates/bevy_render/src/camera/projection.rs b/crates/bevy_render/src/camera/projection.rs
index f560045217675..22996001eb75d 100644
--- a/crates/bevy_render/src/camera/projection.rs
+++ b/crates/bevy_render/src/camera/projection.rs
@@ -1,6 +1,6 @@
 use super::DepthCalculation;
 use bevy_math::Mat4;
-use bevy_property::{Properties, Property};
+use bevy_reflect::{Reflect, ReflectDeserialize};
 use serde::{Deserialize, Serialize};
 
 pub trait CameraProjection {
@@ -9,7 +9,7 @@ pub trait CameraProjection {
     fn depth_calculation(&self) -> DepthCalculation;
 }
 
-#[derive(Debug, Clone, Properties)]
+#[derive(Debug, Clone, Reflect)]
 pub struct PerspectiveProjection {
     pub fov: f32,
     pub aspect_ratio: f32,
@@ -43,13 +43,14 @@ 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)]
 pub struct OrthographicProjection {
     pub left: f32,
     pub right: f32,
diff --git a/crates/bevy_render/src/camera/visible_entities.rs b/crates/bevy_render/src/camera/visible_entities.rs
index 7a79e469bb1d8..2daf62a29ba50 100644
--- a/crates/bevy_render/src/camera/visible_entities.rs
+++ b/crates/bevy_render/src/camera/visible_entities.rs
@@ -2,7 +2,7 @@ use super::{Camera, DepthCalculation};
 use crate::Draw;
 use bevy_core::FloatOrd;
 use bevy_ecs::{Entity, Query, With};
-use bevy_property::Properties;
+use bevy_reflect::Reflect;
 use bevy_transform::prelude::GlobalTransform;
 
 #[derive(Debug)]
@@ -11,9 +11,9 @@ pub struct VisibleEntity {
     pub order: FloatOrd,
 }
 
-#[derive(Default, Debug, Properties)]
+#[derive(Default, Debug, Reflect)]
 pub struct VisibleEntities {
-    #[property(ignore)]
+    #[reflect(ignore)]
     pub value: Vec<VisibleEntity>,
 }
 
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..ea489e175e13b 100644
--- a/crates/bevy_render/src/draw.rs
+++ b/crates/bevy_render/src/draw.rs
@@ -8,7 +8,7 @@ use crate::{
 };
 use bevy_asset::{Assets, Handle};
 use bevy_ecs::{Query, Res, ResMut, SystemParam};
-use bevy_property::Properties;
+use bevy_reflect::Reflect;
 use std::{ops::Range, sync::Arc};
 use thiserror::Error;
 
@@ -44,11 +44,11 @@ pub enum RenderCommand {
 }
 
 /// A component that indicates how to draw an entity.
-#[derive(Debug, Properties, Clone)]
+#[derive(Debug, Clone, Reflect)]
 pub struct Draw {
     pub is_visible: bool,
     pub is_transparent: bool,
-    #[property(ignore)]
+    #[reflect(ignore)]
     pub render_commands: Vec<RenderCommand>,
 }
 
diff --git a/crates/bevy_render/src/lib.rs b/crates/bevy_render/src/lib.rs
index fc3937ef448cc..f9785435dd7ba 100644
--- a/crates/bevy_render/src/lib.rs
+++ b/crates/bevy_render/src/lib.rs
@@ -11,7 +11,7 @@ pub mod renderer;
 pub mod shader;
 pub mod texture;
 
-use bevy_type_registry::RegisterType;
+use bevy_reflect::RegisterTypeBuilder;
 pub use once_cell;
 
 pub mod prelude {
@@ -29,7 +29,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 +40,10 @@ use pipeline::{
     ShaderSpecialization,
 };
 use render_graph::{
-    base::{self, BaseRenderGraphBuilder, BaseRenderGraphConfig},
+    base::{self, BaseRenderGraphBuilder, BaseRenderGraphConfig, MainPass},
     RenderGraph,
 };
 use renderer::{AssetRenderResourceBindings, RenderResourceBindings};
-use std::ops::Range;
 #[cfg(feature = "hdr")]
 use texture::HdrTextureLoader;
 #[cfg(feature = "png")]
@@ -101,19 +100,18 @@ impl Plugin for RenderPlugin {
             .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>()
+            .register_type::<Camera>()
+            .register_type::<Draw>()
+            .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>()
diff --git a/crates/bevy_render/src/mesh/mesh.rs b/crates/bevy_render/src/mesh/mesh.rs
index ceb001bffc053..96278eade50f6 100644
--- a/crates/bevy_render/src/mesh/mesh.rs
+++ b/crates/bevy_render/src/mesh/mesh.rs
@@ -7,7 +7,7 @@ use bevy_asset::{AssetEvent, Assets, Handle};
 use bevy_core::AsBytes;
 use bevy_ecs::{Local, Query, Res};
 use bevy_math::*;
-use bevy_type_registry::TypeUuid;
+use bevy_reflect::TypeUuid;
 use std::borrow::Cow;
 
 use crate::pipeline::{InputStepMode, VertexAttributeDescriptor, VertexBufferDescriptor};
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..cc5009013b618 100644
--- a/crates/bevy_render/src/pipeline/pipeline_compiler.rs
+++ b/crates/bevy_render/src/pipeline/pipeline_compiler.rs
@@ -5,12 +5,12 @@ use crate::{
     shader::{Shader, 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,
@@ -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>,
 }
diff --git a/crates/bevy_render/src/pipeline/render_pipelines.rs b/crates/bevy_render/src/pipeline/render_pipelines.rs
index 6fa8871060216..1617b790d9d89 100644
--- a/crates/bevy_render/src/pipeline/render_pipelines.rs
+++ b/crates/bevy_render/src/pipeline/render_pipelines.rs
@@ -7,10 +7,9 @@ use crate::{
 };
 use bevy_asset::{Assets, Handle};
 use bevy_ecs::{Query, Res, ResMut};
-use bevy_property::Properties;
+use bevy_reflect::Reflect;
 
-#[derive(Debug, Properties, Default, Clone)]
-#[non_exhaustive]
+#[derive(Debug, Default, Clone, Reflect)]
 pub struct RenderPipeline {
     pub pipeline: Handle<PipelineDescriptor>,
     pub specialization: PipelineSpecialization,
@@ -39,10 +38,10 @@ impl RenderPipeline {
     }
 }
 
-#[derive(Debug, Properties, Clone)]
+#[derive(Debug, Clone, Reflect)]
 pub struct RenderPipelines {
     pub pipelines: Vec<RenderPipeline>,
-    #[property(ignore)]
+    #[reflect(ignore)]
     pub bindings: RenderResourceBindings,
 }
 
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..e112181ca8ad3 100644
--- a/crates/bevy_render/src/render_graph/base.rs
+++ b/crates/bevy_render/src/render_graph/base.rs
@@ -10,11 +10,11 @@ use crate::{
     texture::{Extent3d, TextureDescriptor, TextureDimension, TextureFormat, TextureUsage},
     Color,
 };
-use bevy_property::Properties;
+use bevy_reflect::Reflect;
 use bevy_window::WindowId;
 
 /// A component that indicates that an entity should be drawn in the "main pass"
-#[derive(Default, Properties)]
+#[derive(Default, Reflect)]
 pub struct MainPass;
 
 #[derive(Debug)]
diff --git a/crates/bevy_render/src/render_graph/node.rs b/crates/bevy_render/src/render_graph/node.rs
index 3cf3aa13a6a6d..66eaa8f6db545 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);
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/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/shader/shader.rs b/crates/bevy_render/src/shader/shader.rs
index 14e575f670366..dc42acceb3991 100644
--- a/crates/bevy_render/src/shader/shader.rs
+++ b/crates/bevy_render/src/shader/shader.rs
@@ -1,6 +1,6 @@
 use super::ShaderLayout;
 use bevy_asset::Handle;
-use bevy_type_registry::TypeUuid;
+use bevy_reflect::TypeUuid;
 use std::marker::Copy;
 
 /// The stage of a shader
diff --git a/crates/bevy_render/src/texture/texture.rs b/crates/bevy_render/src/texture/texture.rs
index ed7eda398fdea..b279abadc890f 100644
--- a/crates/bevy_render/src/texture/texture.rs
+++ b/crates/bevy_render/src/texture/texture.rs
@@ -5,7 +5,7 @@ use crate::renderer::{
 use bevy_app::prelude::{EventReader, Events};
 use bevy_asset::{AssetEvent, Assets, Handle};
 use bevy_ecs::{Res, ResMut};
-use bevy_type_registry::TypeUuid;
+use bevy_reflect::TypeUuid;
 use bevy_utils::HashSet;
 
 pub const TEXTURE_ASSET_INDEX: u64 = 0;
diff --git a/crates/bevy_scene/Cargo.toml b/crates/bevy_scene/Cargo.toml
index 855a9b13e9bd4..293c392551d51 100644
--- a/crates/bevy_scene/Cargo.toml
+++ b/crates/bevy_scene/Cargo.toml
@@ -17,8 +17,7 @@ keywords = ["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_reflect = { path = "../bevy_reflect", version = "0.3.0", features = ["bevy"] }
 bevy_utils = { path = "../bevy_utils", version = "0.3.0" }
 
 # other
diff --git a/crates/bevy_scene/src/dynamic_scene.rs b/crates/bevy_scene/src/dynamic_scene.rs
index f8ed4bbb0d55a..81c8bc169653a 100644
--- a/crates/bevy_scene/src/dynamic_scene.rs
+++ b/crates/bevy_scene/src/dynamic_scene.rs
@@ -1,8 +1,7 @@
 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;
 
@@ -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/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..1052854b4d3cc 100644
--- a/crates/bevy_scene/src/scene_spawner.rs
+++ b/crates/bevy_scene/src/scene_spawner.rs
@@ -2,7 +2,7 @@ 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_reflect::{ReflectComponent, ReflectMapEntities, TypeRegistryArc};
 use bevy_utils::HashMap;
 use thiserror::Error;
 use uuid::Uuid;
@@ -100,8 +100,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 +116,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::UnregisteredComponent {
+                        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);
                 }
             }
         }
@@ -144,8 +149,8 @@ impl SceneSpawner {
         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 +166,26 @@ 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,
-                        );
+                    if let Some(registration) = type_registry.get(type_info.id()) {
+                        if let Some(component_reflect) = registration.data::<ReflectComponent>() {
+                            component_reflect.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
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..850ca0d41c5b6 100644
--- a/crates/bevy_sprite/Cargo.toml
+++ b/crates/bevy_sprite/Cargo.toml
@@ -19,12 +19,13 @@ 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_reflect = { path = "../bevy_reflect", version = "0.3.0", features = ["bevy"] }
 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" }
 
 # other
 rectangle-pack = "0.2"
 thiserror = "1.0"
 guillotiere = "0.6.0"
+serde = { version = "1", features = ["derive"] }
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/lib.rs b/crates/bevy_sprite/src/lib.rs
index 2bad06938efb0..ad7cb32df6198 100644
--- a/crates/bevy_sprite/src/lib.rs
+++ b/crates/bevy_sprite/src/lib.rs
@@ -27,12 +27,12 @@ pub mod prelude {
 use bevy_app::prelude::*;
 use bevy_asset::{AddAsset, Assets, Handle};
 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)]
@@ -44,6 +44,7 @@ impl Plugin for SpritePlugin {
     fn build(&self, app: &mut AppBuilder) {
         app.add_asset::<ColorMaterial>()
             .add_asset::<TextureAtlas>()
+            .register_type::<Sprite>()
             .add_system_to_stage(stage::POST_UPDATE, sprite_system)
             .add_system_to_stage(
                 stage::POST_UPDATE,
diff --git a/crates/bevy_sprite/src/render/mod.rs b/crates/bevy_sprite/src/render/mod.rs
index c4cd96a5d3dad..1e248923500a2 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_ecs::Resources;
+use bevy_reflect::TypeUuid;
 use bevy_render::{
     pipeline::{
         BlendDescriptor, BlendFactor, BlendOperation, ColorStateDescriptor, ColorWrite,
@@ -11,7 +12,6 @@ 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);
diff --git a/crates/bevy_sprite/src/sprite.rs b/crates/bevy_sprite/src/sprite.rs
index 772ee4c3354a3..7d63c1a5ca0c3 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,
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_text/Cargo.toml b/crates/bevy_text/Cargo.toml
index e222578241872..588e913c85608 100644
--- a/crates/bevy_text/Cargo.toml
+++ b/crates/bevy_text/Cargo.toml
@@ -19,9 +19,9 @@ 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_reflect = { path = "../bevy_reflect", version = "0.3.0", features = ["bevy"] }
 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" }
 
 # other
diff --git a/crates/bevy_text/src/font.rs b/crates/bevy_text/src/font.rs
index c50c695aa4637..a9400632b634c 100644
--- a/crates/bevy_text/src/font.rs
+++ b/crates/bevy_text/src/font.rs
@@ -1,9 +1,9 @@
 use ab_glyph::{FontArc, FontVec, InvalidFont, OutlinedGlyph};
+use bevy_reflect::TypeUuid;
 use bevy_render::{
     color::Color,
     texture::{Extent3d, Texture, TextureDimension, TextureFormat},
 };
-use bevy_type_registry::TypeUuid;
 
 #[derive(Debug, TypeUuid)]
 #[uuid = "97059ac6-c9ba-4da9-95b6-bed82c3ce198"]
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_transform/Cargo.toml b/crates/bevy_transform/Cargo.toml
index eddd4e69f8ac3..cb0a4aced386c 100644
--- a/crates/bevy_transform/Cargo.toml
+++ b/crates/bevy_transform/Cargo.toml
@@ -17,8 +17,7 @@ keywords = ["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_reflect = { path = "../bevy_reflect", version = "0.3.0", features = ["bevy"] }
 bevy_utils = { path = "../bevy_utils", version = "0.3.0" }
 
 # other
diff --git a/crates/bevy_transform/src/components/children.rs b/crates/bevy_transform/src/components/children.rs
index e4205c9ebeaae..80c4c85f14531 100644
--- a/crates/bevy_transform/src/components/children.rs
+++ b/crates/bevy_transform/src/components/children.rs
@@ -1,9 +1,10 @@
 use bevy_ecs::{Entity, MapEntities};
-use bevy_property::Properties;
+use bevy_reflect::{Reflect, ReflectMapEntities};
 use smallvec::SmallVec;
 use std::ops::Deref;
 
-#[derive(Default, Clone, Properties, Debug)]
+#[derive(Default, Clone, Debug, Reflect)]
+#[reflect(MapEntities)]
 pub struct Children(pub(crate) SmallVec<[Entity; 8]>);
 
 impl MapEntities for Children {
diff --git a/crates/bevy_transform/src/components/global_transform.rs b/crates/bevy_transform/src/components/global_transform.rs
index 4292372081e7c..f900192b2b43d 100644
--- a/crates/bevy_transform/src/components/global_transform.rs
+++ b/crates/bevy_transform/src/components/global_transform.rs
@@ -1,10 +1,9 @@
+use super::Transform;
 use bevy_math::{Mat3, Mat4, Quat, Vec3};
-use bevy_property::Properties;
+use bevy_reflect::Reflect;
 use std::ops::Mul;
 
-use super::Transform;
-
-#[derive(Debug, PartialEq, Clone, Copy, Properties)]
+#[derive(Debug, PartialEq, Clone, Copy, Reflect)]
 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 9eddcdaff94f5..698e804fa0a10 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, ReflectMapEntities};
 use std::ops::{Deref, DerefMut};
 
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Properties)]
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Reflect)]
+#[reflect(MapEntities)]
 pub struct Parent(pub Entity);
 
 // TODO: We need to impl either FromResources or Default so Parent can be registered as Properties.
@@ -39,7 +40,8 @@ impl DerefMut for Parent {
     }
 }
 
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Properties)]
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Reflect)]
+#[reflect(MapEntities)]
 pub struct PreviousParent(pub(crate) Entity);
 
 impl MapEntities for PreviousParent {
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/lib.rs b/crates/bevy_transform/src/lib.rs
index eece2199a1e4a..2e08097944b7d 100644
--- a/crates/bevy_transform/src/lib.rs
+++ b/crates/bevy_transform/src/lib.rs
@@ -7,7 +7,7 @@ pub mod prelude {
 }
 
 use bevy_app::prelude::*;
-use bevy_type_registry::RegisterType;
+use bevy_reflect::RegisterTypeBuilder;
 use prelude::{parent_update_system, Children, GlobalTransform, Parent, PreviousParent, Transform};
 
 #[derive(Default)]
@@ -15,11 +15,11 @@ 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_with::<PreviousParent>(|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)
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 16833f4a044ca..0000000000000
--- a/crates/bevy_type_registry/src/type_registry.rs
+++ /dev/null
@@ -1,336 +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()
-        }
-    }
-
-    // NOTE: this code will be removed soon, so we're just suppressing the new clippy lint
-    #[allow(clippy::clippy::unnecessary_wraps)]
-    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..e59ea6cc786ba 100644
--- a/crates/bevy_ui/Cargo.toml
+++ b/crates/bevy_ui/Cargo.toml
@@ -21,13 +21,14 @@ 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_reflect = { path = "../bevy_reflect", version = "0.3.0", features = ["bevy"] }
 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" }
 
 # other
 stretch = "0.3"
+serde = {version = "1", features = ["derive"]}
diff --git a/crates/bevy_ui/src/flex/convert.rs b/crates/bevy_ui/src/flex/convert.rs
index 30de4499983db..c19ce3e3deef8 100644
--- a/crates/bevy_ui/src/flex/convert.rs
+++ b/crates/bevy_ui/src/flex/convert.rs
@@ -3,8 +3,9 @@ use crate::{
     JustifyContent, PositionType, Style, Val,
 };
 use bevy_math::{Rect, Size};
+use bevy_reflect::Reflect;
 
-fn from_rect<T, U>(rect: Rect<U>) -> stretch::geometry::Rect<T>
+fn from_rect<T, U: Reflect>(rect: Rect<U>) -> stretch::geometry::Rect<T>
 where
     T: From<U>,
 {
@@ -19,6 +20,7 @@ where
 
 fn from_size<T, U>(size: Size<U>) -> stretch::geometry::Size<T>
 where
+    U: Reflect,
     T: From<U>,
 {
     stretch::geometry::Size {
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..991f914574e9f 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_ecs::Resources;
+use bevy_reflect::TypeUuid;
 use bevy_render::{
     camera::ActiveCameras,
     pass::{
@@ -16,7 +17,6 @@ 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);
diff --git a/crates/bevy_utils/Cargo.toml b/crates/bevy_utils/Cargo.toml
index 843b487a4e1b9..c00084cdfbb0f 100644
--- a/crates/bevy_utils/Cargo.toml
+++ b/crates/bevy_utils/Cargo.toml
@@ -16,6 +16,8 @@ keywords = ["bevy"]
 ahash = "0.5.3"
 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_window/Cargo.toml b/crates/bevy_window/Cargo.toml
index cb211b1bb4c39..e4c41430dfeff 100644
--- a/crates/bevy_window/Cargo.toml
+++ b/crates/bevy_window/Cargo.toml
@@ -20,8 +20,6 @@ bevy_math = { path = "../bevy_math", version = "0.3.0" }
 bevy_utils = { path = "../bevy_utils", version = "0.3.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/window.rs b/crates/bevy_window/src/window.rs
index 8ff34df074d9b..387f320cbfe9d 100644
--- a/crates/bevy_window/src/window.rs
+++ b/crates/bevy_window/src/window.rs
@@ -1,4 +1,4 @@
-use uuid::Uuid;
+use bevy_utils::Uuid;
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
 pub struct WindowId(Uuid);
diff --git a/examples/asset/custom_asset.rs b/examples/asset/custom_asset.rs
index c28c5f6bc8016..e6527ad1222b9 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;
diff --git a/examples/reflection/generic_reflection.rs b/examples/reflection/generic_reflection.rs
new file mode 100644
index 0000000000000..fecb60aa01600
--- /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)
+        .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..98d0b1e36d2b7
--- /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)
+        .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. 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.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..bbdfb8cba84bb
--- /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)
+        .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..f7d7a1c985f7a
--- /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)
+        .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..8a7f709e73923 100644
--- a/examples/scene/scene.rs
+++ b/examples/scene/scene.rs
@@ -1,16 +1,11 @@
-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>()
+        .register_type::<ComponentA>()
+        .register_type::<ComponentB>()
         .add_startup_system(save_scene_system)
         .add_startup_system(load_scene_system)
         .add_startup_system(infotext_system)
@@ -18,25 +13,27 @@ fn main() {
         .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,18 +81,16 @@ 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
 }
diff --git a/examples/shader/array_texture.rs b/examples/shader/array_texture.rs
index 2285fb7ea2d97..5f4e4499455ae 100644
--- a/examples/shader/array_texture.rs
+++ b/examples/shader/array_texture.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 texture for use with a texture2DArray shader uniform variable.
diff --git a/examples/shader/mesh_custom_attribute.rs b/examples/shader/mesh_custom_attribute.rs
index 98ea547636459..05020216e3ffa 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.
diff --git a/examples/shader/shader_custom_material.rs b/examples/shader/shader_custom_material.rs
index ddaae959ac848..949a1d55c59f1 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
diff --git a/examples/shader/shader_defs.rs b/examples/shader/shader_defs.rs
index f3426160513bd..0c920069c7b18 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.
diff --git a/examples/wasm/assets_wasm.rs b/examples/wasm/assets_wasm.rs
index 6f9fbac34c625..ec4649be80313 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,
 };
 
diff --git a/tools/publish.sh b/tools/publish.sh
index 133ef1375fea9..2d5a7452ed464 100644
--- a/tools/publish.sh
+++ b/tools/publish.sh
@@ -9,9 +9,8 @@ crates=(
     bevy_ecs
     bevy_app
     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