diff --git a/Cargo.toml b/Cargo.toml
index 7dc0d8d6e5..6b5267be70 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -13,14 +13,18 @@ repository = "https://github.com/bevyengine/bevy"
 
 [workspace]
 exclude = ["benches", "crates/bevy_ecs_compile_fail_tests"]
-members = ["crates/*", "examples/ios", "tools/ci", "errors"]
+members = ["crates/*", "pipelined/*", "examples/ios", "tools/ci", "errors"]
 
 [features]
 default = [
   "bevy_audio",
+  "bevy_core_pipeline",
   "bevy_gilrs",
-  "bevy_gltf",
+  "bevy_gltf2",
   "bevy_wgpu",
+  "bevy_sprite2",
+  "bevy_render2",
+  "bevy_pbr2",
   "bevy_winit",
   "render",
   "png",
@@ -50,6 +54,12 @@ bevy_gltf = ["bevy_internal/bevy_gltf"]
 bevy_wgpu = ["bevy_internal/bevy_wgpu"]
 bevy_winit = ["bevy_internal/bevy_winit"]
 
+bevy_core_pipeline = ["bevy_internal/bevy_core_pipeline"]
+bevy_render2 = ["bevy_internal/bevy_render2"]
+bevy_sprite2 = ["bevy_internal/bevy_sprite2"]
+bevy_pbr2 = ["bevy_internal/bevy_pbr2"]
+bevy_gltf2 = ["bevy_internal/bevy_gltf2"]
+
 trace_chrome = ["bevy_internal/trace_chrome"]
 trace_tracy = ["bevy_internal/trace_tracy"]
 trace = ["bevy_internal/trace"]
@@ -95,6 +105,7 @@ ron = "0.6.2"
 serde = { version = "1", features = ["derive"] }
 # Needed to poll Task examples
 futures-lite = "1.11.3"
+crevice = { path = "crates/crevice", version = "0.8.0", features = ["glam"] }
 
 [[example]]
 name = "hello_world"
@@ -133,23 +144,51 @@ path = "examples/2d/text2d.rs"
 name = "texture_atlas"
 path = "examples/2d/texture_atlas.rs"
 
+[[example]]
+name = "pipelined_texture_atlas"
+path = "examples/2d/pipelined_texture_atlas.rs"
+
 # 3D Rendering
 [[example]]
 name = "3d_scene"
 path = "examples/3d/3d_scene.rs"
 
+[[example]]
+name = "3d_scene_pipelined"
+path = "examples/3d/3d_scene_pipelined.rs"
+
+[[example]]
+name = "many_cubes_pipelined"
+path = "examples/3d/many_cubes_pipelined.rs"
+
+[[example]]
+name = "cornell_box_pipelined"
+path = "examples/3d/cornell_box_pipelined.rs"
+
 [[example]]
 name = "load_gltf"
 path = "examples/3d/load_gltf.rs"
 
+[[example]]
+name = "load_gltf_pipelined"
+path = "examples/3d/load_gltf_pipelined.rs"
+
 [[example]]
 name = "msaa"
 path = "examples/3d/msaa.rs"
 
+[[example]]
+name = "msaa_pipelined"
+path = "examples/3d/msaa_pipelined.rs"
+
 [[example]]
 name = "orthographic"
 path = "examples/3d/orthographic.rs"
 
+[[example]]
+name = "orthographic_pipelined"
+path = "examples/3d/orthographic_pipelined.rs"
+
 [[example]]
 name = "parenting"
 path = "examples/3d/parenting.rs"
@@ -158,10 +197,22 @@ path = "examples/3d/parenting.rs"
 name = "pbr"
 path = "examples/3d/pbr.rs"
 
+[[example]]
+name = "pbr_pipelined"
+path = "examples/3d/pbr_pipelined.rs"
+
 [[example]]
 name = "render_to_texture"
 path = "examples/3d/render_to_texture.rs"
 
+[[example]]
+name = "shadow_biases_pipelined"
+path = "examples/3d/shadow_biases_pipelined.rs"
+
+[[example]]
+name = "shadow_caster_receiver_pipelined"
+path = "examples/3d/shadow_caster_receiver_pipelined.rs"
+
 [[example]]
 name = "spawner"
 path = "examples/3d/spawner.rs"
@@ -170,6 +221,10 @@ path = "examples/3d/spawner.rs"
 name = "texture"
 path = "examples/3d/texture.rs"
 
+[[example]]
+name = "texture_pipelined"
+path = "examples/3d/texture_pipelined.rs"
+
 [[example]]
 name = "update_gltf_scene"
 path = "examples/3d/update_gltf_scene.rs"
@@ -413,11 +468,23 @@ path = "examples/shader/shader_custom_material.rs"
 name = "shader_defs"
 path = "examples/shader/shader_defs.rs"
 
+[[example]]
+name = "custom_shader_pipelined"
+path = "examples/shader/custom_shader_pipelined.rs"
+
+[[example]]
+name = "shader_defs_pipelined"
+path = "examples/shader/shader_defs_pipelined.rs"
+
 # Tools
 [[example]]
 name = "bevymark"
 path = "examples/tools/bevymark.rs"
 
+[[example]]
+name = "bevymark_pipelined"
+path = "examples/tools/bevymark_pipelined.rs"
+
 # UI (User Interface)
 [[example]]
 name = "button"
@@ -444,6 +511,10 @@ path = "examples/ui/ui.rs"
 name = "clear_color"
 path = "examples/window/clear_color.rs"
 
+[[example]]
+name = "clear_color_pipelined"
+path = "examples/window/clear_color_pipelined.rs"
+
 [[example]]
 name = "multiple_windows"
 path = "examples/window/multiple_windows.rs"
diff --git a/assets/shaders/custom_material.wgsl b/assets/shaders/custom_material.wgsl
new file mode 100644
index 0000000000..9dfaa6f568
--- /dev/null
+++ b/assets/shaders/custom_material.wgsl
@@ -0,0 +1,11 @@
+[[block]]
+struct CustomMaterial {
+    color: vec4<f32>;
+};
+[[group(1), binding(0)]]
+var<uniform> material: CustomMaterial;
+
+[[stage(fragment)]]
+fn fragment() -> [[location(0)]] vec4<f32> {
+    return material.color;
+}
diff --git a/assets/shaders/shader_defs.wgsl b/assets/shaders/shader_defs.wgsl
new file mode 100644
index 0000000000..0d1c93d37e
--- /dev/null
+++ b/assets/shaders/shader_defs.wgsl
@@ -0,0 +1,33 @@
+#import bevy_pbr::mesh_view_bind_group
+#import bevy_pbr::mesh_struct
+
+[[group(1), binding(0)]]
+var<uniform> mesh: Mesh;
+
+struct Vertex {
+    [[location(0)]] position: vec3<f32>;
+    [[location(1)]] normal: vec3<f32>;
+    [[location(2)]] uv: vec2<f32>;
+};
+
+struct VertexOutput {
+    [[builtin(position)]] clip_position: vec4<f32>;
+};
+
+[[stage(vertex)]]
+fn vertex(vertex: Vertex) -> VertexOutput {
+    let world_position = mesh.model * vec4<f32>(vertex.position, 1.0);
+
+    var out: VertexOutput;
+    out.clip_position = view.view_proj * world_position;
+    return out;
+}
+
+[[stage(fragment)]]
+fn fragment() -> [[location(0)]] vec4<f32> {
+    var color = vec4<f32>(0.0, 0.0, 1.0, 1.0);
+# ifdef IS_RED 
+    color = vec4<f32>(1.0, 0.0, 0.0, 1.0);
+# endif
+    return color;
+}
diff --git a/crates/bevy_app/src/app.rs b/crates/bevy_app/src/app.rs
index 4887bb5917..a14baf2ae2 100644
--- a/crates/bevy_app/src/app.rs
+++ b/crates/bevy_app/src/app.rs
@@ -1,4 +1,5 @@
 use crate::{CoreStage, Events, Plugin, PluginGroup, PluginGroupBuilder, StartupStage};
+pub use bevy_derive::AppLabel;
 use bevy_ecs::{
     prelude::{FromWorld, IntoExclusiveSystem},
     schedule::{
@@ -8,12 +9,14 @@ use bevy_ecs::{
     system::Resource,
     world::World,
 };
-use bevy_utils::tracing::debug;
+use bevy_utils::{tracing::debug, HashMap};
 use std::fmt::Debug;
 
 #[cfg(feature = "trace")]
 use bevy_utils::tracing::info_span;
 
+bevy_utils::define_label!(AppLabel);
+
 #[allow(clippy::needless_doctest_main)]
 /// Containers of app logic and data
 ///
@@ -42,6 +45,12 @@ pub struct App {
     pub world: World,
     pub runner: Box<dyn Fn(App)>,
     pub schedule: Schedule,
+    sub_apps: HashMap<Box<dyn AppLabel>, SubApp>,
+}
+
+struct SubApp {
+    app: App,
+    runner: Box<dyn Fn(&mut World, &mut App)>,
 }
 
 impl Default for App {
@@ -73,6 +82,7 @@ impl App {
             world: Default::default(),
             schedule: Default::default(),
             runner: Box::new(run_once),
+            sub_apps: HashMap::default(),
         }
     }
 
@@ -85,6 +95,9 @@ impl App {
         #[cfg(feature = "trace")]
         let _bevy_frame_update_guard = bevy_frame_update_span.enter();
         self.schedule.run(&mut self.world);
+        for sub_app in self.sub_apps.values_mut() {
+            (sub_app.runner)(&mut self.world, &mut sub_app.app);
+        }
     }
 
     /// Starts the application by calling the app's [runner function](Self::set_runner).
@@ -823,6 +836,39 @@ impl App {
         }
         self
     }
+
+    pub fn add_sub_app(
+        &mut self,
+        label: impl AppLabel,
+        app: App,
+        f: impl Fn(&mut World, &mut App) + 'static,
+    ) -> &mut Self {
+        self.sub_apps.insert(
+            Box::new(label),
+            SubApp {
+                app,
+                runner: Box::new(f),
+            },
+        );
+        self
+    }
+
+    /// Retrieves a "sub app" stored inside this [App]. This will panic if the sub app does not exist.
+    pub fn sub_app(&mut self, label: impl AppLabel) -> &mut App {
+        match self.get_sub_app(label) {
+            Ok(app) => app,
+            Err(label) => panic!("Sub-App with label '{:?}' does not exist", label),
+        }
+    }
+
+    /// Retrieves a "sub app" inside this [App] with the given label, if it exists. Otherwise returns
+    /// an [Err] containing the given label.
+    pub fn get_sub_app(&mut self, label: impl AppLabel) -> Result<&mut App, impl AppLabel> {
+        self.sub_apps
+            .get_mut((&label) as &dyn AppLabel)
+            .map(|sub_app| &mut sub_app.app)
+            .ok_or(label)
+    }
 }
 
 fn run_once(mut app: App) {
diff --git a/crates/bevy_app/src/ci_testing.rs b/crates/bevy_app/src/ci_testing.rs
index 5c8bc87960..a61ee728dd 100644
--- a/crates/bevy_app/src/ci_testing.rs
+++ b/crates/bevy_app/src/ci_testing.rs
@@ -22,16 +22,15 @@ fn ci_testing_exit_after(
     *current_frame += 1;
 }
 
-pub(crate) fn setup_app(app_builder: &mut App) -> &mut App {
+pub(crate) fn setup_app(app: &mut App) -> &mut App {
     let filename =
         std::env::var("CI_TESTING_CONFIG").unwrap_or_else(|_| "ci_testing_config.ron".to_string());
     let config: CiTestingConfig = ron::from_str(
         &std::fs::read_to_string(filename).expect("error reading CI testing configuration file"),
     )
     .expect("error deserializing CI testing configuration file");
-    app_builder
-        .insert_resource(config)
+    app.insert_resource(config)
         .add_system(ci_testing_exit_after);
 
-    app_builder
+    app
 }
diff --git a/crates/bevy_asset/src/handle.rs b/crates/bevy_asset/src/handle.rs
index 1a606c1a62..c140f6247e 100644
--- a/crates/bevy_asset/src/handle.rs
+++ b/crates/bevy_asset/src/handle.rs
@@ -96,6 +96,7 @@ impl<T: Asset> Handle<T> {
         }
     }
 
+    #[inline]
     pub fn weak(id: HandleId) -> Self {
         Self {
             id,
@@ -129,6 +130,7 @@ impl<T: Asset> Handle<T> {
         self.handle_type = HandleType::Strong(sender);
     }
 
+    #[inline]
     pub fn clone_weak(&self) -> Self {
         Handle::weak(self.id)
     }
diff --git a/crates/bevy_asset/src/loader.rs b/crates/bevy_asset/src/loader.rs
index 960208c77b..aa12dbddac 100644
--- a/crates/bevy_asset/src/loader.rs
+++ b/crates/bevy_asset/src/loader.rs
@@ -43,13 +43,19 @@ impl<T: Asset> LoadedAsset<T> {
         }
     }
 
-    pub fn with_dependency(mut self, asset_path: AssetPath) -> Self {
+    pub fn add_dependency(&mut self, asset_path: AssetPath) {
         self.dependencies.push(asset_path.to_owned());
+    }
+
+    pub fn with_dependency(mut self, asset_path: AssetPath) -> Self {
+        self.add_dependency(asset_path);
         self
     }
 
-    pub fn with_dependencies(mut self, asset_paths: Vec<AssetPath<'static>>) -> Self {
-        self.dependencies.extend(asset_paths);
+    pub fn with_dependencies(mut self, mut asset_paths: Vec<AssetPath<'static>>) -> Self {
+        for asset_path in asset_paths.drain(..) {
+            self.add_dependency(asset_path);
+        }
         self
     }
 }
diff --git a/crates/bevy_derive/src/lib.rs b/crates/bevy_derive/src/lib.rs
index edbbf6f1ab..9036b1b602 100644
--- a/crates/bevy_derive/src/lib.rs
+++ b/crates/bevy_derive/src/lib.rs
@@ -9,7 +9,9 @@ mod render_resource;
 mod render_resources;
 mod shader_defs;
 
+use bevy_macro_utils::{derive_label, BevyManifest};
 use proc_macro::TokenStream;
+use quote::format_ident;
 
 /// Derives the Bytes trait. Each field must also implements Bytes or this will fail.
 #[proc_macro_derive(Bytes)]
@@ -52,3 +54,11 @@ pub fn bevy_main(attr: TokenStream, item: TokenStream) -> TokenStream {
 pub fn derive_enum_variant_meta(input: TokenStream) -> TokenStream {
     enum_variant_meta::derive_enum_variant_meta(input)
 }
+
+#[proc_macro_derive(AppLabel)]
+pub fn derive_app_label(input: TokenStream) -> TokenStream {
+    let input = syn::parse_macro_input!(input as syn::DeriveInput);
+    let mut trait_path = BevyManifest::default().get_path("bevy_app");
+    trait_path.segments.push(format_ident!("AppLabel").into());
+    derive_label(input, trait_path)
+}
diff --git a/crates/bevy_ecs/macros/src/lib.rs b/crates/bevy_ecs/macros/src/lib.rs
index 5c5df5b7fc..ed6fd79f95 100644
--- a/crates/bevy_ecs/macros/src/lib.rs
+++ b/crates/bevy_ecs/macros/src/lib.rs
@@ -2,16 +2,16 @@ extern crate proc_macro;
 
 mod component;
 
-use bevy_macro_utils::BevyManifest;
+use bevy_macro_utils::{derive_label, BevyManifest};
 use proc_macro::TokenStream;
-use proc_macro2::{Span, TokenStream as TokenStream2};
+use proc_macro2::Span;
 use quote::{format_ident, quote};
 use syn::{
     parse::{Parse, ParseStream},
     parse_macro_input,
     punctuated::Punctuated,
     token::Comma,
-    Data, DataStruct, DeriveInput, Field, Fields, GenericParam, Ident, Index, LitInt, Path, Result,
+    Data, DataStruct, DeriveInput, Field, Fields, GenericParam, Ident, Index, LitInt, Result,
     Token,
 };
 
@@ -429,46 +429,43 @@ pub fn derive_system_param(input: TokenStream) -> TokenStream {
 #[proc_macro_derive(SystemLabel)]
 pub fn derive_system_label(input: TokenStream) -> TokenStream {
     let input = parse_macro_input!(input as DeriveInput);
-
-    derive_label(input, Ident::new("SystemLabel", Span::call_site())).into()
+    let mut trait_path = bevy_ecs_path();
+    trait_path.segments.push(format_ident!("schedule").into());
+    trait_path
+        .segments
+        .push(format_ident!("SystemLabel").into());
+    derive_label(input, trait_path)
 }
 
 #[proc_macro_derive(StageLabel)]
 pub fn derive_stage_label(input: TokenStream) -> TokenStream {
     let input = parse_macro_input!(input as DeriveInput);
-    derive_label(input, Ident::new("StageLabel", Span::call_site())).into()
+    let mut trait_path = bevy_ecs_path();
+    trait_path.segments.push(format_ident!("schedule").into());
+    trait_path.segments.push(format_ident!("StageLabel").into());
+    derive_label(input, trait_path)
 }
 
 #[proc_macro_derive(AmbiguitySetLabel)]
 pub fn derive_ambiguity_set_label(input: TokenStream) -> TokenStream {
     let input = parse_macro_input!(input as DeriveInput);
-    derive_label(input, Ident::new("AmbiguitySetLabel", Span::call_site())).into()
+    let mut trait_path = bevy_ecs_path();
+    trait_path.segments.push(format_ident!("schedule").into());
+    trait_path
+        .segments
+        .push(format_ident!("AmbiguitySetLabel").into());
+    derive_label(input, trait_path)
 }
 
 #[proc_macro_derive(RunCriteriaLabel)]
 pub fn derive_run_criteria_label(input: TokenStream) -> TokenStream {
     let input = parse_macro_input!(input as DeriveInput);
-    derive_label(input, Ident::new("RunCriteriaLabel", Span::call_site())).into()
-}
-
-fn derive_label(input: DeriveInput, label_type: Ident) -> TokenStream2 {
-    let ident = input.ident;
-    let ecs_path: Path = bevy_ecs_path();
-
-    let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
-    let mut where_clause = where_clause.cloned().unwrap_or_else(|| syn::WhereClause {
-        where_token: Default::default(),
-        predicates: Default::default(),
-    });
-    where_clause.predicates.push(syn::parse2(quote! { Self: Eq + ::std::fmt::Debug + ::std::hash::Hash + Clone + Send + Sync + 'static }).unwrap());
-
-    quote! {
-        impl #impl_generics #ecs_path::schedule::#label_type for #ident #ty_generics #where_clause {
-            fn dyn_clone(&self) -> Box<dyn #ecs_path::schedule::#label_type> {
-                Box::new(Clone::clone(self))
-            }
-        }
-    }
+    let mut trait_path = bevy_ecs_path();
+    trait_path.segments.push(format_ident!("schedule").into());
+    trait_path
+        .segments
+        .push(format_ident!("RunCriteriaLabel").into());
+    derive_label(input, trait_path)
 }
 
 pub(crate) fn bevy_ecs_path() -> syn::Path {
diff --git a/crates/bevy_ecs/src/lib.rs b/crates/bevy_ecs/src/lib.rs
index 6fb347a2a7..6020a9d68e 100644
--- a/crates/bevy_ecs/src/lib.rs
+++ b/crates/bevy_ecs/src/lib.rs
@@ -38,6 +38,8 @@ pub mod prelude {
     };
 }
 
+pub use bevy_ecs_macros::all_tuples;
+
 #[cfg(test)]
 mod tests {
     use crate as bevy_ecs;
diff --git a/crates/bevy_ecs/src/query/fetch.rs b/crates/bevy_ecs/src/query/fetch.rs
index 9572a797f1..215b151790 100644
--- a/crates/bevy_ecs/src/query/fetch.rs
+++ b/crates/bevy_ecs/src/query/fetch.rs
@@ -45,6 +45,8 @@ pub trait WorldQuery {
     type State: FetchState;
 }
 
+pub type QueryItem<'w, 's, Q> = <<Q as WorldQuery>::Fetch as Fetch<'w, 's>>::Item;
+
 pub trait Fetch<'world, 'state>: Sized {
     type Item;
     type State: FetchState;
diff --git a/crates/bevy_ecs/src/query/state.rs b/crates/bevy_ecs/src/query/state.rs
index 6ecca3b870..3dd9a7c6a7 100644
--- a/crates/bevy_ecs/src/query/state.rs
+++ b/crates/bevy_ecs/src/query/state.rs
@@ -66,7 +66,7 @@ where
             matched_archetypes: Default::default(),
             archetype_component_access: Default::default(),
         };
-        state.validate_world_and_update_archetypes(world);
+        state.update_archetypes(world);
         state
     }
 
@@ -87,11 +87,8 @@ where
     /// # Panics
     ///
     /// Panics if the `world.id()` does not equal the current [`QueryState`] internal id.
-    pub fn validate_world_and_update_archetypes(&mut self, world: &World) {
-        if world.id() != self.world_id {
-            panic!("Attempted to use {} with a mismatched World. QueryStates can only be used with the World they were created from.",
-                std::any::type_name::<Self>());
-        }
+    pub fn update_archetypes(&mut self, world: &World) {
+        self.validate_world(world);
         let archetypes = world.archetypes();
         let new_generation = archetypes.generation();
         let old_generation = std::mem::replace(&mut self.archetype_generation, new_generation);
@@ -102,6 +99,14 @@ where
         }
     }
 
+    #[inline]
+    pub fn validate_world(&self, world: &World) {
+        if world.id() != self.world_id {
+            panic!("Attempted to use {} with a mismatched World. QueryStates can only be used with the World they were created from.",
+                std::any::type_name::<Self>());
+        }
+    }
+
     /// Creates a new [`Archetype`].
     pub fn new_archetype(&mut self, archetype: &Archetype) {
         if self.fetch_state.matches_archetype(archetype)
@@ -153,6 +158,27 @@ where
         unsafe { self.get_unchecked(world, entity) }
     }
 
+    #[inline]
+    pub fn get_manual<'w, 's>(
+        &'s self,
+        world: &'w World,
+        entity: Entity,
+    ) -> Result<<Q::Fetch as Fetch<'w, 's>>::Item, QueryEntityError>
+    where
+        Q::Fetch: ReadOnlyFetch,
+    {
+        self.validate_world(world);
+        // SAFETY: query is read only and world is validated
+        unsafe {
+            self.get_unchecked_manual(
+                world,
+                entity,
+                world.last_change_tick(),
+                world.read_change_tick(),
+            )
+        }
+    }
+
     /// Gets the query result for the given [`World`] and [`Entity`].
     ///
     /// # Safety
@@ -165,7 +191,7 @@ where
         world: &'w World,
         entity: Entity,
     ) -> Result<<Q::Fetch as Fetch<'w, 's>>::Item, QueryEntityError> {
-        self.validate_world_and_update_archetypes(world);
+        self.update_archetypes(world);
         self.get_unchecked_manual(
             world,
             entity,
@@ -232,6 +258,28 @@ where
         unsafe { self.iter_unchecked(world) }
     }
 
+    /// Returns an [`Iterator`] over all possible combinations of `K` query results without repetition.
+    /// This can only be called for read-only queries.
+    ///
+    ///  For permutations of size K of query returning N results, you will get:
+    /// - if K == N: one permutation of all query results
+    /// - if K < N: all possible K-sized combinations of query results, without repetition
+    /// - if K > N: empty set (no K-sized combinations exist)
+    ///
+    /// This can only be called for read-only queries, see [`Self::iter_combinations_mut`] for
+    /// write-queries.
+    #[inline]
+    pub fn iter_manual<'w, 's>(&'s self, world: &'w World) -> QueryIter<'w, 's, Q, F>
+    where
+        Q::Fetch: ReadOnlyFetch,
+    {
+        self.validate_world(world);
+        // SAFETY: query is read only and world is validated
+        unsafe {
+            self.iter_unchecked_manual(world, world.last_change_tick(), world.read_change_tick())
+        }
+    }
+
     /// Returns an [`Iterator`] over all possible combinations of `K` query results without repetition.
     /// This can only be called for read-only queries.
     ///
@@ -281,7 +329,7 @@ where
         &'s mut self,
         world: &'w World,
     ) -> QueryIter<'w, 's, Q, F> {
-        self.validate_world_and_update_archetypes(world);
+        self.update_archetypes(world);
         self.iter_unchecked_manual(world, world.last_change_tick(), world.read_change_tick())
     }
 
@@ -298,7 +346,7 @@ where
         &'s mut self,
         world: &'w World,
     ) -> QueryCombinationIter<'w, 's, Q, F, K> {
-        self.validate_world_and_update_archetypes(world);
+        self.update_archetypes(world);
         self.iter_combinations_unchecked_manual(
             world,
             world.last_change_tick(),
@@ -392,7 +440,7 @@ where
         world: &'w World,
         func: impl FnMut(<Q::Fetch as Fetch<'w, 's>>::Item),
     ) {
-        self.validate_world_and_update_archetypes(world);
+        self.update_archetypes(world);
         self.for_each_unchecked_manual(
             world,
             func,
@@ -452,7 +500,7 @@ where
         batch_size: usize,
         func: impl Fn(<Q::Fetch as Fetch<'w, 's>>::Item) + Send + Sync + Clone,
     ) {
-        self.validate_world_and_update_archetypes(world);
+        self.update_archetypes(world);
         self.par_for_each_unchecked_manual(
             world,
             task_pool,
diff --git a/crates/bevy_ecs/src/schedule/label.rs b/crates/bevy_ecs/src/schedule/label.rs
index a7f3538741..5235dc5837 100644
--- a/crates/bevy_ecs/src/schedule/label.rs
+++ b/crates/bevy_ecs/src/schedule/label.rs
@@ -1,115 +1,12 @@
 pub use bevy_ecs_macros::{AmbiguitySetLabel, RunCriteriaLabel, StageLabel, SystemLabel};
+use bevy_utils::define_label;
 
-use std::{
-    any::Any,
-    borrow::Cow,
-    fmt::Debug,
-    hash::{Hash, Hasher},
-};
+define_label!(StageLabel);
+define_label!(SystemLabel);
+define_label!(AmbiguitySetLabel);
+define_label!(RunCriteriaLabel);
 
-pub trait DynEq: Any {
-    fn as_any(&self) -> &dyn Any;
-
-    fn dyn_eq(&self, other: &dyn DynEq) -> bool;
-}
-
-impl<T> DynEq for T
-where
-    T: Any + Eq,
-{
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
-    fn dyn_eq(&self, other: &dyn DynEq) -> bool {
-        if let Some(other) = other.as_any().downcast_ref::<T>() {
-            return self == other;
-        }
-        false
-    }
-}
-
-pub trait DynHash: DynEq {
-    fn as_dyn_eq(&self) -> &dyn DynEq;
-
-    fn dyn_hash(&self, state: &mut dyn Hasher);
-}
-
-impl<T> DynHash for T
-where
-    T: DynEq + Hash,
-{
-    fn as_dyn_eq(&self) -> &dyn DynEq {
-        self
-    }
-
-    fn dyn_hash(&self, mut state: &mut dyn Hasher) {
-        T::hash(self, &mut state);
-        self.type_id().hash(&mut state);
-    }
-}
-
-pub trait StageLabel: DynHash + Debug + Send + Sync + 'static {
-    #[doc(hidden)]
-    fn dyn_clone(&self) -> Box<dyn StageLabel>;
-}
 pub(crate) type BoxedStageLabel = Box<dyn StageLabel>;
-
-pub trait SystemLabel: DynHash + Debug + Send + Sync + 'static {
-    #[doc(hidden)]
-    fn dyn_clone(&self) -> Box<dyn SystemLabel>;
-}
 pub(crate) type BoxedSystemLabel = Box<dyn SystemLabel>;
-
-pub trait AmbiguitySetLabel: DynHash + Debug + Send + Sync + 'static {
-    #[doc(hidden)]
-    fn dyn_clone(&self) -> Box<dyn AmbiguitySetLabel>;
-}
 pub(crate) type BoxedAmbiguitySetLabel = Box<dyn AmbiguitySetLabel>;
-
-pub trait RunCriteriaLabel: DynHash + Debug + Send + Sync + 'static {
-    #[doc(hidden)]
-    fn dyn_clone(&self) -> Box<dyn RunCriteriaLabel>;
-}
 pub(crate) type BoxedRunCriteriaLabel = Box<dyn RunCriteriaLabel>;
-
-macro_rules! impl_label {
-    ($trait_name:ident) => {
-        impl PartialEq for dyn $trait_name {
-            fn eq(&self, other: &Self) -> bool {
-                self.dyn_eq(other.as_dyn_eq())
-            }
-        }
-
-        impl Eq for dyn $trait_name {}
-
-        impl Hash for dyn $trait_name {
-            fn hash<H: Hasher>(&self, state: &mut H) {
-                self.dyn_hash(state);
-            }
-        }
-
-        impl Clone for Box<dyn $trait_name> {
-            fn clone(&self) -> Self {
-                self.dyn_clone()
-            }
-        }
-
-        impl $trait_name for Cow<'static, str> {
-            fn dyn_clone(&self) -> Box<dyn $trait_name> {
-                Box::new(self.clone())
-            }
-        }
-
-        impl $trait_name for &'static str {
-            fn dyn_clone(&self) -> Box<dyn $trait_name> {
-                Box::new(<&str>::clone(self))
-            }
-        }
-    };
-}
-
-impl_label!(StageLabel);
-impl_label!(SystemLabel);
-impl_label!(AmbiguitySetLabel);
-impl_label!(RunCriteriaLabel);
diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index 11cf3ea0c0..39880a3035 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -84,6 +84,8 @@ pub struct SystemStage {
     uninitialized_parallel: Vec<usize>,
     /// Saves the value of the World change_tick during the last tick check
     last_tick_check: u32,
+    /// If true, buffers will be automatically applied at the end of the stage. If false, buffers must be manually applied.
+    apply_buffers: bool,
 }
 
 impl SystemStage {
@@ -105,6 +107,7 @@ impl SystemStage {
             uninitialized_before_commands: vec![],
             uninitialized_at_end: vec![],
             last_tick_check: Default::default(),
+            apply_buffers: true,
         }
     }
 
@@ -204,6 +207,21 @@ impl SystemStage {
         }
     }
 
+    pub fn apply_buffers(&mut self, world: &mut World) {
+        for container in self.parallel.iter_mut() {
+            let system = container.system_mut();
+            #[cfg(feature = "trace")]
+            let span = bevy_utils::tracing::info_span!("system_commands", name = &*system.name());
+            #[cfg(feature = "trace")]
+            let _guard = span.enter();
+            system.apply_buffers(world);
+        }
+    }
+
+    pub fn set_apply_buffers(&mut self, apply_buffers: bool) {
+        self.apply_buffers = apply_buffers;
+    }
+
     /// Topologically sorted parallel systems.
     ///
     /// Note that systems won't be fully-formed until the stage has been run at least once.
@@ -832,9 +850,11 @@ impl Stage for SystemStage {
                 }
 
                 // Apply parallel systems' buffers.
-                for container in &mut self.parallel {
-                    if container.should_run {
-                        container.system_mut().apply_buffers(world);
+                if self.apply_buffers {
+                    for container in &mut self.parallel {
+                        if container.should_run {
+                            container.system_mut().apply_buffers(world);
+                        }
                     }
                 }
 
diff --git a/crates/bevy_ecs/src/system/function_system.rs b/crates/bevy_ecs/src/system/function_system.rs
index 90b36671e8..15f5b8a952 100644
--- a/crates/bevy_ecs/src/system/function_system.rs
+++ b/crates/bevy_ecs/src/system/function_system.rs
@@ -4,7 +4,7 @@ use crate::{
     query::{Access, FilteredAccessSet},
     system::{
         check_system_change_tick, ReadOnlySystemParamFetch, System, SystemParam, SystemParamFetch,
-        SystemParamState,
+        SystemParamItem, SystemParamState,
     },
     world::{World, WorldId},
 };
@@ -46,6 +46,11 @@ impl SystemMeta {
     pub fn set_non_send(&mut self) {
         self.is_send = false;
     }
+
+    #[inline]
+    pub(crate) fn check_change_tick(&mut self, change_tick: u32) {
+        check_system_change_tick(&mut self.last_change_tick, change_tick, self.name.as_ref());
+    }
 }
 
 // TODO: Actually use this in FunctionSystem. We should probably only do this once Systems are constructed using a World reference
@@ -121,6 +126,10 @@ impl<Param: SystemParam> SystemState<Param> {
         self.world_id == world.id()
     }
 
+    pub(crate) fn new_archetype(&mut self, archetype: &Archetype) {
+        self.param_state.new_archetype(archetype, &mut self.meta);
+    }
+
     fn validate_world_and_update_archetypes(&mut self, world: &World) {
         assert!(self.matches_world(world), "Encountered a mismatched World. A SystemState cannot be used with Worlds other than the one it was created with.");
         let archetypes = world.archetypes();
@@ -159,6 +168,74 @@ impl<Param: SystemParam> SystemState<Param> {
     }
 }
 
+/// A trait for defining systems with a [`SystemParam`] associated type.
+///
+/// This facilitates the creation of systems that are generic over some trait
+/// and that use that trait's associated types as `SystemParam`s.
+pub trait RunSystem: Send + Sync + 'static {
+    /// The `SystemParam` type passed to the system when it runs.
+    type Param: SystemParam;
+
+    /// Runs the system.
+    fn run(param: SystemParamItem<Self::Param>);
+
+    /// Creates a concrete instance of the system for the specified `World`.
+    fn system(world: &mut World) -> ParamSystem<Self::Param> {
+        ParamSystem {
+            run: Self::run,
+            state: SystemState::new(world),
+        }
+    }
+}
+
+pub struct ParamSystem<P: SystemParam> {
+    state: SystemState<P>,
+    run: fn(SystemParamItem<P>),
+}
+
+impl<P: SystemParam + 'static> System for ParamSystem<P> {
+    type In = ();
+
+    type Out = ();
+
+    fn name(&self) -> Cow<'static, str> {
+        self.state.meta().name.clone()
+    }
+
+    fn new_archetype(&mut self, archetype: &Archetype) {
+        self.state.new_archetype(archetype);
+    }
+
+    fn component_access(&self) -> &Access<ComponentId> {
+        self.state.meta().component_access_set.combined_access()
+    }
+
+    fn archetype_component_access(&self) -> &Access<ArchetypeComponentId> {
+        &self.state.meta().archetype_component_access
+    }
+
+    fn is_send(&self) -> bool {
+        self.state.meta().is_send()
+    }
+
+    unsafe fn run_unsafe(&mut self, _input: Self::In, world: &World) -> Self::Out {
+        let param = self.state.get_unchecked_manual(world);
+        (self.run)(param);
+    }
+
+    fn apply_buffers(&mut self, world: &mut World) {
+        self.state.apply(world);
+    }
+
+    fn initialize(&mut self, _world: &mut World) {
+        // already initialized by nature of the SystemState being constructed
+    }
+
+    fn check_change_tick(&mut self, change_tick: u32) {
+        self.state.meta.check_change_tick(change_tick);
+    }
+}
+
 /// Conversion trait to turn something into a [`System`].
 ///
 /// Use this to get a system from a function. Also note that every system implements this trait as
diff --git a/crates/bevy_ecs/src/system/system_param.rs b/crates/bevy_ecs/src/system/system_param.rs
index b544ed5a6c..af52e24d7b 100644
--- a/crates/bevy_ecs/src/system/system_param.rs
+++ b/crates/bevy_ecs/src/system/system_param.rs
@@ -48,6 +48,8 @@ pub trait SystemParam: Sized {
     type Fetch: for<'w, 's> SystemParamFetch<'w, 's>;
 }
 
+pub type SystemParamItem<'w, 's, P> = <<P as SystemParam>::Fetch as SystemParamFetch<'w, 's>>::Item;
+
 /// The state of a [`SystemParam`].
 ///
 /// # Safety
@@ -1230,3 +1232,12 @@ macro_rules! impl_system_param_tuple {
 }
 
 all_tuples!(impl_system_param_tuple, 0, 16, P);
+
+pub mod lifetimeless {
+    pub type SQuery<Q, F = ()> = super::Query<'static, 'static, Q, F>;
+    pub type Read<T> = &'static T;
+    pub type Write<T> = &'static mut T;
+    pub type SRes<T> = super::Res<'static, T>;
+    pub type SResMut<T> = super::ResMut<'static, T>;
+    pub type SCommands = crate::system::Commands<'static, 'static>;
+}
diff --git a/crates/bevy_internal/Cargo.toml b/crates/bevy_internal/Cargo.toml
index 1a052cdc88..9f06295817 100644
--- a/crates/bevy_internal/Cargo.toml
+++ b/crates/bevy_internal/Cargo.toml
@@ -11,17 +11,17 @@ categories = ["game-engines", "graphics", "gui", "rendering"]
 
 [features]
 wgpu_trace = ["bevy_wgpu/trace"]
-trace = [ "bevy_app/trace", "bevy_ecs/trace" ]
+trace = [ "bevy_app/trace", "bevy_ecs/trace", "bevy_render2/trace" ]
 trace_chrome = [ "bevy_log/tracing-chrome" ]
 trace_tracy = [ "bevy_log/tracing-tracy" ]
 
 # Image format support for texture loading (PNG and HDR are enabled by default)
-hdr = ["bevy_render/hdr"]
-png = ["bevy_render/png"]
-dds = ["bevy_render/dds"]
-tga = ["bevy_render/tga"]
-jpeg = ["bevy_render/jpeg"]
-bmp = ["bevy_render/bmp"]
+hdr = ["bevy_render/hdr", "bevy_render2/hdr" ]
+png = ["bevy_render/png", "bevy_render2/png" ]
+dds = ["bevy_render/dds", "bevy_render2/dds" ]
+tga = ["bevy_render/tga", "bevy_render2/tga" ]
+jpeg = ["bevy_render/jpeg", "bevy_render2/jpeg" ]
+bmp = ["bevy_render/bmp", "bevy_render2/bmp" ]
 
 # Audio format support (MP3 is enabled by default)
 flac = ["bevy_audio/flac"]
@@ -63,11 +63,16 @@ bevy_window = { path = "../bevy_window", version = "0.5.0" }
 bevy_tasks = { path = "../bevy_tasks", version = "0.5.0" }
 # bevy (optional)
 bevy_audio = { path = "../bevy_audio", optional = true, version = "0.5.0" }
+bevy_core_pipeline = { path = "../../pipelined/bevy_core_pipeline", optional = true, version = "0.5.0" }
 bevy_gltf = { path = "../bevy_gltf", optional = true, version = "0.5.0" }
+bevy_gltf2 = { path = "../../pipelined/bevy_gltf2", optional = true, version = "0.5.0" }
 bevy_pbr = { path = "../bevy_pbr", optional = true, version = "0.5.0" }
+bevy_pbr2 = { path = "../../pipelined/bevy_pbr2", optional = true, version = "0.5.0" }
 bevy_render = { path = "../bevy_render", optional = true, version = "0.5.0" }
+bevy_render2 = { path = "../../pipelined/bevy_render2", optional = true, version = "0.5.0" }
 bevy_dynamic_plugin = { path = "../bevy_dynamic_plugin", optional = true, version = "0.5.0" }
 bevy_sprite = { path = "../bevy_sprite", optional = true, version = "0.5.0" }
+bevy_sprite2 = { path = "../../pipelined/bevy_sprite2", optional = true, version = "0.5.0" }
 bevy_text = { path = "../bevy_text", optional = true, version = "0.5.0" }
 bevy_ui = { path = "../bevy_ui", optional = true, version = "0.5.0" }
 bevy_wgpu = { path = "../bevy_wgpu", optional = true, version = "0.5.0" }
diff --git a/crates/bevy_internal/src/default_plugins.rs b/crates/bevy_internal/src/default_plugins.rs
index 0cc8f49ca2..733fd2d419 100644
--- a/crates/bevy_internal/src/default_plugins.rs
+++ b/crates/bevy_internal/src/default_plugins.rs
@@ -109,3 +109,40 @@ impl PluginGroup for MinimalPlugins {
         group.add(ScheduleRunnerPlugin::default());
     }
 }
+
+pub struct PipelinedDefaultPlugins;
+
+impl PluginGroup for PipelinedDefaultPlugins {
+    fn build(&mut self, group: &mut PluginGroupBuilder) {
+        group.add(bevy_log::LogPlugin::default());
+        group.add(bevy_core::CorePlugin::default());
+        group.add(bevy_transform::TransformPlugin::default());
+        group.add(bevy_diagnostic::DiagnosticsPlugin::default());
+        group.add(bevy_input::InputPlugin::default());
+        group.add(bevy_window::WindowPlugin::default());
+        group.add(bevy_asset::AssetPlugin::default());
+        group.add(bevy_scene::ScenePlugin::default());
+
+        #[cfg(feature = "bevy_winit")]
+        group.add(bevy_winit::WinitPlugin::default());
+
+        #[cfg(feature = "bevy_render2")]
+        {
+            group.add(bevy_render2::RenderPlugin::default());
+        }
+
+        #[cfg(feature = "bevy_core_pipeline")]
+        {
+            group.add(bevy_core_pipeline::CorePipelinePlugin::default());
+
+            #[cfg(feature = "bevy_sprite2")]
+            group.add(bevy_sprite2::SpritePlugin::default());
+
+            #[cfg(feature = "bevy_pbr2")]
+            group.add(bevy_pbr2::PbrPlugin::default());
+
+            #[cfg(feature = "bevy_gltf2")]
+            group.add(bevy_gltf2::GltfPlugin::default());
+        }
+    }
+}
diff --git a/crates/bevy_internal/src/lib.rs b/crates/bevy_internal/src/lib.rs
index 87dc85dd3c..932971b6f1 100644
--- a/crates/bevy_internal/src/lib.rs
+++ b/crates/bevy_internal/src/lib.rs
@@ -82,6 +82,12 @@ pub mod audio {
     pub use bevy_audio::*;
 }
 
+#[cfg(feature = "bevy_core_pipeline")]
+pub mod core_pipeline {
+    //! Core render pipeline.
+    pub use bevy_core_pipeline::*;
+}
+
 #[cfg(feature = "bevy_gilrs")]
 pub mod gilrs {
     pub use bevy_gilrs::*;
@@ -93,24 +99,48 @@ pub mod gltf {
     pub use bevy_gltf::*;
 }
 
+#[cfg(feature = "bevy_gltf2")]
+pub mod gltf2 {
+    //! Support for GLTF file loading.
+    pub use bevy_gltf2::*;
+}
+
 #[cfg(feature = "bevy_pbr")]
 pub mod pbr {
     //! Physically based rendering.
     pub use bevy_pbr::*;
 }
 
+#[cfg(feature = "bevy_pbr2")]
+pub mod pbr2 {
+    //! Physically based rendering.
+    pub use bevy_pbr2::*;
+}
+
 #[cfg(feature = "bevy_render")]
 pub mod render {
     //! Cameras, meshes, textures, shaders, and pipelines.
     pub use bevy_render::*;
 }
 
+#[cfg(feature = "bevy_render2")]
+pub mod render2 {
+    //! Cameras, meshes, textures, shaders, and pipelines.
+    pub use bevy_render2::*;
+}
+
 #[cfg(feature = "bevy_sprite")]
 pub mod sprite {
     //! Items for sprites, rects, texture atlases, etc.
     pub use bevy_sprite::*;
 }
 
+#[cfg(feature = "bevy_sprite2")]
+pub mod sprite2 {
+    //! Items for sprites, rects, texture atlases, etc.
+    pub use bevy_sprite2::*;
+}
+
 #[cfg(feature = "bevy_text")]
 pub mod text {
     //! Text drawing, styling, and font assets.
diff --git a/crates/bevy_log/Cargo.toml b/crates/bevy_log/Cargo.toml
index 4b8027adb9..d7f45cf6ec 100644
--- a/crates/bevy_log/Cargo.toml
+++ b/crates/bevy_log/Cargo.toml
@@ -15,6 +15,7 @@ bevy_utils = { path = "../bevy_utils", version = "0.5.0" }
 tracing-subscriber = {version = "0.3.1", features = ["registry", "env-filter"]}
 tracing-chrome = { version = "0.4.0", optional = true }
 tracing-tracy = { version = "0.8.0", optional = true }
+tracing-log = "0.1.2"
 
 [target.'cfg(target_os = "android")'.dependencies]
 android_log-sys = "0.2.0"
diff --git a/crates/bevy_log/src/lib.rs b/crates/bevy_log/src/lib.rs
index b4c1760b5c..c769a652ec 100644
--- a/crates/bevy_log/src/lib.rs
+++ b/crates/bevy_log/src/lib.rs
@@ -13,6 +13,7 @@ pub use bevy_utils::tracing::{
 };
 
 use bevy_app::{App, Plugin};
+use tracing_log::LogTracer;
 #[cfg(feature = "tracing-chrome")]
 use tracing_subscriber::fmt::{format::DefaultFields, FormattedFields};
 use tracing_subscriber::{prelude::*, registry::Registry, EnvFilter};
@@ -88,7 +89,7 @@ impl Plugin for LogPlugin {
             let settings = app.world.get_resource_or_insert_with(LogSettings::default);
             format!("{},{}", settings.level, settings.filter)
         };
-
+        LogTracer::init().unwrap();
         let filter_layer = EnvFilter::try_from_default_env()
             .or_else(|_| EnvFilter::try_new(&default_filter))
             .unwrap();
diff --git a/crates/bevy_macro_utils/Cargo.toml b/crates/bevy_macro_utils/Cargo.toml
index 2845405e2f..f541e2555b 100644
--- a/crates/bevy_macro_utils/Cargo.toml
+++ b/crates/bevy_macro_utils/Cargo.toml
@@ -11,3 +11,4 @@ keywords = ["bevy"]
 [dependencies]
 cargo-manifest = "0.2.6"
 syn = "1.0"
+quote = "1.0"
diff --git a/crates/bevy_macro_utils/src/lib.rs b/crates/bevy_macro_utils/src/lib.rs
index 98e72e6a89..0dd6a57037 100644
--- a/crates/bevy_macro_utils/src/lib.rs
+++ b/crates/bevy_macro_utils/src/lib.rs
@@ -8,6 +8,7 @@ pub use symbol::*;
 
 use cargo_manifest::{DepsSet, Manifest};
 use proc_macro::TokenStream;
+use quote::quote;
 use std::{env, path::PathBuf};
 
 pub struct BevyManifest {
@@ -65,3 +66,29 @@ fn get_path(path: &str) -> syn::Path {
 fn parse_str<T: syn::parse::Parse>(path: &str) -> T {
     syn::parse(path.parse::<TokenStream>().unwrap()).unwrap()
 }
+
+/// Derive a label trait
+///
+/// # Args
+///
+/// - `input`: The [`syn::DeriveInput`] for struct that is deriving the label trait
+/// - `trait_path`: The path [`syn::Path`] to the label trait
+pub fn derive_label(input: syn::DeriveInput, trait_path: syn::Path) -> TokenStream {
+    let ident = input.ident;
+
+    let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
+    let mut where_clause = where_clause.cloned().unwrap_or_else(|| syn::WhereClause {
+        where_token: Default::default(),
+        predicates: Default::default(),
+    });
+    where_clause.predicates.push(syn::parse2(quote! { Self: Eq + ::std::fmt::Debug + ::std::hash::Hash + Clone + Send + Sync + 'static }).unwrap());
+
+    (quote! {
+        impl #impl_generics #trait_path for #ident #ty_generics #where_clause {
+            fn dyn_clone(&self) -> Box<dyn #trait_path> {
+                Box::new(Clone::clone(self))
+            }
+        }
+    })
+    .into()
+}
diff --git a/crates/bevy_math/Cargo.toml b/crates/bevy_math/Cargo.toml
index f998039ba1..f3cc0b02d3 100644
--- a/crates/bevy_math/Cargo.toml
+++ b/crates/bevy_math/Cargo.toml
@@ -9,5 +9,5 @@ license = "MIT OR Apache-2.0"
 keywords = ["bevy"]
 
 [dependencies]
-glam = { version = "0.18.0", features = ["serde", "bytemuck"] }
+glam = { version = "0.20.0", features = ["serde", "bytemuck"] }
 bevy_reflect = { path = "../bevy_reflect", version = "0.5.0", features = ["bevy"] }
diff --git a/crates/bevy_reflect/Cargo.toml b/crates/bevy_reflect/Cargo.toml
index 2e9af8f073..ab9b8cbd23 100644
--- a/crates/bevy_reflect/Cargo.toml
+++ b/crates/bevy_reflect/Cargo.toml
@@ -24,7 +24,7 @@ parking_lot = "0.11.0"
 thiserror = "1.0"
 serde = "1"
 smallvec = { version = "1.6", features = ["serde", "union", "const_generics"], optional = true }
-glam = { version = "0.18.0", features = ["serde"], optional = true }
+glam = { version = "0.20.0", features = ["serde"], optional = true }
 
 [dev-dependencies]
 ron = "0.6.2"
diff --git a/crates/bevy_render/Cargo.toml b/crates/bevy_render/Cargo.toml
index 6dbad550a9..c3ac5c6167 100644
--- a/crates/bevy_render/Cargo.toml
+++ b/crates/bevy_render/Cargo.toml
@@ -32,7 +32,7 @@ downcast-rs = "1.2.0"
 thiserror = "1.0"
 anyhow = "1.0.4"
 hex = "0.4.2"
-hexasphere = "5.0.0"
+hexasphere = "6.0.0"
 parking_lot = "0.11.0"
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
diff --git a/crates/bevy_render/src/render_graph/base.rs b/crates/bevy_render/src/render_graph/base.rs
index 160039a8b0..1e526ba8da 100644
--- a/crates/bevy_render/src/render_graph/base.rs
+++ b/crates/bevy_render/src/render_graph/base.rs
@@ -7,7 +7,7 @@ use crate::{
         LoadOp, Operations, PassDescriptor, RenderPassColorAttachment,
         RenderPassDepthStencilAttachment, TextureAttachment,
     },
-    texture::{Extent3d, TextureDescriptor, TextureDimension, TextureFormat, TextureUsage},
+    texture::{Extent3d, TextureDescriptor, TextureDimension, TextureFormat, TextureUsages},
     Color,
 };
 use bevy_ecs::{component::Component, reflect::ReflectComponent, world::World};
@@ -126,7 +126,7 @@ pub(crate) fn add_base_graph(config: &BaseRenderGraphConfig, world: &mut World)
                     dimension: TextureDimension::D2,
                     format: TextureFormat::Depth32Float, /* PERF: vulkan docs recommend using 24
                                                           * bit depth for better performance */
-                    usage: TextureUsage::OUTPUT_ATTACHMENT,
+                    usage: TextureUsages::OUTPUT_ATTACHMENT,
                 },
             ),
         );
@@ -220,7 +220,7 @@ pub(crate) fn add_base_graph(config: &BaseRenderGraphConfig, world: &mut World)
                     sample_count: msaa.samples,
                     dimension: TextureDimension::D2,
                     format: TextureFormat::default(),
-                    usage: TextureUsage::OUTPUT_ATTACHMENT,
+                    usage: TextureUsages::OUTPUT_ATTACHMENT,
                 },
             ),
         );
diff --git a/crates/bevy_render/src/render_graph/nodes/window_swapchain_node.rs b/crates/bevy_render/src/render_graph/nodes/window_swapchain_node.rs
index 50df2ea883..52c7904e42 100644
--- a/crates/bevy_render/src/render_graph/nodes/window_swapchain_node.rs
+++ b/crates/bevy_render/src/render_graph/nodes/window_swapchain_node.rs
@@ -52,7 +52,7 @@ impl Node for WindowSwapChainNode {
 
         let render_resource_context = render_context.resources_mut();
 
-        // create window swapchain when window is resized or created
+        // reconfigure surface window is resized or created
         if self
             .window_created_event_reader
             .iter(window_created_events)
@@ -62,10 +62,10 @@ impl Node for WindowSwapChainNode {
                 .iter(window_resized_events)
                 .any(|e| e.id == window.id())
         {
-            render_resource_context.create_swap_chain(window);
+            render_resource_context.configure_surface(window);
         }
 
-        let swap_chain_texture = render_resource_context.next_swap_chain_texture(window);
+        let swap_chain_texture = render_resource_context.next_surface_frame(window);
         output.set(
             WINDOW_TEXTURE,
             RenderResourceId::Texture(swap_chain_texture),
diff --git a/crates/bevy_render/src/renderer/headless_render_resource_context.rs b/crates/bevy_render/src/renderer/headless_render_resource_context.rs
index 738c065966..89f6c2e726 100644
--- a/crates/bevy_render/src/renderer/headless_render_resource_context.rs
+++ b/crates/bevy_render/src/renderer/headless_render_resource_context.rs
@@ -31,15 +31,15 @@ impl HeadlessRenderResourceContext {
 }
 
 impl RenderResourceContext for HeadlessRenderResourceContext {
-    fn create_swap_chain(&self, _window: &Window) {}
+    fn configure_surface(&self, _window: &Window) {}
 
-    fn next_swap_chain_texture(&self, _window: &Window) -> TextureId {
+    fn next_surface_frame(&self, _window: &Window) -> TextureId {
         TextureId::new()
     }
 
-    fn drop_swap_chain_texture(&self, _render_resource: TextureId) {}
+    fn drop_surface_frame(&self, _render_resource: TextureId) {}
 
-    fn drop_all_swap_chain_textures(&self) {}
+    fn drop_all_surface_frames(&self) {}
 
     fn create_sampler(&self, _sampler_descriptor: &SamplerDescriptor) -> SamplerId {
         SamplerId::new()
diff --git a/crates/bevy_render/src/renderer/render_resource_context.rs b/crates/bevy_render/src/renderer/render_resource_context.rs
index 9afa958aa8..9d16197e76 100644
--- a/crates/bevy_render/src/renderer/render_resource_context.rs
+++ b/crates/bevy_render/src/renderer/render_resource_context.rs
@@ -12,10 +12,10 @@ use downcast_rs::{impl_downcast, Downcast};
 use std::ops::Range;
 
 pub trait RenderResourceContext: Downcast + Send + Sync + 'static {
-    fn create_swap_chain(&self, window: &Window);
-    fn next_swap_chain_texture(&self, window: &Window) -> TextureId;
-    fn drop_swap_chain_texture(&self, resource: TextureId);
-    fn drop_all_swap_chain_textures(&self);
+    fn configure_surface(&self, window: &Window);
+    fn next_surface_frame(&self, window: &Window) -> TextureId;
+    fn drop_surface_frame(&self, resource: TextureId);
+    fn drop_all_surface_frames(&self);
     fn create_sampler(&self, sampler_descriptor: &SamplerDescriptor) -> SamplerId;
     fn create_texture(&self, texture_descriptor: TextureDescriptor) -> TextureId;
     fn create_buffer(&self, buffer_info: BufferInfo) -> BufferId;
diff --git a/crates/bevy_render/src/texture/image_texture_conversion.rs b/crates/bevy_render/src/texture/image_texture_conversion.rs
index dc31be26d5..d355860f26 100644
--- a/crates/bevy_render/src/texture/image_texture_conversion.rs
+++ b/crates/bevy_render/src/texture/image_texture_conversion.rs
@@ -1,4 +1,3 @@
-use std::convert::TryFrom;
 use thiserror::Error;
 
 use super::{Extent3d, Texture, TextureDimension, TextureFormat};
@@ -87,7 +86,8 @@ impl From<image::DynamicImage> for Texture {
                     Vec::with_capacity(width as usize * height as usize * format.pixel_size());
 
                 for pixel in image.into_raw().chunks_exact(3) {
-                    // TODO unsafe_get in release builds?
+                    // TODO use the array_chunks method once stabilised
+                    // https://github.com/rust-lang/rust/issues/74985
                     let r = pixel[0];
                     let g = pixel[1];
                     let b = pixel[2];
diff --git a/crates/bevy_render/src/texture/texture_descriptor.rs b/crates/bevy_render/src/texture/texture_descriptor.rs
index 7df3bc4070..9f83c86457 100644
--- a/crates/bevy_render/src/texture/texture_descriptor.rs
+++ b/crates/bevy_render/src/texture/texture_descriptor.rs
@@ -1,4 +1,4 @@
-use super::{Extent3d, Texture, TextureDimension, TextureFormat, TextureUsage};
+use super::{Extent3d, Texture, TextureDimension, TextureFormat, TextureUsages};
 
 /// Describes a texture
 #[derive(Debug, Copy, Clone, Eq, PartialEq)]
@@ -8,7 +8,7 @@ pub struct TextureDescriptor {
     pub sample_count: u32,
     pub dimension: TextureDimension,
     pub format: TextureFormat,
-    pub usage: TextureUsage,
+    pub usage: TextureUsages,
 }
 
 impl From<&Texture> for TextureDescriptor {
@@ -19,7 +19,7 @@ impl From<&Texture> for TextureDescriptor {
             sample_count: 1,
             dimension: texture.dimension,
             format: texture.format,
-            usage: TextureUsage::SAMPLED | TextureUsage::COPY_DST,
+            usage: TextureUsages::SAMPLED | TextureUsages::COPY_DST,
         }
     }
 }
@@ -36,7 +36,7 @@ impl Default for TextureDescriptor {
             sample_count: 1,
             dimension: TextureDimension::D2,
             format: TextureFormat::Rgba8UnormSrgb,
-            usage: TextureUsage::SAMPLED | TextureUsage::COPY_DST,
+            usage: TextureUsages::SAMPLED | TextureUsages::COPY_DST,
         }
     }
 }
diff --git a/crates/bevy_render/src/texture/texture_dimension.rs b/crates/bevy_render/src/texture/texture_dimension.rs
index 5791863591..e1cdda77eb 100644
--- a/crates/bevy_render/src/texture/texture_dimension.rs
+++ b/crates/bevy_render/src/texture/texture_dimension.rs
@@ -276,7 +276,7 @@ impl Default for TextureFormat {
 
 bitflags::bitflags! {
     #[repr(transparent)]
-    pub struct TextureUsage: u32 {
+    pub struct TextureUsages: u32 {
         const COPY_SRC = 1;
         const COPY_DST = 2;
         const SAMPLED = 4;
diff --git a/crates/bevy_sprite/src/render/sprite_sheet.vert b/crates/bevy_sprite/src/render/sprite_sheet.vert
index 62ecf33237..8380a12455 100644
--- a/crates/bevy_sprite/src/render/sprite_sheet.vert
+++ b/crates/bevy_sprite/src/render/sprite_sheet.vert
@@ -21,7 +21,7 @@ struct Rect {
     vec2 end;
 };
 
-layout(set = 1, binding = 1) buffer TextureAtlas_textures {
+layout(set = 1, binding = 1) readonly buffer TextureAtlas_textures {
     Rect[] Textures;
 };
 
diff --git a/crates/bevy_sprite/src/texture_atlas_builder.rs b/crates/bevy_sprite/src/texture_atlas_builder.rs
index c09b819037..e26ac27c87 100644
--- a/crates/bevy_sprite/src/texture_atlas_builder.rs
+++ b/crates/bevy_sprite/src/texture_atlas_builder.rs
@@ -168,10 +168,11 @@ impl TextureAtlasBuilder {
                 &contains_smallest_box,
             ) {
                 Ok(rect_placements) => {
-                    atlas_texture = Texture::new_fill(
-                        Extent3d::new(current_width, current_height, 1),
+                    let size = Extent3d::new(current_width, current_height, 1);
+                    atlas_texture = Texture::new(
+                        size,
                         TextureDimension::D2,
-                        &[0, 0, 0, 0],
+                        vec![0; self.format.pixel_size() * size.volume()],
                         self.format,
                     );
                     Some(rect_placements)
diff --git a/crates/bevy_transform/src/components/global_transform.rs b/crates/bevy_transform/src/components/global_transform.rs
index 930f23a48a..bf01169353 100644
--- a/crates/bevy_transform/src/components/global_transform.rs
+++ b/crates/bevy_transform/src/components/global_transform.rs
@@ -190,7 +190,7 @@ impl GlobalTransform {
     #[doc(hidden)]
     #[inline]
     pub fn rotate(&mut self, rotation: Quat) {
-        self.rotation *= rotation;
+        self.rotation = rotation * self.rotation;
     }
 
     /// Multiplies `self` with `transform` component by component, returning the
diff --git a/crates/bevy_transform/src/components/transform.rs b/crates/bevy_transform/src/components/transform.rs
index cea0fc32cb..e97beaea20 100644
--- a/crates/bevy_transform/src/components/transform.rs
+++ b/crates/bevy_transform/src/components/transform.rs
@@ -202,7 +202,7 @@ impl Transform {
     /// Rotates the transform by the given rotation.
     #[inline]
     pub fn rotate(&mut self, rotation: Quat) {
-        self.rotation *= rotation;
+        self.rotation = rotation * self.rotation;
     }
 
     /// Multiplies `self` with `transform` component by component, returning the
diff --git a/crates/bevy_utils/src/label.rs b/crates/bevy_utils/src/label.rs
new file mode 100644
index 0000000000..ed759f6a59
--- /dev/null
+++ b/crates/bevy_utils/src/label.rs
@@ -0,0 +1,100 @@
+//! Traits used by label implementations
+
+use std::{
+    any::Any,
+    hash::{Hash, Hasher},
+};
+
+pub trait DynEq: Any {
+    fn as_any(&self) -> &dyn Any;
+
+    fn dyn_eq(&self, other: &dyn DynEq) -> bool;
+}
+
+impl<T> DynEq for T
+where
+    T: Any + Eq,
+{
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn dyn_eq(&self, other: &dyn DynEq) -> bool {
+        if let Some(other) = other.as_any().downcast_ref::<T>() {
+            return self == other;
+        }
+        false
+    }
+}
+
+pub trait DynHash: DynEq {
+    fn as_dyn_eq(&self) -> &dyn DynEq;
+
+    fn dyn_hash(&self, state: &mut dyn Hasher);
+}
+
+impl<T> DynHash for T
+where
+    T: DynEq + Hash,
+{
+    fn as_dyn_eq(&self) -> &dyn DynEq {
+        self
+    }
+
+    fn dyn_hash(&self, mut state: &mut dyn Hasher) {
+        T::hash(self, &mut state);
+        self.type_id().hash(&mut state);
+    }
+}
+
+/// Macro to define a new label trait
+///
+/// # Example
+///
+/// ```
+/// # use bevy_utils::define_label;
+/// define_label!(MyNewLabelTrait);
+/// ```
+#[macro_export]
+macro_rules! define_label {
+    ($label_trait_name:ident) => {
+        pub trait $label_trait_name:
+            ::bevy_utils::label::DynHash + ::std::fmt::Debug + Send + Sync + 'static
+        {
+            #[doc(hidden)]
+            fn dyn_clone(&self) -> Box<dyn $label_trait_name>;
+        }
+
+        impl PartialEq for dyn $label_trait_name {
+            fn eq(&self, other: &Self) -> bool {
+                self.dyn_eq(other.as_dyn_eq())
+            }
+        }
+
+        impl Eq for dyn $label_trait_name {}
+
+        impl ::std::hash::Hash for dyn $label_trait_name {
+            fn hash<H: ::std::hash::Hasher>(&self, state: &mut H) {
+                self.dyn_hash(state);
+            }
+        }
+
+        impl Clone for Box<dyn $label_trait_name> {
+            fn clone(&self) -> Self {
+                self.dyn_clone()
+            }
+        }
+
+        impl $label_trait_name for ::std::borrow::Cow<'static, str> {
+            fn dyn_clone(&self) -> Box<dyn $label_trait_name> {
+                Box::new(self.clone())
+            }
+        }
+
+        impl $label_trait_name for &'static str {
+            fn dyn_clone(&self) -> Box<dyn $label_trait_name> {
+                Box::new(<&str>::clone(self))
+            }
+        }
+    };
+}
diff --git a/crates/bevy_utils/src/lib.rs b/crates/bevy_utils/src/lib.rs
index 4b810f0a21..175152e84f 100644
--- a/crates/bevy_utils/src/lib.rs
+++ b/crates/bevy_utils/src/lib.rs
@@ -1,7 +1,8 @@
 mod enum_variant_meta;
-pub use enum_variant_meta::*;
+pub mod label;
 
 pub use ahash::AHasher;
+pub use enum_variant_meta::*;
 pub use instant::{Duration, Instant};
 pub use tracing;
 pub use uuid::Uuid;
diff --git a/crates/bevy_wgpu/Cargo.toml b/crates/bevy_wgpu/Cargo.toml
index ad9dc72019..e1bc40f8d2 100644
--- a/crates/bevy_wgpu/Cargo.toml
+++ b/crates/bevy_wgpu/Cargo.toml
@@ -25,7 +25,7 @@ bevy_winit = { path = "../bevy_winit", optional = true, version = "0.5.0" }
 bevy_utils = { path = "../bevy_utils", version = "0.5.0" }
 
 # other
-wgpu = "0.9"
+wgpu = { version = "0.11.0", features = ["spirv"] }
 futures-lite = "1.4.0"
 crossbeam-channel = "0.5.0"
 crossbeam-utils = "0.8.1"
diff --git a/crates/bevy_wgpu/src/diagnostic/wgpu_resource_diagnostics_plugin.rs b/crates/bevy_wgpu/src/diagnostic/wgpu_resource_diagnostics_plugin.rs
index b696b7bbc0..d4eb37a0af 100644
--- a/crates/bevy_wgpu/src/diagnostic/wgpu_resource_diagnostics_plugin.rs
+++ b/crates/bevy_wgpu/src/diagnostic/wgpu_resource_diagnostics_plugin.rs
@@ -29,9 +29,7 @@ impl WgpuResourceDiagnosticsPlugin {
         DiagnosticId::from_u128(305855369913076220671125671543184691267);
     pub const SHADER_MODULES: DiagnosticId =
         DiagnosticId::from_u128(287681470908132753275843248383768232237);
-    pub const SWAP_CHAINS: DiagnosticId =
-        DiagnosticId::from_u128(199253035828743332241465305105689014605);
-    pub const SWAP_CHAIN_OUTPUTS: DiagnosticId =
+    pub const SURFACE_FRAMES: DiagnosticId =
         DiagnosticId::from_u128(112048874168736161226721327099863374234);
     pub const TEXTURES: DiagnosticId =
         DiagnosticId::from_u128(305955424195390184883220102469231911115);
@@ -47,10 +45,8 @@ impl WgpuResourceDiagnosticsPlugin {
             10,
         ));
 
-        diagnostics.add(Diagnostic::new(Self::SWAP_CHAINS, "swap_chains", 10));
-
         diagnostics.add(Diagnostic::new(
-            Self::SWAP_CHAIN_OUTPUTS,
+            Self::SURFACE_FRAMES,
             "swap_chain_outputs",
             10,
         ));
@@ -99,19 +95,10 @@ impl WgpuResourceDiagnosticsPlugin {
         );
 
         diagnostics.add_measurement(
-            Self::SWAP_CHAINS,
+            Self::SURFACE_FRAMES,
             render_resource_context
                 .resources
-                .window_swap_chains
-                .read()
-                .len() as f64,
-        );
-
-        diagnostics.add_measurement(
-            Self::SWAP_CHAIN_OUTPUTS,
-            render_resource_context
-                .resources
-                .swap_chain_frames
+                .surface_textures
                 .read()
                 .len() as f64,
         );
diff --git a/crates/bevy_wgpu/src/lib.rs b/crates/bevy_wgpu/src/lib.rs
index 5722f649d1..b5c730735e 100644
--- a/crates/bevy_wgpu/src/lib.rs
+++ b/crates/bevy_wgpu/src/lib.rs
@@ -26,15 +26,12 @@ pub enum WgpuFeature {
     TimestampQuery,
     PipelineStatisticsQuery,
     MappablePrimaryBuffers,
-    SampledTextureBindingArray,
-    SampledTextureArrayDynamicIndexing,
-    SampledTextureArrayNonUniformIndexing,
     UnsizedBindingArray,
     MultiDrawIndirect,
     MultiDrawIndirectCount,
     PushConstants,
     AddressModeClampToBorder,
-    NonFillPolygonMode,
+    PolygonModeLine,
     TextureCompressionEtc2,
     TextureCompressionAstcLdr,
     TextureAdapterSpecificFormatFeatures,
@@ -67,6 +64,8 @@ pub struct WgpuLimits {
     pub max_vertex_buffers: u32,
     pub max_vertex_attributes: u32,
     pub max_vertex_buffer_array_stride: u32,
+    pub min_storage_buffer_offset_alignment: u32,
+    pub min_uniform_buffer_offset_alignment: u32,
 }
 
 impl Default for WgpuLimits {
@@ -93,6 +92,8 @@ impl Default for WgpuLimits {
             max_vertex_buffers: default.max_vertex_buffers,
             max_vertex_attributes: default.max_vertex_attributes,
             max_vertex_buffer_array_stride: default.max_vertex_buffer_array_stride,
+            min_storage_buffer_offset_alignment: default.min_storage_buffer_offset_alignment,
+            min_uniform_buffer_offset_alignment: default.min_uniform_buffer_offset_alignment,
         }
     }
 }
diff --git a/crates/bevy_wgpu/src/renderer/wgpu_render_context.rs b/crates/bevy_wgpu/src/renderer/wgpu_render_context.rs
index d2aba29fa7..65f09b5fb1 100644
--- a/crates/bevy_wgpu/src/renderer/wgpu_render_context.rs
+++ b/crates/bevy_wgpu/src/renderer/wgpu_render_context.rs
@@ -231,8 +231,15 @@ fn get_texture_view<'a>(
                 panic!("Color attachment {} does not exist.", name);
             }
         },
-        TextureAttachment::Id(render_resource) => refs.textures.get(render_resource).unwrap_or_else(|| &refs.swap_chain_frames.get(render_resource).unwrap().output.view),
-        TextureAttachment::Input(_) => panic!("Encountered unset `TextureAttachment::Input`. The `RenderGraph` executor should always set `TextureAttachment::Inputs` to `TextureAttachment::RenderResource` before running. This is a bug, please report it!"),
+        TextureAttachment::Id(render_resource) => refs
+            .textures
+            .get(render_resource)
+            .unwrap_or_else(|| &refs.surface_textures.get(render_resource).unwrap().0),
+        TextureAttachment::Input(_) => panic!(
+            "Encountered unset `TextureAttachment::Input`. The `RenderGraph` executor should \
+            always set `TextureAttachment::Inputs` to `TextureAttachment::RenderResource` before \
+            running. This is a bug, please report it!"
+        ),
     }
 }
 
diff --git a/crates/bevy_wgpu/src/renderer/wgpu_render_resource_context.rs b/crates/bevy_wgpu/src/renderer/wgpu_render_resource_context.rs
index 8e53d3c292..3031e7ca6e 100644
--- a/crates/bevy_wgpu/src/renderer/wgpu_render_resource_context.rs
+++ b/crates/bevy_wgpu/src/renderer/wgpu_render_resource_context.rs
@@ -31,7 +31,8 @@ pub struct WgpuRenderResourceContext {
 }
 
 pub const COPY_BYTES_PER_ROW_ALIGNMENT: usize = wgpu::COPY_BYTES_PER_ROW_ALIGNMENT as usize;
-pub const BIND_BUFFER_ALIGNMENT: usize = wgpu::BIND_BUFFER_ALIGNMENT as usize;
+// TODO: fix this?
+pub const BIND_BUFFER_ALIGNMENT: usize = 256;
 pub const COPY_BUFFER_ALIGNMENT: usize = wgpu::COPY_BUFFER_ALIGNMENT as usize;
 pub const PUSH_CONSTANT_ALIGNMENT: u32 = wgpu::PUSH_CONSTANT_ALIGNMENT;
 
@@ -94,6 +95,7 @@ impl WgpuRenderResourceContext {
                     y: source_origin[1],
                     z: source_origin[2],
                 },
+                aspect: wgpu::TextureAspect::All,
             },
             wgpu::ImageCopyTexture {
                 texture: destination,
@@ -103,6 +105,7 @@ impl WgpuRenderResourceContext {
                     y: destination_origin[1],
                     z: destination_origin[2],
                 },
+                aspect: wgpu::TextureAspect::All,
             },
             size.wgpu_into(),
         )
@@ -134,6 +137,7 @@ impl WgpuRenderResourceContext {
                     y: source_origin[1],
                     z: source_origin[2],
                 },
+                aspect: wgpu::TextureAspect::All,
             },
             wgpu::ImageCopyBuffer {
                 buffer: destination,
@@ -181,6 +185,7 @@ impl WgpuRenderResourceContext {
                     y: destination_origin[1],
                     z: destination_origin[2],
                 },
+                aspect: wgpu::TextureAspect::All,
             },
             size.wgpu_into(),
         );
@@ -206,11 +211,11 @@ impl WgpuRenderResourceContext {
                 let shader_stage = if binding.shader_stage
                     == BindingShaderStage::VERTEX | BindingShaderStage::FRAGMENT
                 {
-                    wgpu::ShaderStage::VERTEX | wgpu::ShaderStage::FRAGMENT
+                    wgpu::ShaderStages::VERTEX | wgpu::ShaderStages::FRAGMENT
                 } else if binding.shader_stage == BindingShaderStage::VERTEX {
-                    wgpu::ShaderStage::VERTEX
+                    wgpu::ShaderStages::VERTEX
                 } else if binding.shader_stage == BindingShaderStage::FRAGMENT {
-                    wgpu::ShaderStage::FRAGMENT
+                    wgpu::ShaderStages::FRAGMENT
                 } else {
                     panic!("Invalid binding shader stage.")
                 };
@@ -230,14 +235,15 @@ impl WgpuRenderResourceContext {
         bind_group_layouts.insert(descriptor.id, bind_group_layout);
     }
 
-    fn try_next_swap_chain_texture(&self, window_id: bevy_window::WindowId) -> Option<TextureId> {
-        let mut window_swap_chains = self.resources.window_swap_chains.write();
-        let mut swap_chain_outputs = self.resources.swap_chain_frames.write();
+    fn try_next_surface_frame(&self, window_id: bevy_window::WindowId) -> Option<TextureId> {
+        let mut window_surfaces = self.resources.window_surfaces.write();
+        let mut surface_frames = self.resources.surface_textures.write();
 
-        let window_swap_chain = window_swap_chains.get_mut(&window_id).unwrap();
-        let next_texture = window_swap_chain.get_current_frame().ok()?;
+        let window_surface = window_surfaces.get_mut(&window_id).unwrap();
+        let next_texture = window_surface.get_current_texture().ok()?;
+        let view = next_texture.texture.create_view(&Default::default());
         let id = TextureId::new();
-        swap_chain_outputs.insert(id, next_texture);
+        surface_frames.insert(id, (view, next_texture));
         Some(id)
     }
 }
@@ -339,7 +345,6 @@ impl RenderResourceContext for WgpuRenderResourceContext {
             .create_shader_module(&wgpu::ShaderModuleDescriptor {
                 label: None,
                 source: wgpu::ShaderSource::SpirV(spirv),
-                flags: Default::default(),
             });
         shader_modules.insert(shader_handle.clone_weak(), shader_module);
     }
@@ -358,43 +363,39 @@ impl RenderResourceContext for WgpuRenderResourceContext {
         self.create_shader_module_from_source(shader_handle, shader);
     }
 
-    fn create_swap_chain(&self, window: &Window) {
+    fn configure_surface(&self, window: &Window) {
         let surfaces = self.resources.window_surfaces.read();
-        let mut window_swap_chains = self.resources.window_swap_chains.write();
 
-        let swap_chain_descriptor: wgpu::SwapChainDescriptor = window.wgpu_into();
+        let surface_configuration: wgpu::SurfaceConfiguration = window.wgpu_into();
         let surface = surfaces
             .get(&window.id())
             .expect("No surface found for window.");
-        let swap_chain = self
-            .device
-            .create_swap_chain(surface, &swap_chain_descriptor);
-
-        window_swap_chains.insert(window.id(), swap_chain);
+        surface.configure(&self.device, &surface_configuration);
     }
 
-    fn next_swap_chain_texture(&self, window: &bevy_window::Window) -> TextureId {
-        if let Some(texture_id) = self.try_next_swap_chain_texture(window.id()) {
+    fn next_surface_frame(&self, window: &bevy_window::Window) -> TextureId {
+        if let Some(texture_id) = self.try_next_surface_frame(window.id()) {
             texture_id
         } else {
-            self.resources
-                .window_swap_chains
-                .write()
-                .remove(&window.id());
-            self.create_swap_chain(window);
-            self.try_next_swap_chain_texture(window.id())
+            self.resources.window_surfaces.write().remove(&window.id());
+            self.configure_surface(window);
+            self.try_next_surface_frame(window.id())
                 .expect("Failed to acquire next swap chain texture!")
         }
     }
 
-    fn drop_swap_chain_texture(&self, texture: TextureId) {
-        let mut swap_chain_outputs = self.resources.swap_chain_frames.write();
-        swap_chain_outputs.remove(&texture);
+    fn drop_surface_frame(&self, texture: TextureId) {
+        let mut surface_frames = self.resources.surface_textures.write();
+        surface_frames.remove(&texture);
     }
 
-    fn drop_all_swap_chain_textures(&self) {
-        let mut swap_chain_outputs = self.resources.swap_chain_frames.write();
-        swap_chain_outputs.clear();
+    fn drop_all_surface_frames(&self) {
+        let mut surface_frames = self.resources.surface_textures.write();
+        for (_, (_, texture)) in surface_frames.drain() {
+            texture.present();
+        }
+
+        surface_frames.clear();
     }
 
     fn set_asset_resource_untyped(
diff --git a/crates/bevy_wgpu/src/wgpu_renderer.rs b/crates/bevy_wgpu/src/wgpu_renderer.rs
index 4ed697cd33..1dcebadd39 100644
--- a/crates/bevy_wgpu/src/wgpu_renderer.rs
+++ b/crates/bevy_wgpu/src/wgpu_renderer.rs
@@ -24,13 +24,13 @@ pub struct WgpuRenderer {
 impl WgpuRenderer {
     pub async fn new(options: WgpuOptions) -> Self {
         let backend = match options.backend {
-            WgpuBackend::Auto => wgpu::BackendBit::PRIMARY,
-            WgpuBackend::Vulkan => wgpu::BackendBit::VULKAN,
-            WgpuBackend::Metal => wgpu::BackendBit::METAL,
-            WgpuBackend::Dx12 => wgpu::BackendBit::DX12,
-            WgpuBackend::Dx11 => wgpu::BackendBit::DX11,
-            WgpuBackend::Gl => wgpu::BackendBit::GL,
-            WgpuBackend::BrowserWgpu => wgpu::BackendBit::BROWSER_WEBGPU,
+            WgpuBackend::Auto => wgpu::Backends::PRIMARY,
+            WgpuBackend::Vulkan => wgpu::Backends::VULKAN,
+            WgpuBackend::Metal => wgpu::Backends::METAL,
+            WgpuBackend::Dx12 => wgpu::Backends::DX12,
+            WgpuBackend::Dx11 => wgpu::Backends::DX11,
+            WgpuBackend::Gl => wgpu::Backends::GL,
+            WgpuBackend::BrowserWgpu => wgpu::Backends::BROWSER_WEBGPU,
         };
         let instance = wgpu::Instance::new(backend);
 
@@ -42,6 +42,7 @@ impl WgpuRenderer {
                     WgpuPowerOptions::LowPower => wgpu::PowerPreference::LowPower,
                 },
                 compatible_surface: None,
+                ..Default::default()
             })
             .await
             .expect("Unable to find a GPU! Make sure you have installed required drivers!");
@@ -56,12 +57,14 @@ impl WgpuRenderer {
         #[cfg(not(feature = "trace"))]
         let trace_path = None;
 
+        let adapter_limits = adapter.limits();
+
         let (device, queue) = adapter
             .request_device(
                 &wgpu::DeviceDescriptor {
                     label: options.device_label.as_ref().map(|a| a.as_ref()),
                     features: options.features.wgpu_into(),
-                    limits: options.limits.wgpu_into(),
+                    limits: adapter_limits,
                 },
                 trace_path,
             )
@@ -129,7 +132,7 @@ impl WgpuRenderer {
         let render_resource_context = world
             .get_resource::<Box<dyn RenderResourceContext>>()
             .unwrap();
-        render_resource_context.drop_all_swap_chain_textures();
+        render_resource_context.drop_all_surface_frames();
         render_resource_context.remove_stale_bind_groups();
     }
 }
diff --git a/crates/bevy_wgpu/src/wgpu_resources.rs b/crates/bevy_wgpu/src/wgpu_resources.rs
index e3e918a97a..a1ec6878ca 100644
--- a/crates/bevy_wgpu/src/wgpu_resources.rs
+++ b/crates/bevy_wgpu/src/wgpu_resources.rs
@@ -47,7 +47,8 @@ pub struct WgpuBindGroupInfo {
 pub struct WgpuResourcesReadLock<'a> {
     pub buffers: RwLockReadGuard<'a, HashMap<BufferId, Arc<wgpu::Buffer>>>,
     pub textures: RwLockReadGuard<'a, HashMap<TextureId, wgpu::TextureView>>,
-    pub swap_chain_frames: RwLockReadGuard<'a, HashMap<TextureId, wgpu::SwapChainFrame>>,
+    pub surface_textures:
+        RwLockReadGuard<'a, HashMap<TextureId, (wgpu::TextureView, wgpu::SurfaceTexture)>>,
     pub render_pipelines:
         RwLockReadGuard<'a, HashMap<Handle<PipelineDescriptor>, wgpu::RenderPipeline>>,
     pub bind_groups: RwLockReadGuard<'a, HashMap<BindGroupDescriptorId, WgpuBindGroupInfo>>,
@@ -59,7 +60,7 @@ impl<'a> WgpuResourcesReadLock<'a> {
         WgpuResourceRefs {
             buffers: &self.buffers,
             textures: &self.textures,
-            swap_chain_frames: &self.swap_chain_frames,
+            surface_textures: &self.surface_textures,
             render_pipelines: &self.render_pipelines,
             bind_groups: &self.bind_groups,
             used_bind_group_sender: &self.used_bind_group_sender,
@@ -73,7 +74,7 @@ impl<'a> WgpuResourcesReadLock<'a> {
 pub struct WgpuResourceRefs<'a> {
     pub buffers: &'a HashMap<BufferId, Arc<wgpu::Buffer>>,
     pub textures: &'a HashMap<TextureId, wgpu::TextureView>,
-    pub swap_chain_frames: &'a HashMap<TextureId, wgpu::SwapChainFrame>,
+    pub surface_textures: &'a HashMap<TextureId, (wgpu::TextureView, wgpu::SurfaceTexture)>,
     pub render_pipelines: &'a HashMap<Handle<PipelineDescriptor>, wgpu::RenderPipeline>,
     pub bind_groups: &'a HashMap<BindGroupDescriptorId, WgpuBindGroupInfo>,
     pub used_bind_group_sender: &'a Sender<BindGroupId>,
@@ -84,8 +85,8 @@ pub struct WgpuResources {
     pub buffer_infos: Arc<RwLock<HashMap<BufferId, BufferInfo>>>,
     pub texture_descriptors: Arc<RwLock<HashMap<TextureId, TextureDescriptor>>>,
     pub window_surfaces: Arc<RwLock<HashMap<WindowId, wgpu::Surface>>>,
-    pub window_swap_chains: Arc<RwLock<HashMap<WindowId, wgpu::SwapChain>>>,
-    pub swap_chain_frames: Arc<RwLock<HashMap<TextureId, wgpu::SwapChainFrame>>>,
+    pub surface_textures:
+        Arc<RwLock<HashMap<TextureId, (wgpu::TextureView, wgpu::SurfaceTexture)>>>,
     pub buffers: Arc<RwLock<HashMap<BufferId, Arc<wgpu::Buffer>>>>,
     pub texture_views: Arc<RwLock<HashMap<TextureId, wgpu::TextureView>>>,
     pub textures: Arc<RwLock<HashMap<TextureId, wgpu::Texture>>>,
@@ -103,7 +104,7 @@ impl WgpuResources {
         WgpuResourcesReadLock {
             buffers: self.buffers.read(),
             textures: self.texture_views.read(),
-            swap_chain_frames: self.swap_chain_frames.read(),
+            surface_textures: self.surface_textures.read(),
             render_pipelines: self.render_pipelines.read(),
             bind_groups: self.bind_groups.read(),
             used_bind_group_sender: self.bind_group_counter.used_bind_group_sender.clone(),
diff --git a/crates/bevy_wgpu/src/wgpu_type_converter.rs b/crates/bevy_wgpu/src/wgpu_type_converter.rs
index e84f76febb..a1e72e36f6 100644
--- a/crates/bevy_wgpu/src/wgpu_type_converter.rs
+++ b/crates/bevy_wgpu/src/wgpu_type_converter.rs
@@ -13,7 +13,7 @@ use bevy_render::{
     texture::{
         AddressMode, Extent3d, FilterMode, SamplerBorderColor, SamplerDescriptor,
         StorageTextureAccess, TextureDescriptor, TextureDimension, TextureFormat,
-        TextureSampleType, TextureUsage, TextureViewDimension,
+        TextureSampleType, TextureUsages, TextureViewDimension,
     },
 };
 use bevy_window::Window;
@@ -83,11 +83,11 @@ impl WgpuFrom<&VertexAttribute> for wgpu::VertexAttribute {
     }
 }
 
-impl WgpuFrom<InputStepMode> for wgpu::InputStepMode {
+impl WgpuFrom<InputStepMode> for wgpu::VertexStepMode {
     fn from(val: InputStepMode) -> Self {
         match val {
-            InputStepMode::Vertex => wgpu::InputStepMode::Vertex,
-            InputStepMode::Instance => wgpu::InputStepMode::Instance,
+            InputStepMode::Vertex => wgpu::VertexStepMode::Vertex,
+            InputStepMode::Instance => wgpu::VertexStepMode::Instance,
         }
     }
 }
@@ -95,7 +95,7 @@ impl WgpuFrom<InputStepMode> for wgpu::InputStepMode {
 #[derive(Clone, Debug)]
 pub struct OwnedWgpuVertexBufferLayout {
     pub array_stride: wgpu::BufferAddress,
-    pub step_mode: wgpu::InputStepMode,
+    pub step_mode: wgpu::VertexStepMode,
     pub attributes: Vec<wgpu::VertexAttribute>,
 }
 
@@ -137,9 +137,9 @@ impl WgpuFrom<Color> for wgpu::Color {
     }
 }
 
-impl WgpuFrom<BufferUsage> for wgpu::BufferUsage {
+impl WgpuFrom<BufferUsage> for wgpu::BufferUsages {
     fn from(val: BufferUsage) -> Self {
-        wgpu::BufferUsage::from_bits(val.bits()).unwrap()
+        wgpu::BufferUsages::from_bits(val.bits()).unwrap()
     }
 }
 
@@ -190,7 +190,9 @@ impl WgpuFrom<&BindType> for wgpu::BindingType {
             } => wgpu::BindingType::Buffer {
                 ty: BufferBindingType::Uniform,
                 has_dynamic_offset: *has_dynamic_offset,
-                min_binding_size: bind_type.get_uniform_size().and_then(wgpu::BufferSize::new),
+                // FIXME: The line below cause a validation error
+                // min_binding_size: bind_type.get_uniform_size().and_then(wgpu::BufferSize::new),
+                min_binding_size: None,
             },
             BindType::StorageBuffer {
                 has_dynamic_offset,
@@ -200,7 +202,9 @@ impl WgpuFrom<&BindType> for wgpu::BindingType {
                     read_only: *readonly,
                 },
                 has_dynamic_offset: *has_dynamic_offset,
-                min_binding_size: bind_type.get_uniform_size().and_then(wgpu::BufferSize::new),
+                // FIXME: The line below cause a validation error
+                // min_binding_size: bind_type.get_uniform_size().and_then(wgpu::BufferSize::new),
+                min_binding_size: None,
             },
             BindType::Texture {
                 view_dimension,
@@ -346,9 +350,9 @@ impl WgpuFrom<TextureFormat> for wgpu::TextureFormat {
     }
 }
 
-impl WgpuFrom<TextureUsage> for wgpu::TextureUsage {
-    fn from(val: TextureUsage) -> Self {
-        wgpu::TextureUsage::from_bits(val.bits()).unwrap()
+impl WgpuFrom<TextureUsages> for wgpu::TextureUsages {
+    fn from(val: TextureUsages) -> Self {
+        wgpu::TextureUsages::from_bits(val.bits()).unwrap()
     }
 }
 
@@ -526,9 +530,9 @@ impl WgpuFrom<PrimitiveState> for wgpu::PrimitiveState {
     }
 }
 
-impl WgpuFrom<ColorWrite> for wgpu::ColorWrite {
+impl WgpuFrom<ColorWrite> for wgpu::ColorWrites {
     fn from(val: ColorWrite) -> Self {
-        wgpu::ColorWrite::from_bits(val.bits()).unwrap()
+        wgpu::ColorWrites::from_bits(val.bits()).unwrap()
     }
 }
 
@@ -640,10 +644,10 @@ impl WgpuFrom<SamplerBorderColor> for wgpu::SamplerBorderColor {
     }
 }
 
-impl WgpuFrom<&Window> for wgpu::SwapChainDescriptor {
+impl WgpuFrom<&Window> for wgpu::SurfaceConfiguration {
     fn from(window: &Window) -> Self {
-        wgpu::SwapChainDescriptor {
-            usage: wgpu::TextureUsage::RENDER_ATTACHMENT,
+        wgpu::SurfaceConfiguration {
+            usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
             format: TextureFormat::default().wgpu_into(),
             width: window.physical_width().max(1),
             height: window.physical_height().max(1),
@@ -664,21 +668,12 @@ impl WgpuFrom<WgpuFeature> for wgpu::Features {
             WgpuFeature::TimestampQuery => wgpu::Features::TIMESTAMP_QUERY,
             WgpuFeature::PipelineStatisticsQuery => wgpu::Features::PIPELINE_STATISTICS_QUERY,
             WgpuFeature::MappablePrimaryBuffers => wgpu::Features::MAPPABLE_PRIMARY_BUFFERS,
-            WgpuFeature::SampledTextureBindingArray => {
-                wgpu::Features::SAMPLED_TEXTURE_BINDING_ARRAY
-            }
-            WgpuFeature::SampledTextureArrayDynamicIndexing => {
-                wgpu::Features::SAMPLED_TEXTURE_ARRAY_DYNAMIC_INDEXING
-            }
-            WgpuFeature::SampledTextureArrayNonUniformIndexing => {
-                wgpu::Features::SAMPLED_TEXTURE_ARRAY_NON_UNIFORM_INDEXING
-            }
             WgpuFeature::UnsizedBindingArray => wgpu::Features::UNSIZED_BINDING_ARRAY,
             WgpuFeature::MultiDrawIndirect => wgpu::Features::MULTI_DRAW_INDIRECT,
             WgpuFeature::MultiDrawIndirectCount => wgpu::Features::MULTI_DRAW_INDIRECT_COUNT,
             WgpuFeature::PushConstants => wgpu::Features::PUSH_CONSTANTS,
             WgpuFeature::AddressModeClampToBorder => wgpu::Features::ADDRESS_MODE_CLAMP_TO_BORDER,
-            WgpuFeature::NonFillPolygonMode => wgpu::Features::NON_FILL_POLYGON_MODE,
+            WgpuFeature::PolygonModeLine => wgpu::Features::POLYGON_MODE_LINE,
             WgpuFeature::TextureCompressionEtc2 => wgpu::Features::TEXTURE_COMPRESSION_ETC2,
             WgpuFeature::TextureCompressionAstcLdr => wgpu::Features::TEXTURE_COMPRESSION_ASTC_LDR,
             WgpuFeature::TextureAdapterSpecificFormatFeatures => {
@@ -724,6 +719,8 @@ impl WgpuFrom<WgpuLimits> for wgpu::Limits {
             max_vertex_buffers: val.max_vertex_buffers,
             max_vertex_attributes: val.max_vertex_attributes,
             max_vertex_buffer_array_stride: val.max_vertex_buffer_array_stride,
+            min_storage_buffer_offset_alignment: val.min_storage_buffer_offset_alignment,
+            min_uniform_buffer_offset_alignment: val.min_uniform_buffer_offset_alignment,
         }
     }
 }
diff --git a/crates/bevy_window/Cargo.toml b/crates/bevy_window/Cargo.toml
index bbb8f5880e..d4a164549c 100644
--- a/crates/bevy_window/Cargo.toml
+++ b/crates/bevy_window/Cargo.toml
@@ -13,6 +13,7 @@ keywords = ["bevy"]
 bevy_app = { path = "../bevy_app", version = "0.5.0" }
 bevy_math = { path = "../bevy_math", version = "0.5.0" }
 bevy_utils = { path = "../bevy_utils", version = "0.5.0" }
+raw-window-handle = "0.3.0"
 
 # other
 
diff --git a/crates/bevy_window/src/lib.rs b/crates/bevy_window/src/lib.rs
index 00b26de361..c07eecf598 100644
--- a/crates/bevy_window/src/lib.rs
+++ b/crates/bevy_window/src/lib.rs
@@ -1,8 +1,10 @@
 mod event;
+mod raw_window_handle;
 mod system;
 mod window;
 mod windows;
 
+pub use crate::raw_window_handle::*;
 pub use event::*;
 pub use system::*;
 pub use window::*;
diff --git a/crates/bevy_window/src/raw_window_handle.rs b/crates/bevy_window/src/raw_window_handle.rs
new file mode 100644
index 0000000000..76f1411261
--- /dev/null
+++ b/crates/bevy_window/src/raw_window_handle.rs
@@ -0,0 +1,37 @@
+use raw_window_handle::{HasRawWindowHandle, RawWindowHandle};
+
+/// This wrapper exist to enable safely passing a [`RawWindowHandle`] across threads. Extracting the handle
+/// is still an unsafe operation, so the caller must still validate that using the raw handle is safe for a given context.
+#[derive(Debug, Clone)]
+pub struct RawWindowHandleWrapper(RawWindowHandle);
+
+impl RawWindowHandleWrapper {
+    pub(crate) fn new(handle: RawWindowHandle) -> Self {
+        Self(handle)
+    }
+
+    /// # Safety
+    /// This returns a [`HasRawWindowHandle`] impl, which exposes [`RawWindowHandle`]. Some platforms
+    /// have constraints on where/how this handle can be used. For example, some platforms don't support doing window
+    /// operations off of the main thread. The caller must ensure the [`RawWindowHandle`] is only used in valid contexts.
+    pub unsafe fn get_handle(&self) -> HasRawWindowHandleWrapper {
+        HasRawWindowHandleWrapper(self.0)
+    }
+}
+
+// SAFE: RawWindowHandle is just a normal "raw pointer", which doesn't impl Send/Sync. However the pointer is only
+// exposed via an unsafe method that forces the user to make a call for a given platform. (ex: some platforms don't
+// support doing window operations off of the main thread).
+// A recommendation for this pattern (and more context) is available here:
+// https://github.com/rust-windowing/raw-window-handle/issues/59
+unsafe impl Send for RawWindowHandleWrapper {}
+unsafe impl Sync for RawWindowHandleWrapper {}
+
+pub struct HasRawWindowHandleWrapper(RawWindowHandle);
+
+// SAFE: the caller has validated that this is a valid context to get RawWindowHandle
+unsafe impl HasRawWindowHandle for HasRawWindowHandleWrapper {
+    fn raw_window_handle(&self) -> RawWindowHandle {
+        self.0
+    }
+}
diff --git a/crates/bevy_window/src/window.rs b/crates/bevy_window/src/window.rs
index 94b0e1edda..a7a497ff65 100644
--- a/crates/bevy_window/src/window.rs
+++ b/crates/bevy_window/src/window.rs
@@ -1,5 +1,6 @@
 use bevy_math::{DVec2, IVec2, Vec2};
 use bevy_utils::{tracing::warn, Uuid};
+use raw_window_handle::RawWindowHandle;
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
 pub struct WindowId(Uuid);
@@ -20,6 +21,8 @@ impl WindowId {
 
 use std::fmt;
 
+use crate::raw_window_handle::RawWindowHandleWrapper;
+
 impl fmt::Display for WindowId {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         self.0.to_simple().fmt(f)
@@ -123,6 +126,7 @@ pub struct Window {
     cursor_visible: bool,
     cursor_locked: bool,
     physical_cursor_position: Option<DVec2>,
+    raw_window_handle: RawWindowHandleWrapper,
     focused: bool,
     mode: WindowMode,
     #[cfg(target_arch = "wasm32")]
@@ -198,6 +202,7 @@ impl Window {
         physical_height: u32,
         scale_factor: f64,
         position: Option<IVec2>,
+        raw_window_handle: RawWindowHandle,
     ) -> Self {
         Window {
             id,
@@ -216,6 +221,7 @@ impl Window {
             cursor_visible: window_descriptor.cursor_visible,
             cursor_locked: window_descriptor.cursor_locked,
             physical_cursor_position: None,
+            raw_window_handle: RawWindowHandleWrapper::new(raw_window_handle),
             focused: true,
             mode: window_descriptor.mode,
             #[cfg(target_arch = "wasm32")]
@@ -519,6 +525,10 @@ impl Window {
     pub fn is_focused(&self) -> bool {
         self.focused
     }
+
+    pub fn raw_window_handle(&self) -> RawWindowHandleWrapper {
+        self.raw_window_handle.clone()
+    }
 }
 
 #[derive(Debug, Clone)]
diff --git a/crates/bevy_winit/Cargo.toml b/crates/bevy_winit/Cargo.toml
index a531e41680..ad3e58c0d6 100644
--- a/crates/bevy_winit/Cargo.toml
+++ b/crates/bevy_winit/Cargo.toml
@@ -24,6 +24,7 @@ bevy_utils = { path = "../bevy_utils", version = "0.5.0" }
 # other
 winit = { version = "0.25.0", default-features = false }
 approx = { version = "0.5.0", default-features = false }
+raw-window-handle = "0.3.0"
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 winit = { version = "0.25.0", features = ["web-sys"], default-features = false }
diff --git a/crates/bevy_winit/src/lib.rs b/crates/bevy_winit/src/lib.rs
index 97b79131ca..7e47c00222 100644
--- a/crates/bevy_winit/src/lib.rs
+++ b/crates/bevy_winit/src/lib.rs
@@ -26,14 +26,6 @@ use winit::{
 };
 
 use winit::dpi::LogicalSize;
-#[cfg(any(
-    target_os = "linux",
-    target_os = "dragonfly",
-    target_os = "freebsd",
-    target_os = "netbsd",
-    target_os = "openbsd"
-))]
-use winit::platform::unix::EventLoopExtUnix;
 
 #[derive(Default)]
 pub struct WinitPlugin;
@@ -43,6 +35,9 @@ impl Plugin for WinitPlugin {
         app.init_resource::<WinitWindows>()
             .set_runner(winit_runner)
             .add_system_to_stage(CoreStage::PostUpdate, change_window.exclusive_system());
+        let event_loop = EventLoop::new();
+        handle_initial_window_events(&mut app.world, &event_loop);
+        app.insert_non_send_resource(event_loop);
     }
 }
 
@@ -207,21 +202,22 @@ where
 }
 
 pub fn winit_runner(app: App) {
-    winit_runner_with(app, EventLoop::new());
+    winit_runner_with(app);
 }
 
-#[cfg(any(
-    target_os = "linux",
-    target_os = "dragonfly",
-    target_os = "freebsd",
-    target_os = "netbsd",
-    target_os = "openbsd"
-))]
-pub fn winit_runner_any_thread(app: App) {
-    winit_runner_with(app, EventLoop::new_any_thread());
-}
+// #[cfg(any(
+//     target_os = "linux",
+//     target_os = "dragonfly",
+//     target_os = "freebsd",
+//     target_os = "netbsd",
+//     target_os = "openbsd"
+// ))]
+// pub fn winit_runner_any_thread(app: App) {
+//     winit_runner_with(app, EventLoop::new_any_thread());
+// }
 
-pub fn winit_runner_with(mut app: App, mut event_loop: EventLoop<()>) {
+pub fn winit_runner_with(mut app: App) {
+    let mut event_loop = app.world.remove_non_send::<EventLoop<()>>().unwrap();
     let mut create_window_event_reader = ManualEventReader::<CreateWindow>::default();
     let mut app_exit_event_reader = ManualEventReader::<AppExit>::default();
     app.world.insert_non_send(event_loop.create_proxy());
@@ -534,3 +530,22 @@ fn handle_create_window_events(
         });
     }
 }
+
+fn handle_initial_window_events(world: &mut World, event_loop: &EventLoop<()>) {
+    let world = world.cell();
+    let mut winit_windows = world.get_resource_mut::<WinitWindows>().unwrap();
+    let mut windows = world.get_resource_mut::<Windows>().unwrap();
+    let mut create_window_events = world.get_resource_mut::<Events<CreateWindow>>().unwrap();
+    let mut window_created_events = world.get_resource_mut::<Events<WindowCreated>>().unwrap();
+    for create_window_event in create_window_events.drain() {
+        let window = winit_windows.create_window(
+            event_loop,
+            create_window_event.id,
+            &create_window_event.descriptor,
+        );
+        windows.add(window);
+        window_created_events.send(WindowCreated {
+            id: create_window_event.id,
+        });
+    }
+}
diff --git a/crates/bevy_winit/src/winit_windows.rs b/crates/bevy_winit/src/winit_windows.rs
index 8194ddb702..86ca6d3d43 100644
--- a/crates/bevy_winit/src/winit_windows.rs
+++ b/crates/bevy_winit/src/winit_windows.rs
@@ -1,6 +1,7 @@
 use bevy_math::IVec2;
 use bevy_utils::HashMap;
 use bevy_window::{Window, WindowDescriptor, WindowId, WindowMode};
+use raw_window_handle::HasRawWindowHandle;
 use winit::dpi::LogicalSize;
 
 #[derive(Debug, Default)]
@@ -156,6 +157,7 @@ impl WinitWindows {
             .map(|position| IVec2::new(position.x, position.y));
         let inner_size = winit_window.inner_size();
         let scale_factor = winit_window.scale_factor();
+        let raw_window_handle = winit_window.raw_window_handle();
         self.windows.insert(winit_window.id(), winit_window);
         Window::new(
             window_id,
@@ -164,6 +166,7 @@ impl WinitWindows {
             inner_size.height,
             scale_factor,
             position,
+            raw_window_handle,
         )
     }
 
diff --git a/crates/crevice/Cargo.toml b/crates/crevice/Cargo.toml
new file mode 100644
index 0000000000..76d473d0c5
--- /dev/null
+++ b/crates/crevice/Cargo.toml
@@ -0,0 +1,36 @@
+[package]
+name = "crevice"
+description = "Create GLSL-compatible versions of structs with explicitly-initialized padding"
+version = "0.8.0"
+edition = "2021"
+authors = ["Lucien Greathouse <me@lpghatguy.com>"]
+documentation = "https://docs.rs/crevice"
+homepage = "https://github.com/LPGhatguy/crevice"
+repository = "https://github.com/LPGhatguy/crevice"
+readme = "README.md"
+keywords = ["glsl", "std140", "std430"]
+license = "MIT OR Apache-2.0"
+# resolver = "2"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[features]
+default = ["std"]
+std = []
+
+# [workspace]
+# members = ["crevice-derive", "crevice-tests"]
+# default-members = ["crevice-derive", "crevice-tests"]
+
+[dependencies]
+crevice-derive = { version = "0.8.0", path = "crevice-derive" }
+
+bytemuck = "1.4.1"
+mint = "0.5.8"
+
+cgmath = { version = "0.18.0", optional = true }
+glam = { version = "0.20.0", features = ["mint"], optional = true }
+nalgebra = { version = "0.29.0", features = ["mint"], optional = true }
+
+[dev-dependencies]
+insta = "0.16.1"
diff --git a/crates/crevice/LICENSE-APACHE b/crates/crevice/LICENSE-APACHE
new file mode 100644
index 0000000000..d42ecff58b
--- /dev/null
+++ b/crates/crevice/LICENSE-APACHE
@@ -0,0 +1,201 @@
+i                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/crates/crevice/LICENSE-MIT b/crates/crevice/LICENSE-MIT
new file mode 100644
index 0000000000..32c2307fc6
--- /dev/null
+++ b/crates/crevice/LICENSE-MIT
@@ -0,0 +1,19 @@
+Copyright (c) 2020 Lucien Greathouse
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
\ No newline at end of file
diff --git a/crates/crevice/README.md b/crates/crevice/README.md
new file mode 100644
index 0000000000..7e7070178e
--- /dev/null
+++ b/crates/crevice/README.md
@@ -0,0 +1,170 @@
+# Crevice
+
+[![GitHub CI Status](https://github.com/LPGhatguy/crevice/workflows/CI/badge.svg)](https://github.com/LPGhatguy/crevice/actions)
+[![crevice on crates.io](https://img.shields.io/crates/v/crevice.svg)](https://crates.io/crates/crevice)
+[![crevice docs](https://img.shields.io/badge/docs-docs.rs-orange.svg)](https://docs.rs/crevice)
+
+Crevice creates GLSL-compatible versions of types through the power of derive
+macros. Generated structures provide an [`as_bytes`][std140::Std140::as_bytes]
+method to allow safely packing data into buffers for uploading.
+
+Generated structs also implement [`bytemuck::Zeroable`] and
+[`bytemuck::Pod`] for use with other libraries.
+
+Crevice is similar to [`glsl-layout`][glsl-layout], but supports types from many
+math crates, can generate GLSL source from structs, and explicitly initializes
+padding to remove one source of undefined behavior.
+
+Crevice has support for many Rust math libraries via feature flags, and most
+other math libraries by use of the mint crate. Crevice currently supports:
+
+* mint 0.5, enabled by default
+* cgmath 0.18, using the `cgmath` feature
+* nalgebra 0.29, using the `nalgebra` feature
+* glam 0.19, using the `glam` feature
+
+PRs are welcome to add or update math libraries to Crevice.
+
+If your math library is not supported, it's possible to define structs using the
+types from mint and convert your math library's types into mint types. This is
+supported by most Rust math libraries.
+
+Your math library may require you to turn on a feature flag to get mint support.
+For example, cgmath requires the "mint" feature to be enabled to allow
+conversions to and from mint types.
+
+## Examples
+
+### Single Value
+
+Uploading many types can be done by deriving [`AsStd140`][std140::AsStd140] and
+using [`as_std140`][std140::AsStd140::as_std140] and
+[`as_bytes`][std140::Std140::as_bytes] to turn the result into bytes.
+
+```glsl
+uniform MAIN {
+    mat3 orientation;
+    vec3 position;
+    float scale;
+} main;
+```
+
+```rust
+use crevice::std140::{AsStd140, Std140};
+
+#[derive(AsStd140)]
+struct MainUniform {
+    orientation: mint::ColumnMatrix3<f32>,
+    position: mint::Vector3<f32>,
+    scale: f32,
+}
+
+let value = MainUniform {
+    orientation: [
+        [1.0, 0.0, 0.0],
+        [0.0, 1.0, 0.0],
+        [0.0, 0.0, 1.0],
+    ].into(),
+    position: [1.0, 2.0, 3.0].into(),
+    scale: 4.0,
+};
+
+let value_std140 = value.as_std140();
+
+upload_data_to_gpu(value_std140.as_bytes());
+```
+
+### Sequential Types
+
+More complicated data can be uploaded using the std140
+[`Writer`][std140::Writer] type.
+
+```glsl
+struct PointLight {
+    vec3 position;
+    vec3 color;
+    float brightness;
+};
+
+buffer POINT_LIGHTS {
+    uint len;
+    PointLight[] lights;
+} point_lights;
+```
+
+```rust
+use crevice::std140::{self, AsStd140};
+
+#[derive(AsStd140)]
+struct PointLight {
+    position: mint::Vector3<f32>,
+    color: mint::Vector3<f32>,
+    brightness: f32,
+}
+
+let lights = vec![
+    PointLight {
+        position: [0.0, 1.0, 0.0].into(),
+        color: [1.0, 0.0, 0.0].into(),
+        brightness: 0.6,
+    },
+    PointLight {
+        position: [0.0, 4.0, 3.0].into(),
+        color: [1.0, 1.0, 1.0].into(),
+        brightness: 1.0,
+    },
+];
+
+let target_buffer = map_gpu_buffer_for_write();
+let mut writer = std140::Writer::new(target_buffer);
+
+let light_count = lights.len() as u32;
+writer.write(&light_count)?;
+
+// Crevice will automatically insert the required padding to align the
+// PointLight structure correctly. In this case, there will be 12 bytes of
+// padding between the length field and the light list.
+
+writer.write(lights.as_slice())?;
+
+unmap_gpu_buffer();
+
+```
+
+## Features
+
+* `std` (default): Enables [`std::io::Write`]-based structs.
+* `cgmath`: Enables support for types from cgmath.
+* `nalgebra`: Enables support for types from nalgebra.
+* `glam`: Enables support for types from glam.
+
+## Minimum Supported Rust Version (MSRV)
+
+Crevice supports Rust 1.52.1 and newer due to use of new `const fn` features.
+
+[glsl-layout]: https://github.com/rustgd/glsl-layout
+
+[std140::AsStd140]: https://docs.rs/crevice/latest/crevice/std140/trait.AsStd140.html
+[std140::AsStd140::as_std140]: https://docs.rs/crevice/latest/crevice/std140/trait.AsStd140.html#method.as_std140
+[std140::Std140::as_bytes]: https://docs.rs/crevice/latest/crevice/std140/trait.Std140.html#method.as_bytes
+[std140::Writer]: https://docs.rs/crevice/latest/crevice/std140/struct.Writer.html
+
+[`std::io::Write`]: https://doc.rust-lang.org/stable/std/io/trait.Write.html
+
+[`bytemuck::Pod`]: https://docs.rs/bytemuck/latest/bytemuck/trait.Pod.html
+[`bytemuck::Zeroable`]: https://docs.rs/bytemuck/latest/bytemuck/trait.Zeroable.html
+
+## License
+
+Licensed under either of
+
+* Apache License, Version 2.0, ([LICENSE-APACHE](http://www.apache.org/licenses/LICENSE-2.0))
+* MIT license ([LICENSE-MIT](http://opensource.org/licenses/MIT))
+
+at your option.
+
+### Contribution
+
+Unless you explicitly state otherwise, any contribution intentionally submitted
+for inclusion in the work by you, as defined in the Apache-2.0 license, shall
+be dual licensed as above, without any additional terms or conditions.
diff --git a/crates/crevice/README.tpl b/crates/crevice/README.tpl
new file mode 100644
index 0000000000..42ca95cfb8
--- /dev/null
+++ b/crates/crevice/README.tpl
@@ -0,0 +1,25 @@
+# Crevice
+
+{{readme}}
+
+[std140::AsStd140]: https://docs.rs/crevice/latest/crevice/std140/trait.AsStd140.html
+[std140::AsStd140::as_std140]: https://docs.rs/crevice/latest/crevice/std140/trait.AsStd140.html#method.as_std140
+[std140::Std140::as_bytes]: https://docs.rs/crevice/latest/crevice/std140/trait.Std140.html#method.as_bytes
+[std140::Writer]: https://docs.rs/crevice/latest/crevice/std140/struct.Writer.html
+
+[`std::io::Write`]: https://doc.rust-lang.org/stable/std/io/trait.Write.html
+
+[`bytemuck::Pod`]: https://docs.rs/bytemuck/latest/bytemuck/trait.Pod.html
+[`bytemuck::Zeroable`]: https://docs.rs/bytemuck/latest/bytemuck/trait.Zeroable.html
+
+## License
+
+Licensed under either of
+
+ * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
+ * MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
+
+at your option.
+
+### Contribution
+Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.
\ No newline at end of file
diff --git a/crates/crevice/crevice-derive/Cargo.toml b/crates/crevice/crevice-derive/Cargo.toml
new file mode 100644
index 0000000000..1d64fbb673
--- /dev/null
+++ b/crates/crevice/crevice-derive/Cargo.toml
@@ -0,0 +1,26 @@
+[package]
+name = "crevice-derive"
+description = "Derive crate for the 'crevice' crate"
+version = "0.8.0"
+edition = "2018"
+authors = ["Lucien Greathouse <me@lpghatguy.com>"]
+documentation = "https://docs.rs/crevice-derive"
+homepage = "https://github.com/LPGhatguy/crevice"
+repository = "https://github.com/LPGhatguy/crevice"
+license = "MIT OR Apache-2.0"
+
+[features]
+default = []
+
+# Enable methods that let you introspect into the generated structs.
+debug-methods = []
+
+[lib]
+proc-macro = true
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+syn = "1.0.40"
+quote = "1.0.7"
+proc-macro2 = "1.0.21"
diff --git a/crates/crevice/crevice-derive/src/glsl.rs b/crates/crevice/crevice-derive/src/glsl.rs
new file mode 100644
index 0000000000..fd74f0cd91
--- /dev/null
+++ b/crates/crevice/crevice-derive/src/glsl.rs
@@ -0,0 +1,49 @@
+use proc_macro2::{Literal, TokenStream};
+use quote::quote;
+use syn::{parse_quote, Data, DeriveInput, Fields, Path};
+
+pub fn emit(input: DeriveInput) -> TokenStream {
+    let fields = match &input.data {
+        Data::Struct(data) => match &data.fields {
+            Fields::Named(fields) => fields,
+            Fields::Unnamed(_) => panic!("Tuple structs are not supported"),
+            Fields::Unit => panic!("Unit structs are not supported"),
+        },
+        Data::Enum(_) | Data::Union(_) => panic!("Only structs are supported"),
+    };
+
+    let base_trait_path: Path = parse_quote!(::crevice::glsl::Glsl);
+    let struct_trait_path: Path = parse_quote!(::crevice::glsl::GlslStruct);
+
+    let name = input.ident;
+    let name_str = Literal::string(&name.to_string());
+
+    let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
+
+    let glsl_fields = fields.named.iter().map(|field| {
+        let field_ty = &field.ty;
+        let field_name_str = Literal::string(&field.ident.as_ref().unwrap().to_string());
+        let field_as = quote! {<#field_ty as ::crevice::glsl::GlslArray>};
+
+        quote! {
+            s.push_str("\t");
+            s.push_str(#field_as::NAME);
+            s.push_str(" ");
+            s.push_str(#field_name_str);
+            <#field_as::ArraySize as ::crevice::glsl::DimensionList>::push_to_string(s);
+            s.push_str(";\n");
+        }
+    });
+
+    quote! {
+        unsafe impl #impl_generics #base_trait_path for #name #ty_generics #where_clause {
+            const NAME: &'static str = #name_str;
+        }
+
+        unsafe impl #impl_generics #struct_trait_path for #name #ty_generics #where_clause {
+            fn enumerate_fields(s: &mut String) {
+                #( #glsl_fields )*
+            }
+        }
+    }
+}
diff --git a/crates/crevice/crevice-derive/src/layout.rs b/crates/crevice/crevice-derive/src/layout.rs
new file mode 100644
index 0000000000..0819a01cf2
--- /dev/null
+++ b/crates/crevice/crevice-derive/src/layout.rs
@@ -0,0 +1,288 @@
+use proc_macro2::{Span, TokenStream};
+use quote::{format_ident, quote};
+use syn::{parse_quote, Data, DeriveInput, Fields, Ident, Path, Type};
+
+pub fn emit(
+    input: DeriveInput,
+    trait_name: &'static str,
+    mod_name: &'static str,
+    min_struct_alignment: usize,
+) -> TokenStream {
+    let mod_name = Ident::new(mod_name, Span::call_site());
+    let trait_name = Ident::new(trait_name, Span::call_site());
+
+    let mod_path: Path = parse_quote!(::crevice::#mod_name);
+    let trait_path: Path = parse_quote!(#mod_path::#trait_name);
+
+    let as_trait_name = format_ident!("As{}", trait_name);
+    let as_trait_path: Path = parse_quote!(#mod_path::#as_trait_name);
+    let as_trait_method = format_ident!("as_{}", mod_name);
+    let from_trait_method = format_ident!("from_{}", mod_name);
+
+    let padded_name = format_ident!("{}Padded", trait_name);
+    let padded_path: Path = parse_quote!(#mod_path::#padded_name);
+
+    let visibility = input.vis;
+    let input_name = input.ident;
+    let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
+
+    let generated_name = format_ident!("{}{}", trait_name, input_name);
+
+    // Crevice's derive only works on regular structs. We could potentially
+    // support transparent tuple structs in the future.
+    let fields: Vec<_> = match &input.data {
+        Data::Struct(data) => match &data.fields {
+            Fields::Named(fields) => fields.named.iter().collect(),
+            Fields::Unnamed(_) => panic!("Tuple structs are not supported"),
+            Fields::Unit => panic!("Unit structs are not supported"),
+        },
+        Data::Enum(_) | Data::Union(_) => panic!("Only structs are supported"),
+    };
+
+    // Gives the layout-specific version of the given type.
+    let layout_version_of_ty = |ty: &Type| {
+        quote! {
+            <#ty as #as_trait_path>::Output
+        }
+    };
+
+    // Gives an expression returning the layout-specific alignment for the type.
+    let layout_alignment_of_ty = |ty: &Type| {
+        quote! {
+            <<#ty as #as_trait_path>::Output as #trait_path>::ALIGNMENT
+        }
+    };
+
+    // Gives an expression telling whether the type should have trailing padding
+    // at least equal to its alignment.
+    let layout_pad_at_end_of_ty = |ty: &Type| {
+        quote! {
+            <<#ty as #as_trait_path>::Output as #trait_path>::PAD_AT_END
+        }
+    };
+
+    let field_alignments = fields.iter().map(|field| layout_alignment_of_ty(&field.ty));
+    let struct_alignment = quote! {
+        ::crevice::internal::max_arr([
+            #min_struct_alignment,
+            #(#field_alignments,)*
+        ])
+    };
+
+    // Generate names for each padding calculation function.
+    let pad_fns: Vec<_> = (0..fields.len())
+        .map(|index| format_ident!("_{}__{}Pad{}", input_name, trait_name, index))
+        .collect();
+
+    // Computes the offset immediately AFTER the field with the given index.
+    //
+    // This function depends on the generated padding calculation functions to
+    // do correct alignment. Be careful not to cause recursion!
+    let offset_after_field = |target: usize| {
+        let mut output = vec![quote!(0usize)];
+
+        for index in 0..=target {
+            let field_ty = &fields[index].ty;
+            let layout_ty = layout_version_of_ty(field_ty);
+
+            output.push(quote! {
+                + ::core::mem::size_of::<#layout_ty>()
+            });
+
+            // For every field except our target field, also add the generated
+            // padding. Padding occurs after each field, so it isn't included in
+            // this value.
+            if index < target {
+                let pad_fn = &pad_fns[index];
+                output.push(quote! {
+                    + #pad_fn()
+                });
+            }
+        }
+
+        output.into_iter().collect::<TokenStream>()
+    };
+
+    let pad_fn_impls: TokenStream = fields
+        .iter()
+        .enumerate()
+        .map(|(index, prev_field)| {
+            let pad_fn = &pad_fns[index];
+
+            let starting_offset = offset_after_field(index);
+            let prev_field_has_end_padding = layout_pad_at_end_of_ty(&prev_field.ty);
+            let prev_field_alignment = layout_alignment_of_ty(&prev_field.ty);
+
+            let next_field_or_self_alignment = fields
+                .get(index + 1)
+                .map(|next_field| layout_alignment_of_ty(&next_field.ty))
+                .unwrap_or(quote!(#struct_alignment));
+
+            quote! {
+                /// Tells how many bytes of padding have to be inserted after
+                /// the field with index #index.
+                #[allow(non_snake_case)]
+                const fn #pad_fn() -> usize {
+                    // First up, calculate our offset into the struct so far.
+                    // We'll use this value to figure out how far out of
+                    // alignment we are.
+                    let starting_offset = #starting_offset;
+
+                    // If the previous field is a struct or array, we must align
+                    // the next field to at least THAT field's alignment.
+                    let min_alignment = if #prev_field_has_end_padding {
+                        #prev_field_alignment
+                    } else {
+                        0
+                    };
+
+                    // We set our target alignment to the larger of the
+                    // alignment due to the previous field and the alignment
+                    // requirement of the next field.
+                    let alignment = ::crevice::internal::max(
+                        #next_field_or_self_alignment,
+                        min_alignment,
+                    );
+
+                    // Using everything we've got, compute our padding amount.
+                    ::crevice::internal::align_offset(starting_offset, alignment)
+                }
+            }
+        })
+        .collect();
+
+    let generated_struct_fields: TokenStream = fields
+        .iter()
+        .enumerate()
+        .map(|(index, field)| {
+            let field_name = field.ident.as_ref().unwrap();
+            let field_ty = layout_version_of_ty(&field.ty);
+            let pad_field_name = format_ident!("_pad{}", index);
+            let pad_fn = &pad_fns[index];
+
+            quote! {
+                #field_name: #field_ty,
+                #pad_field_name: [u8; #pad_fn()],
+            }
+        })
+        .collect();
+
+    let generated_struct_field_init: TokenStream = fields
+        .iter()
+        .map(|field| {
+            let field_name = field.ident.as_ref().unwrap();
+
+            quote! {
+                #field_name: self.#field_name.#as_trait_method(),
+            }
+        })
+        .collect();
+
+    let input_struct_field_init: TokenStream = fields
+        .iter()
+        .map(|field| {
+            let field_name = field.ident.as_ref().unwrap();
+
+            quote! {
+                #field_name: #as_trait_path::#from_trait_method(input.#field_name),
+            }
+        })
+        .collect();
+
+    let struct_definition = quote! {
+        #[derive(Debug, Clone, Copy)]
+        #[repr(C)]
+        #[allow(non_snake_case)]
+        #visibility struct #generated_name #ty_generics #where_clause {
+            #generated_struct_fields
+        }
+    };
+
+    let debug_methods = if cfg!(feature = "debug-methods") {
+        let debug_fields: TokenStream = fields
+            .iter()
+            .map(|field| {
+                let field_name = field.ident.as_ref().unwrap();
+                let field_ty = &field.ty;
+
+                quote! {
+                    fields.push(Field {
+                        name: stringify!(#field_name),
+                        size: ::core::mem::size_of::<#field_ty>(),
+                        offset: (&zeroed.#field_name as *const _ as usize)
+                            - (&zeroed as *const _ as usize),
+                    });
+                }
+            })
+            .collect();
+
+        quote! {
+            impl #impl_generics #generated_name #ty_generics #where_clause {
+                fn debug_metrics() -> String {
+                    let size = ::core::mem::size_of::<Self>();
+                    let align = <Self as #trait_path>::ALIGNMENT;
+
+                    let zeroed: Self = ::crevice::internal::bytemuck::Zeroable::zeroed();
+
+                    #[derive(Debug)]
+                    struct Field {
+                        name: &'static str,
+                        offset: usize,
+                        size: usize,
+                    }
+                    let mut fields = Vec::new();
+
+                    #debug_fields
+
+                    format!("Size {}, Align {}, fields: {:#?}", size, align, fields)
+                }
+
+                fn debug_definitions() -> &'static str {
+                    stringify!(
+                        #struct_definition
+                        #pad_fn_impls
+                    )
+                }
+            }
+        }
+    } else {
+        quote!()
+    };
+
+    quote! {
+        #pad_fn_impls
+        #struct_definition
+
+        unsafe impl #impl_generics ::crevice::internal::bytemuck::Zeroable for #generated_name #ty_generics #where_clause {}
+        unsafe impl #impl_generics ::crevice::internal::bytemuck::Pod for #generated_name #ty_generics #where_clause {}
+
+        unsafe impl #impl_generics #mod_path::#trait_name for #generated_name #ty_generics #where_clause {
+            const ALIGNMENT: usize = #struct_alignment;
+            const PAD_AT_END: bool = true;
+            type Padded = #padded_path<Self, {::crevice::internal::align_offset(
+                    ::core::mem::size_of::<#generated_name>(),
+                    #struct_alignment
+                )}>;
+        }
+
+        impl #impl_generics #as_trait_path for #input_name #ty_generics #where_clause {
+            type Output = #generated_name;
+
+            fn #as_trait_method(&self) -> Self::Output {
+                Self::Output {
+                    #generated_struct_field_init
+
+                    ..::crevice::internal::bytemuck::Zeroable::zeroed()
+                }
+            }
+
+            fn #from_trait_method(input: Self::Output) -> Self {
+                Self {
+                    #input_struct_field_init
+                }
+            }
+        }
+
+        #debug_methods
+    }
+}
diff --git a/crates/crevice/crevice-derive/src/lib.rs b/crates/crevice/crevice-derive/src/lib.rs
new file mode 100644
index 0000000000..ab1012a909
--- /dev/null
+++ b/crates/crevice/crevice-derive/src/lib.rs
@@ -0,0 +1,30 @@
+mod glsl;
+mod layout;
+
+use proc_macro::TokenStream as CompilerTokenStream;
+
+use syn::{parse_macro_input, DeriveInput};
+
+#[proc_macro_derive(AsStd140)]
+pub fn derive_as_std140(input: CompilerTokenStream) -> CompilerTokenStream {
+    let input = parse_macro_input!(input as DeriveInput);
+    let expanded = layout::emit(input, "Std140", "std140", 16);
+
+    CompilerTokenStream::from(expanded)
+}
+
+#[proc_macro_derive(AsStd430)]
+pub fn derive_as_std430(input: CompilerTokenStream) -> CompilerTokenStream {
+    let input = parse_macro_input!(input as DeriveInput);
+    let expanded = layout::emit(input, "Std430", "std430", 0);
+
+    CompilerTokenStream::from(expanded)
+}
+
+#[proc_macro_derive(GlslStruct)]
+pub fn derive_glsl_struct(input: CompilerTokenStream) -> CompilerTokenStream {
+    let input = parse_macro_input!(input as DeriveInput);
+    let expanded = glsl::emit(input);
+
+    CompilerTokenStream::from(expanded)
+}
diff --git a/crates/crevice/crevice-tests/Cargo.toml b/crates/crevice/crevice-tests/Cargo.toml
new file mode 100644
index 0000000000..a6f8605c5a
--- /dev/null
+++ b/crates/crevice/crevice-tests/Cargo.toml
@@ -0,0 +1,20 @@
+[package]
+name = "crevice-tests"
+version = "0.1.0"
+edition = "2018"
+
+[features]
+wgpu-validation = ["wgpu", "naga", "futures"]
+
+[dependencies]
+crevice = { path = ".." }
+crevice-derive = { path = "../crevice-derive", features = ["debug-methods"] }
+
+anyhow = "1.0.44"
+bytemuck = "1.7.2"
+memoffset = "0.6.4"
+mint = "0.5.5"
+
+futures = { version = "0.3.17", features = ["executor"], optional = true }
+naga = { version = "0.7.0", features = ["glsl-in", "wgsl-out"], optional = true }
+wgpu = { version = "0.11.0", optional = true }
diff --git a/crates/crevice/crevice-tests/src/gpu.rs b/crates/crevice/crevice-tests/src/gpu.rs
new file mode 100644
index 0000000000..517e8d7a46
--- /dev/null
+++ b/crates/crevice/crevice-tests/src/gpu.rs
@@ -0,0 +1,268 @@
+use std::borrow::Cow;
+use std::fmt::Debug;
+use std::marker::PhantomData;
+
+use crevice::glsl::{Glsl, GlslStruct};
+use crevice::std140::{AsStd140, Std140};
+use crevice::std430::{AsStd430, Std430};
+use futures::executor::block_on;
+use wgpu::util::DeviceExt;
+
+const BASE_SHADER: &str = "#version 450
+
+{struct_definition}
+
+layout({layout}, set = 0, binding = 0) readonly buffer INPUT {
+    {struct_name} in_data;
+};
+
+layout({layout}, set = 0, binding = 1) buffer OUTPUT {
+    {struct_name} out_data;
+};
+
+void main() {
+    out_data = in_data;
+}";
+
+pub fn test_round_trip_struct<T: Debug + PartialEq + AsStd140 + AsStd430 + GlslStruct>(value: T) {
+    let shader_std140 = glsl_shader_for_struct::<T>("std140");
+    let shader_std430 = glsl_shader_for_struct::<T>("std430");
+
+    let context = Context::new();
+    context.test_round_trip_std140(&shader_std140, &value);
+    context.test_round_trip_std430(&shader_std430, &value);
+}
+
+pub fn test_round_trip_primitive<T: Debug + PartialEq + AsStd140 + AsStd430 + Glsl>(value: T) {
+    let shader_std140 = glsl_shader_for_primitive::<T>("std140");
+    let shader_std430 = glsl_shader_for_primitive::<T>("std430");
+
+    let context = Context::new();
+    context.test_round_trip_std140(&shader_std140, &value);
+    context.test_round_trip_std430(&shader_std430, &value);
+}
+
+fn glsl_shader_for_struct<T: GlslStruct>(layout: &str) -> String {
+    BASE_SHADER
+        .replace("{struct_name}", T::NAME)
+        .replace("{struct_definition}", &T::glsl_definition())
+        .replace("{layout}", layout)
+}
+
+fn glsl_shader_for_primitive<T: Glsl>(layout: &str) -> String {
+    BASE_SHADER
+        .replace("{struct_name}", T::NAME)
+        .replace("{struct_definition}", "")
+        .replace("{layout}", layout)
+}
+
+fn compile_glsl(glsl: &str) -> String {
+    match compile(glsl) {
+        Ok(shader) => shader,
+        Err(err) => {
+            eprintln!("Bad shader: {}", glsl);
+            panic!("{}", err);
+        }
+    }
+}
+
+struct Context<T> {
+    device: wgpu::Device,
+    queue: wgpu::Queue,
+    _phantom: PhantomData<*const T>,
+}
+
+impl<T> Context<T>
+where
+    T: Debug + PartialEq + AsStd140 + AsStd430 + Glsl,
+{
+    fn new() -> Self {
+        let (device, queue) = setup();
+        Self {
+            device,
+            queue,
+            _phantom: PhantomData,
+        }
+    }
+
+    fn test_round_trip_std140(&self, glsl_shader: &str, value: &T) {
+        let mut data = Vec::new();
+        data.extend_from_slice(value.as_std140().as_bytes());
+
+        let wgsl_shader = compile_glsl(glsl_shader);
+        let bytes = self.round_trip(&wgsl_shader, &data);
+
+        let std140 = bytemuck::from_bytes::<<T as AsStd140>::Output>(&bytes);
+        let output = T::from_std140(*std140);
+
+        if value != &output {
+            println!(
+                "std140 value did not round-trip through wgpu successfully.\n\
+                Input:  {:?}\n\
+                Output: {:?}\n\n\
+                GLSL shader:\n{}\n\n\
+                WGSL shader:\n{}",
+                value, output, glsl_shader, wgsl_shader,
+            );
+
+            panic!("wgpu round-trip failure for {}", T::NAME);
+        }
+    }
+
+    fn test_round_trip_std430(&self, glsl_shader: &str, value: &T) {
+        let mut data = Vec::new();
+        data.extend_from_slice(value.as_std430().as_bytes());
+
+        let wgsl_shader = compile_glsl(glsl_shader);
+        let bytes = self.round_trip(&wgsl_shader, &data);
+
+        let std430 = bytemuck::from_bytes::<<T as AsStd430>::Output>(&bytes);
+        let output = T::from_std430(*std430);
+
+        if value != &output {
+            println!(
+                "std430 value did not round-trip through wgpu successfully.\n\
+                Input:  {:?}\n\
+                Output: {:?}\n\n\
+                GLSL shader:\n{}\n\n\
+                WGSL shader:\n{}",
+                value, output, glsl_shader, wgsl_shader,
+            );
+
+            panic!("wgpu round-trip failure for {}", T::NAME);
+        }
+    }
+
+    fn round_trip(&self, shader: &str, data: &[u8]) -> Vec<u8> {
+        let input_buffer = self
+            .device
+            .create_buffer_init(&wgpu::util::BufferInitDescriptor {
+                label: Some("Input Buffer"),
+                contents: &data,
+                usage: wgpu::BufferUsages::STORAGE
+                    | wgpu::BufferUsages::COPY_DST
+                    | wgpu::BufferUsages::COPY_SRC,
+            });
+
+        let output_gpu_buffer = self.device.create_buffer(&wgpu::BufferDescriptor {
+            label: Some("Output Buffer"),
+            size: data.len() as wgpu::BufferAddress,
+            usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC,
+            mapped_at_creation: false,
+        });
+
+        let output_cpu_buffer = self.device.create_buffer(&wgpu::BufferDescriptor {
+            label: Some("Output Buffer"),
+            size: data.len() as wgpu::BufferAddress,
+            usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
+            mapped_at_creation: false,
+        });
+
+        let cs_module = self
+            .device
+            .create_shader_module(&wgpu::ShaderModuleDescriptor {
+                label: None,
+                source: wgpu::ShaderSource::Wgsl(Cow::Borrowed(shader)),
+            });
+
+        let compute_pipeline =
+            self.device
+                .create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
+                    label: None,
+                    layout: None,
+                    module: &cs_module,
+                    entry_point: "main",
+                });
+
+        let bind_group_layout = compute_pipeline.get_bind_group_layout(0);
+        let bind_group = self.device.create_bind_group(&wgpu::BindGroupDescriptor {
+            label: None,
+            layout: &bind_group_layout,
+            entries: &[
+                wgpu::BindGroupEntry {
+                    binding: 0,
+                    resource: input_buffer.as_entire_binding(),
+                },
+                wgpu::BindGroupEntry {
+                    binding: 1,
+                    resource: output_gpu_buffer.as_entire_binding(),
+                },
+            ],
+        });
+
+        let mut encoder = self
+            .device
+            .create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
+
+        {
+            let mut cpass =
+                encoder.begin_compute_pass(&wgpu::ComputePassDescriptor { label: None });
+            cpass.set_pipeline(&compute_pipeline);
+            cpass.set_bind_group(0, &bind_group, &[]);
+            cpass.dispatch(1, 1, 1);
+        }
+
+        encoder.copy_buffer_to_buffer(
+            &output_gpu_buffer,
+            0,
+            &output_cpu_buffer,
+            0,
+            data.len() as wgpu::BufferAddress,
+        );
+
+        self.queue.submit(std::iter::once(encoder.finish()));
+
+        let output_slice = output_cpu_buffer.slice(..);
+        let output_future = output_slice.map_async(wgpu::MapMode::Read);
+
+        self.device.poll(wgpu::Maintain::Wait);
+        block_on(output_future).unwrap();
+
+        let output = output_slice.get_mapped_range().to_vec();
+        output_cpu_buffer.unmap();
+
+        output
+    }
+}
+
+fn setup() -> (wgpu::Device, wgpu::Queue) {
+    let instance = wgpu::Instance::new(wgpu::Backends::all());
+    let adapter =
+        block_on(instance.request_adapter(&wgpu::RequestAdapterOptions::default())).unwrap();
+
+    println!("Adapter info: {:#?}", adapter.get_info());
+
+    block_on(adapter.request_device(
+        &wgpu::DeviceDescriptor {
+            label: None,
+            features: wgpu::Features::empty(),
+            limits: wgpu::Limits::downlevel_defaults(),
+        },
+        None,
+    ))
+    .unwrap()
+}
+
+fn compile(glsl_source: &str) -> anyhow::Result<String> {
+    let mut parser = naga::front::glsl::Parser::default();
+
+    let module = parser
+        .parse(
+            &naga::front::glsl::Options {
+                stage: naga::ShaderStage::Compute,
+                defines: Default::default(),
+            },
+            glsl_source,
+        )
+        .map_err(|err| anyhow::format_err!("{:?}", err))?;
+
+    let info = naga::valid::Validator::new(
+        naga::valid::ValidationFlags::default(),
+        naga::valid::Capabilities::all(),
+    )
+    .validate(&module)?;
+
+    let wgsl = naga::back::wgsl::write_string(&module, &info)?;
+
+    Ok(wgsl)
+}
diff --git a/crates/crevice/crevice-tests/src/lib.rs b/crates/crevice/crevice-tests/src/lib.rs
new file mode 100644
index 0000000000..da61b47fb4
--- /dev/null
+++ b/crates/crevice/crevice-tests/src/lib.rs
@@ -0,0 +1,366 @@
+#![cfg(test)]
+
+#[cfg(feature = "wgpu-validation")]
+mod gpu;
+
+#[cfg(feature = "wgpu-validation")]
+use gpu::{test_round_trip_primitive, test_round_trip_struct};
+
+#[cfg(not(feature = "wgpu-validation"))]
+fn test_round_trip_struct<T>(_value: T) {}
+
+#[cfg(not(feature = "wgpu-validation"))]
+fn test_round_trip_primitive<T>(_value: T) {}
+
+#[macro_use]
+mod util;
+
+use crevice::glsl::GlslStruct;
+use crevice::std140::AsStd140;
+use crevice::std430::AsStd430;
+use mint::{ColumnMatrix2, ColumnMatrix3, ColumnMatrix4, Vector2, Vector3, Vector4};
+
+#[test]
+fn two_f32() {
+    #[derive(Debug, PartialEq, AsStd140, AsStd430, GlslStruct)]
+    struct TwoF32 {
+        x: f32,
+        y: f32,
+    }
+
+    assert_std140!((size = 16, align = 16) TwoF32 {
+        x: 0,
+        y: 4,
+    });
+
+    assert_std430!((size = 8, align = 4) TwoF32 {
+        x: 0,
+        y: 4,
+    });
+
+    test_round_trip_struct(TwoF32 { x: 5.0, y: 7.0 });
+}
+
+#[test]
+fn vec2() {
+    #[derive(Debug, PartialEq, AsStd140, AsStd430, GlslStruct)]
+    struct UseVec2 {
+        one: Vector2<f32>,
+    }
+
+    assert_std140!((size = 16, align = 16) UseVec2 {
+        one: 0,
+    });
+
+    test_round_trip_struct(UseVec2 {
+        one: [1.0, 2.0].into(),
+    });
+}
+
+#[test]
+fn mat2_bare() {
+    type Mat2 = ColumnMatrix2<f32>;
+
+    assert_std140!((size = 32, align = 16) Mat2 {
+        x: 0,
+        y: 16,
+    });
+
+    assert_std430!((size = 16, align = 8) Mat2 {
+        x: 0,
+        y: 8,
+    });
+
+    // Naga doesn't work with std140 mat2 values.
+    // https://github.com/gfx-rs/naga/issues/1400
+
+    // test_round_trip_primitive(Mat2 {
+    //     x: [1.0, 2.0].into(),
+    //     y: [3.0, 4.0].into(),
+    // });
+}
+
+#[test]
+fn mat3_bare() {
+    type Mat3 = ColumnMatrix3<f32>;
+
+    assert_std140!((size = 48, align = 16) Mat3 {
+        x: 0,
+        y: 16,
+        z: 32,
+    });
+
+    // Naga produces invalid HLSL for mat3 value.
+    // https://github.com/gfx-rs/naga/issues/1466
+
+    // test_round_trip_primitive(Mat3 {
+    //     x: [1.0, 2.0, 3.0].into(),
+    //     y: [4.0, 5.0, 6.0].into(),
+    //     z: [7.0, 8.0, 9.0].into(),
+    // });
+}
+
+#[test]
+fn mat4_bare() {
+    type Mat4 = ColumnMatrix4<f32>;
+
+    assert_std140!((size = 64, align = 16) Mat4 {
+        x: 0,
+        y: 16,
+        z: 32,
+        w: 48,
+    });
+
+    test_round_trip_primitive(Mat4 {
+        x: [1.0, 2.0, 3.0, 4.0].into(),
+        y: [5.0, 6.0, 7.0, 8.0].into(),
+        z: [9.0, 10.0, 11.0, 12.0].into(),
+        w: [13.0, 14.0, 15.0, 16.0].into(),
+    });
+}
+
+#[test]
+fn mat3() {
+    #[derive(Debug, PartialEq, AsStd140, AsStd430, GlslStruct)]
+    struct TestData {
+        one: ColumnMatrix3<f32>,
+    }
+
+    // Naga produces invalid HLSL for mat3 value.
+    // https://github.com/gfx-rs/naga/issues/1466
+
+    // test_round_trip_struct(TestData {
+    //     one: [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]].into(),
+    // });
+}
+
+#[test]
+fn dvec4() {
+    #[derive(Debug, PartialEq, AsStd140, AsStd430, GlslStruct)]
+    struct UsingDVec4 {
+        doubles: Vector4<f64>,
+    }
+
+    assert_std140!((size = 32, align = 32) UsingDVec4 {
+        doubles: 0,
+    });
+
+    // Naga does not appear to support doubles.
+    // https://github.com/gfx-rs/naga/issues/1272
+
+    // test_round_trip_struct(UsingDVec4 {
+    //     doubles: [1.0, 2.0, 3.0, 4.0].into(),
+    // });
+}
+
+#[test]
+fn four_f64() {
+    #[derive(Debug, PartialEq, AsStd140, AsStd430, GlslStruct)]
+    struct FourF64 {
+        x: f64,
+        y: f64,
+        z: f64,
+        w: f64,
+    }
+
+    assert_std140!((size = 32, align = 16) FourF64 {
+        x: 0,
+        y: 8,
+        z: 16,
+        w: 24,
+    });
+
+    // Naga does not appear to support doubles.
+    // https://github.com/gfx-rs/naga/issues/1272
+
+    // test_round_trip_struct(FourF64 {
+    //     x: 5.0,
+    //     y: 7.0,
+    //     z: 9.0,
+    //     w: 11.0,
+    // });
+}
+
+#[test]
+fn two_vec3() {
+    #[derive(Debug, PartialEq, AsStd140, AsStd430, GlslStruct)]
+    struct TwoVec3 {
+        one: Vector3<f32>,
+        two: Vector3<f32>,
+    }
+
+    print_std140!(TwoVec3);
+    print_std430!(TwoVec3);
+
+    assert_std140!((size = 32, align = 16) TwoVec3 {
+        one: 0,
+        two: 16,
+    });
+
+    assert_std430!((size = 32, align = 16) TwoVec3 {
+        one: 0,
+        two: 16,
+    });
+
+    test_round_trip_struct(TwoVec3 {
+        one: [1.0, 2.0, 3.0].into(),
+        two: [4.0, 5.0, 6.0].into(),
+    });
+}
+
+#[test]
+fn two_vec4() {
+    #[derive(Debug, PartialEq, AsStd140, AsStd430, GlslStruct)]
+    struct TwoVec4 {
+        one: Vector4<f32>,
+        two: Vector4<f32>,
+    }
+
+    assert_std140!((size = 32, align = 16) TwoVec4 {
+        one: 0,
+        two: 16,
+    });
+
+    test_round_trip_struct(TwoVec4 {
+        one: [1.0, 2.0, 3.0, 4.0].into(),
+        two: [5.0, 6.0, 7.0, 8.0].into(),
+    });
+}
+
+#[test]
+fn vec3_then_f32() {
+    #[derive(Debug, PartialEq, AsStd140, AsStd430, GlslStruct)]
+    struct Vec3ThenF32 {
+        one: Vector3<f32>,
+        two: f32,
+    }
+
+    assert_std140!((size = 16, align = 16) Vec3ThenF32 {
+        one: 0,
+        two: 12,
+    });
+
+    test_round_trip_struct(Vec3ThenF32 {
+        one: [1.0, 2.0, 3.0].into(),
+        two: 4.0,
+    });
+}
+
+#[test]
+fn mat3_padding() {
+    #[derive(Debug, PartialEq, AsStd140, AsStd430, GlslStruct)]
+    struct Mat3Padding {
+        // Three rows of 16 bytes (3x f32 + 4 bytes padding)
+        one: mint::ColumnMatrix3<f32>,
+        two: f32,
+    }
+
+    assert_std140!((size = 64, align = 16) Mat3Padding {
+        one: 0,
+        two: 48,
+    });
+
+    // Naga produces invalid HLSL for mat3 value.
+    // https://github.com/gfx-rs/naga/issues/1466
+
+    // test_round_trip_struct(Mat3Padding {
+    //     one: [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]].into(),
+    //     two: 10.0,
+    // });
+}
+
+#[test]
+fn padding_after_struct() {
+    #[derive(AsStd140)]
+    struct TwoF32 {
+        x: f32,
+    }
+
+    #[derive(AsStd140)]
+    struct PaddingAfterStruct {
+        base_value: TwoF32,
+        // There should be 8 bytes of padding inserted here.
+        small_field: f32,
+    }
+
+    assert_std140!((size = 32, align = 16) PaddingAfterStruct {
+        base_value: 0,
+        small_field: 16,
+    });
+}
+
+#[test]
+fn proper_offset_calculations_for_differing_member_sizes() {
+    #[derive(AsStd140)]
+    struct Foo {
+        x: f32,
+    }
+
+    #[derive(AsStd140)]
+    struct Bar {
+        first: Foo,
+        second: Foo,
+    }
+
+    #[derive(AsStd140)]
+    struct Outer {
+        leading: Bar,
+        trailing: Foo,
+    }
+
+    // Offset  Size  Contents
+    // 0       4     Bar.leading.first.x
+    // 4       12    [padding]
+    // 16      4     Bar.leading.second.x
+    // 20      12    [padding]
+    // 32      4     Bar.trailing.x
+    // 36      12    [padding]
+    //
+    // Total size is 48.
+
+    assert_std140!((size = 48, align = 16) Outer {
+        leading: 0,
+        trailing: 32,
+    });
+}
+
+#[test]
+fn array_strides_small_value() {
+    #[derive(Debug, PartialEq, AsStd140, AsStd430)]
+    struct ArrayOfSmallValues {
+        inner: [f32; 4],
+    }
+
+    assert_std140!((size = 64, align = 16) ArrayOfSmallValues {
+        inner: 0,
+    });
+
+    assert_std430!((size = 16, align = 4) ArrayOfSmallValues {
+        inner: 0,
+    });
+}
+
+#[test]
+fn array_strides_vec3() {
+    #[derive(Debug, PartialEq, AsStd140, AsStd430, GlslStruct)]
+    struct ArrayOfVector3 {
+        inner: [Vector3<f32>; 4],
+    }
+
+    assert_std140!((size = 64, align = 16) ArrayOfVector3 {
+        inner: 0,
+    });
+
+    assert_std430!((size = 64, align = 16) ArrayOfVector3 {
+        inner: 0,
+    });
+
+    test_round_trip_struct(ArrayOfVector3 {
+        inner: [
+            [0.0, 1.0, 2.0].into(),
+            [3.0, 4.0, 5.0].into(),
+            [6.0, 7.0, 8.0].into(),
+            [9.0, 10.0, 11.0].into(),
+        ],
+    })
+}
diff --git a/crates/crevice/crevice-tests/src/util.rs b/crates/crevice/crevice-tests/src/util.rs
new file mode 100644
index 0000000000..203afced8e
--- /dev/null
+++ b/crates/crevice/crevice-tests/src/util.rs
@@ -0,0 +1,143 @@
+#[macro_export]
+macro_rules! print_std140 {
+    ($type:ty) => {
+        println!(
+            "{}",
+            <$type as crevice::std140::AsStd140>::Output::debug_metrics()
+        );
+        println!();
+        println!();
+        println!(
+            "{}",
+            <$type as crevice::std140::AsStd140>::Output::debug_definitions()
+        );
+    };
+}
+
+#[macro_export]
+macro_rules! print_std430 {
+    ($type:ty) => {
+        println!(
+            "{}",
+            <$type as crevice::std430::AsStd430>::Output::debug_metrics()
+        );
+        println!();
+        println!();
+        println!(
+            "{}",
+            <$type as crevice::std430::AsStd430>::Output::debug_definitions()
+        );
+    };
+}
+
+#[macro_export]
+macro_rules! assert_std140 {
+    ((size = $size:literal, align = $align:literal) $struct:ident {
+        $( $field:ident: $offset:literal, )*
+    }) => {{
+        type Target = <$struct as crevice::std140::AsStd140>::Output;
+
+        let mut fail = false;
+
+        let actual_size = std::mem::size_of::<Target>();
+        if actual_size != $size {
+            fail = true;
+            println!(
+                "Invalid size for std140 struct {}\n\
+                Expected: {}\n\
+                Actual:   {}\n",
+                stringify!($struct),
+                $size,
+                actual_size,
+            );
+        }
+
+        let actual_alignment = <Target as crevice::std140::Std140>::ALIGNMENT;
+        if actual_alignment != $align {
+            fail = true;
+            println!(
+                "Invalid alignment for std140 struct {}\n\
+                Expected: {}\n\
+                Actual:   {}\n",
+                stringify!($struct),
+                $align,
+                actual_alignment,
+            );
+        }
+
+        $({
+            let actual_offset = memoffset::offset_of!(Target, $field);
+            if actual_offset != $offset {
+                fail = true;
+                println!(
+                    "Invalid offset for field {}\n\
+                    Expected: {}\n\
+                    Actual:   {}\n",
+                    stringify!($field),
+                    $offset,
+                    actual_offset,
+                );
+            }
+        })*
+
+        if fail {
+            panic!("Invalid std140 result for {}", stringify!($struct));
+        }
+    }};
+}
+
+#[macro_export]
+macro_rules! assert_std430 {
+    ((size = $size:literal, align = $align:literal) $struct:ident {
+        $( $field:ident: $offset:literal, )*
+    }) => {{
+        type Target = <$struct as crevice::std430::AsStd430>::Output;
+
+        let mut fail = false;
+
+        let actual_size = std::mem::size_of::<Target>();
+        if actual_size != $size {
+            fail = true;
+            println!(
+                "Invalid size for std430 struct {}\n\
+                Expected: {}\n\
+                Actual:   {}\n",
+                stringify!($struct),
+                $size,
+                actual_size,
+            );
+        }
+
+        let actual_alignment = <Target as crevice::std430::Std430>::ALIGNMENT;
+        if actual_alignment != $align {
+            fail = true;
+            println!(
+                "Invalid alignment for std430 struct {}\n\
+                Expected: {}\n\
+                Actual:   {}\n",
+                stringify!($struct),
+                $align,
+                actual_alignment,
+            );
+        }
+
+        $({
+            let actual_offset = memoffset::offset_of!(Target, $field);
+            if actual_offset != $offset {
+                fail = true;
+                println!(
+                    "Invalid offset for std430 field {}\n\
+                    Expected: {}\n\
+                    Actual:   {}\n",
+                    stringify!($field),
+                    $offset,
+                    actual_offset,
+                );
+            }
+        })*
+
+        if fail {
+            panic!("Invalid std430 result for {}", stringify!($struct));
+        }
+    }};
+}
diff --git a/crates/crevice/src/glsl.rs b/crates/crevice/src/glsl.rs
new file mode 100644
index 0000000000..3f879b6ab1
--- /dev/null
+++ b/crates/crevice/src/glsl.rs
@@ -0,0 +1,93 @@
+//! Defines traits and types for generating GLSL code from Rust definitions.
+
+pub use crevice_derive::GlslStruct;
+use std::marker::PhantomData;
+
+/// Type-level linked list of array dimensions
+pub struct Dimension<A, const N: usize> {
+    _marker: PhantomData<A>,
+}
+
+/// Type-level linked list terminator for array dimensions.
+pub struct DimensionNil;
+
+/// Trait for type-level array dimensions. Probably shouldn't be implemented outside this crate.
+pub unsafe trait DimensionList {
+    /// Write dimensions in square brackets to a string, list tail to list head.
+    fn push_to_string(s: &mut String);
+}
+
+unsafe impl DimensionList for DimensionNil {
+    fn push_to_string(_: &mut String) {}
+}
+
+unsafe impl<A: DimensionList, const N: usize> DimensionList for Dimension<A, N> {
+    fn push_to_string(s: &mut String) {
+        use std::fmt::Write;
+        A::push_to_string(s);
+        write!(s, "[{}]", N).unwrap();
+    }
+}
+
+/// Trait for types that have a GLSL equivalent. Useful for generating GLSL code
+/// from Rust structs.
+pub unsafe trait Glsl {
+    /// The name of this type in GLSL, like `vec2` or `mat4`.
+    const NAME: &'static str;
+}
+
+/// Trait for types that can be represented as a struct in GLSL.
+///
+/// This trait should not generally be implemented by hand, but can be derived.
+pub unsafe trait GlslStruct: Glsl {
+    /// The fields contained in this struct.
+    fn enumerate_fields(s: &mut String);
+
+    /// Generates GLSL code that represents this struct and its fields.
+    fn glsl_definition() -> String {
+        let mut output = String::new();
+        output.push_str("struct ");
+        output.push_str(Self::NAME);
+        output.push_str(" {\n");
+
+        Self::enumerate_fields(&mut output);
+
+        output.push_str("};");
+        output
+    }
+}
+
+/// Trait for types that are expressible as a GLSL type with (possibly zero) array dimensions.
+pub unsafe trait GlslArray {
+    /// Base type name.
+    const NAME: &'static str;
+    /// Type-level linked list of array dimensions, ordered outer to inner.
+    type ArraySize: DimensionList;
+}
+
+unsafe impl<T: Glsl> GlslArray for T {
+    const NAME: &'static str = <T as Glsl>::NAME;
+    type ArraySize = DimensionNil;
+}
+
+unsafe impl Glsl for f32 {
+    const NAME: &'static str = "float";
+}
+
+unsafe impl Glsl for f64 {
+    const NAME: &'static str = "double";
+}
+
+unsafe impl Glsl for i32 {
+    const NAME: &'static str = "int";
+}
+
+unsafe impl Glsl for u32 {
+    const NAME: &'static str = "uint";
+}
+
+unsafe impl<T: GlslArray, const N: usize> GlslArray for [T; N] {
+    const NAME: &'static str = T::NAME;
+
+    type ArraySize = Dimension<T::ArraySize, N>;
+}
diff --git a/crates/crevice/src/imp.rs b/crates/crevice/src/imp.rs
new file mode 100644
index 0000000000..af49bd8915
--- /dev/null
+++ b/crates/crevice/src/imp.rs
@@ -0,0 +1,10 @@
+mod imp_mint;
+
+#[cfg(feature = "cgmath")]
+mod imp_cgmath;
+
+#[cfg(feature = "glam")]
+mod imp_glam;
+
+#[cfg(feature = "nalgebra")]
+mod imp_nalgebra;
diff --git a/crates/crevice/src/imp/imp_cgmath.rs b/crates/crevice/src/imp/imp_cgmath.rs
new file mode 100644
index 0000000000..79ee7e071c
--- /dev/null
+++ b/crates/crevice/src/imp/imp_cgmath.rs
@@ -0,0 +1,30 @@
+easy_impl! {
+    Vec2 cgmath::Vector2<f32> { x, y },
+    Vec3 cgmath::Vector3<f32> { x, y, z },
+    Vec4 cgmath::Vector4<f32> { x, y, z, w },
+
+    IVec2 cgmath::Vector2<i32> { x, y },
+    IVec3 cgmath::Vector3<i32> { x, y, z },
+    IVec4 cgmath::Vector4<i32> { x, y, z, w },
+
+    UVec2 cgmath::Vector2<u32> { x, y },
+    UVec3 cgmath::Vector3<u32> { x, y, z },
+    UVec4 cgmath::Vector4<u32> { x, y, z, w },
+
+    // bool vectors are disabled due to https://github.com/LPGhatguy/crevice/issues/36
+    // BVec2 cgmath::Vector2<bool> { x, y },
+    // BVec3 cgmath::Vector3<bool> { x, y, z },
+    // BVec4 cgmath::Vector4<bool> { x, y, z, w },
+
+    DVec2 cgmath::Vector2<f64> { x, y },
+    DVec3 cgmath::Vector3<f64> { x, y, z },
+    DVec4 cgmath::Vector4<f64> { x, y, z, w },
+
+    Mat2 cgmath::Matrix2<f32> { x, y },
+    Mat3 cgmath::Matrix3<f32> { x, y, z },
+    Mat4 cgmath::Matrix4<f32> { x, y, z, w },
+
+    DMat2 cgmath::Matrix2<f64> { x, y },
+    DMat3 cgmath::Matrix3<f64> { x, y, z },
+    DMat4 cgmath::Matrix4<f64> { x, y, z, w },
+}
diff --git a/crates/crevice/src/imp/imp_glam.rs b/crates/crevice/src/imp/imp_glam.rs
new file mode 100644
index 0000000000..58ef711c27
--- /dev/null
+++ b/crates/crevice/src/imp/imp_glam.rs
@@ -0,0 +1,24 @@
+minty_impl! {
+    mint::Vector2<f32> => glam::Vec2,
+    mint::Vector3<f32> => glam::Vec3,
+    mint::Vector4<f32> => glam::Vec4,
+    mint::Vector2<i32> => glam::IVec2,
+    mint::Vector3<i32> => glam::IVec3,
+    mint::Vector4<i32> => glam::IVec4,
+    mint::Vector2<u32> => glam::UVec2,
+    mint::Vector3<u32> => glam::UVec3,
+    mint::Vector4<u32> => glam::UVec4,
+    // bool vectors are disabled due to https://github.com/LPGhatguy/crevice/issues/36
+    // mint::Vector2<bool> => glam::BVec2,
+    // mint::Vector3<bool> => glam::BVec3,
+    // mint::Vector4<bool> => glam::BVec4,
+    mint::Vector2<f64> => glam::DVec2,
+    mint::Vector3<f64> => glam::DVec3,
+    mint::Vector4<f64> => glam::DVec4,
+    mint::ColumnMatrix2<f32> => glam::Mat2,
+    mint::ColumnMatrix3<f32> => glam::Mat3,
+    mint::ColumnMatrix4<f32> => glam::Mat4,
+    mint::ColumnMatrix2<f64> => glam::DMat2,
+    mint::ColumnMatrix3<f64> => glam::DMat3,
+    mint::ColumnMatrix4<f64> => glam::DMat4,
+}
diff --git a/crates/crevice/src/imp/imp_mint.rs b/crates/crevice/src/imp/imp_mint.rs
new file mode 100644
index 0000000000..056a181c2c
--- /dev/null
+++ b/crates/crevice/src/imp/imp_mint.rs
@@ -0,0 +1,30 @@
+easy_impl! {
+    Vec2 mint::Vector2<f32> { x, y },
+    Vec3 mint::Vector3<f32> { x, y, z },
+    Vec4 mint::Vector4<f32> { x, y, z, w },
+
+    IVec2 mint::Vector2<i32> { x, y },
+    IVec3 mint::Vector3<i32> { x, y, z },
+    IVec4 mint::Vector4<i32> { x, y, z, w },
+
+    UVec2 mint::Vector2<u32> { x, y },
+    UVec3 mint::Vector3<u32> { x, y, z },
+    UVec4 mint::Vector4<u32> { x, y, z, w },
+
+    // bool vectors are disabled due to https://github.com/LPGhatguy/crevice/issues/36
+    // BVec2 mint::Vector2<bool> { x, y },
+    // BVec3 mint::Vector3<bool> { x, y, z },
+    // BVec4 mint::Vector4<bool> { x, y, z, w },
+
+    DVec2 mint::Vector2<f64> { x, y },
+    DVec3 mint::Vector3<f64> { x, y, z },
+    DVec4 mint::Vector4<f64> { x, y, z, w },
+
+    Mat2 mint::ColumnMatrix2<f32> { x, y },
+    Mat3 mint::ColumnMatrix3<f32> { x, y, z },
+    Mat4 mint::ColumnMatrix4<f32> { x, y, z, w },
+
+    DMat2 mint::ColumnMatrix2<f64> { x, y },
+    DMat3 mint::ColumnMatrix3<f64> { x, y, z },
+    DMat4 mint::ColumnMatrix4<f64> { x, y, z, w },
+}
diff --git a/crates/crevice/src/imp/imp_nalgebra.rs b/crates/crevice/src/imp/imp_nalgebra.rs
new file mode 100644
index 0000000000..3d1b89c0d3
--- /dev/null
+++ b/crates/crevice/src/imp/imp_nalgebra.rs
@@ -0,0 +1,24 @@
+minty_impl! {
+    mint::Vector2<f32> => nalgebra::Vector2<f32>,
+    mint::Vector3<f32> => nalgebra::Vector3<f32>,
+    mint::Vector4<f32> => nalgebra::Vector4<f32>,
+    mint::Vector2<i32> => nalgebra::Vector2<i32>,
+    mint::Vector3<i32> => nalgebra::Vector3<i32>,
+    mint::Vector4<i32> => nalgebra::Vector4<i32>,
+    mint::Vector2<u32> => nalgebra::Vector2<u32>,
+    mint::Vector3<u32> => nalgebra::Vector3<u32>,
+    mint::Vector4<u32> => nalgebra::Vector4<u32>,
+    // bool vectors are disabled due to https://github.com/LPGhatguy/crevice/issues/36
+    // mint::Vector2<bool> => nalgebra::Vector2<bool>,
+    // mint::Vector3<bool> => nalgebra::Vector3<bool>,
+    // mint::Vector4<bool> => nalgebra::Vector4<bool>,
+    mint::Vector2<f64> => nalgebra::Vector2<f64>,
+    mint::Vector3<f64> => nalgebra::Vector3<f64>,
+    mint::Vector4<f64> => nalgebra::Vector4<f64>,
+    mint::ColumnMatrix2<f32> => nalgebra::Matrix2<f32>,
+    mint::ColumnMatrix3<f32> => nalgebra::Matrix3<f32>,
+    mint::ColumnMatrix4<f32> => nalgebra::Matrix4<f32>,
+    mint::ColumnMatrix2<f64> => nalgebra::Matrix2<f64>,
+    mint::ColumnMatrix3<f64> => nalgebra::Matrix3<f64>,
+    mint::ColumnMatrix4<f64> => nalgebra::Matrix4<f64>,
+}
diff --git a/crates/crevice/src/internal.rs b/crates/crevice/src/internal.rs
new file mode 100644
index 0000000000..cd22972fb3
--- /dev/null
+++ b/crates/crevice/src/internal.rs
@@ -0,0 +1,40 @@
+//! This module is internal to crevice but used by its derive macro. No
+//! guarantees are made about its contents.
+
+pub use bytemuck;
+
+/// Gives the number of bytes needed to make `offset` be aligned to `alignment`.
+pub const fn align_offset(offset: usize, alignment: usize) -> usize {
+    if alignment == 0 || offset % alignment == 0 {
+        0
+    } else {
+        alignment - offset % alignment
+    }
+}
+
+/// Max of two `usize`. Implemented because the `max` method from `Ord` cannot
+/// be used in const fns.
+pub const fn max(a: usize, b: usize) -> usize {
+    if a > b {
+        a
+    } else {
+        b
+    }
+}
+
+/// Max of an array of `usize`. This function's implementation is funky because
+/// we have no for loops!
+pub const fn max_arr<const N: usize>(input: [usize; N]) -> usize {
+    let mut max = 0;
+    let mut i = 0;
+
+    while i < N {
+        if input[i] > max {
+            max = input[i];
+        }
+
+        i += 1;
+    }
+
+    max
+}
diff --git a/crates/crevice/src/lib.rs b/crates/crevice/src/lib.rs
new file mode 100644
index 0000000000..958d2c118b
--- /dev/null
+++ b/crates/crevice/src/lib.rs
@@ -0,0 +1,172 @@
+#![allow(
+    clippy::new_without_default,
+    clippy::needless_update,
+    clippy::len_without_is_empty,
+    clippy::needless_range_loop
+)]
+/*!
+[![GitHub CI Status](https://github.com/LPGhatguy/crevice/workflows/CI/badge.svg)](https://github.com/LPGhatguy/crevice/actions)
+[![crevice on crates.io](https://img.shields.io/crates/v/crevice.svg)](https://crates.io/crates/crevice)
+[![crevice docs](https://img.shields.io/badge/docs-docs.rs-orange.svg)](https://docs.rs/crevice)
+
+Crevice creates GLSL-compatible versions of types through the power of derive
+macros. Generated structures provide an [`as_bytes`][std140::Std140::as_bytes]
+method to allow safely packing data into buffers for uploading.
+
+Generated structs also implement [`bytemuck::Zeroable`] and
+[`bytemuck::Pod`] for use with other libraries.
+
+Crevice is similar to [`glsl-layout`][glsl-layout], but supports types from many
+math crates, can generate GLSL source from structs, and explicitly initializes
+padding to remove one source of undefined behavior.
+
+Crevice has support for many Rust math libraries via feature flags, and most
+other math libraries by use of the mint crate. Crevice currently supports:
+
+* mint 0.5, enabled by default
+* cgmath 0.18, using the `cgmath` feature
+* nalgebra 0.29, using the `nalgebra` feature
+* glam 0.19, using the `glam` feature
+
+PRs are welcome to add or update math libraries to Crevice.
+
+If your math library is not supported, it's possible to define structs using the
+types from mint and convert your math library's types into mint types. This is
+supported by most Rust math libraries.
+
+Your math library may require you to turn on a feature flag to get mint support.
+For example, cgmath requires the "mint" feature to be enabled to allow
+conversions to and from mint types.
+
+## Examples
+
+### Single Value
+
+Uploading many types can be done by deriving [`AsStd140`][std140::AsStd140] and
+using [`as_std140`][std140::AsStd140::as_std140] and
+[`as_bytes`][std140::Std140::as_bytes] to turn the result into bytes.
+
+```glsl
+uniform MAIN {
+    mat3 orientation;
+    vec3 position;
+    float scale;
+} main;
+```
+
+```rust
+use crevice::std140::{AsStd140, Std140};
+
+#[derive(AsStd140)]
+struct MainUniform {
+    orientation: mint::ColumnMatrix3<f32>,
+    position: mint::Vector3<f32>,
+    scale: f32,
+}
+
+let value = MainUniform {
+    orientation: [
+        [1.0, 0.0, 0.0],
+        [0.0, 1.0, 0.0],
+        [0.0, 0.0, 1.0],
+    ].into(),
+    position: [1.0, 2.0, 3.0].into(),
+    scale: 4.0,
+};
+
+let value_std140 = value.as_std140();
+
+# fn upload_data_to_gpu(_value: &[u8]) {}
+upload_data_to_gpu(value_std140.as_bytes());
+```
+
+### Sequential Types
+
+More complicated data can be uploaded using the std140
+[`Writer`][std140::Writer] type.
+
+```glsl
+struct PointLight {
+    vec3 position;
+    vec3 color;
+    float brightness;
+};
+
+buffer POINT_LIGHTS {
+    uint len;
+    PointLight[] lights;
+} point_lights;
+```
+
+```rust
+use crevice::std140::{self, AsStd140};
+
+#[derive(AsStd140)]
+struct PointLight {
+    position: mint::Vector3<f32>,
+    color: mint::Vector3<f32>,
+    brightness: f32,
+}
+
+let lights = vec![
+    PointLight {
+        position: [0.0, 1.0, 0.0].into(),
+        color: [1.0, 0.0, 0.0].into(),
+        brightness: 0.6,
+    },
+    PointLight {
+        position: [0.0, 4.0, 3.0].into(),
+        color: [1.0, 1.0, 1.0].into(),
+        brightness: 1.0,
+    },
+];
+
+# fn map_gpu_buffer_for_write() -> &'static mut [u8] {
+#     Box::leak(vec![0; 1024].into_boxed_slice())
+# }
+let target_buffer = map_gpu_buffer_for_write();
+let mut writer = std140::Writer::new(target_buffer);
+
+let light_count = lights.len() as u32;
+writer.write(&light_count)?;
+
+// Crevice will automatically insert the required padding to align the
+// PointLight structure correctly. In this case, there will be 12 bytes of
+// padding between the length field and the light list.
+
+writer.write(lights.as_slice())?;
+
+# fn unmap_gpu_buffer() {}
+unmap_gpu_buffer();
+
+# Ok::<(), std::io::Error>(())
+```
+
+## Features
+
+* `std` (default): Enables [`std::io::Write`]-based structs.
+* `cgmath`: Enables support for types from cgmath.
+* `nalgebra`: Enables support for types from nalgebra.
+* `glam`: Enables support for types from glam.
+
+## Minimum Supported Rust Version (MSRV)
+
+Crevice supports Rust 1.52.1 and newer due to use of new `const fn` features.
+
+[glsl-layout]: https://github.com/rustgd/glsl-layout
+*/
+
+#![deny(missing_docs)]
+#![cfg_attr(not(feature = "std"), no_std)]
+
+#[macro_use]
+mod util;
+
+pub mod glsl;
+pub mod std140;
+pub mod std430;
+
+#[doc(hidden)]
+pub mod internal;
+
+mod imp;
diff --git a/crates/crevice/src/std140.rs b/crates/crevice/src/std140.rs
new file mode 100644
index 0000000000..184b99a92d
--- /dev/null
+++ b/crates/crevice/src/std140.rs
@@ -0,0 +1,18 @@
+//! Defines traits and types for working with data adhering to GLSL's `std140`
+//! layout specification.
+
+mod dynamic_uniform;
+mod primitives;
+mod sizer;
+mod traits;
+#[cfg(feature = "std")]
+mod writer;
+
+pub use self::dynamic_uniform::*;
+pub use self::primitives::*;
+pub use self::sizer::*;
+pub use self::traits::*;
+#[cfg(feature = "std")]
+pub use self::writer::*;
+
+pub use crevice_derive::AsStd140;
diff --git a/crates/crevice/src/std140/dynamic_uniform.rs b/crates/crevice/src/std140/dynamic_uniform.rs
new file mode 100644
index 0000000000..262f8ea449
--- /dev/null
+++ b/crates/crevice/src/std140/dynamic_uniform.rs
@@ -0,0 +1,68 @@
+use bytemuck::{Pod, Zeroable};
+
+#[allow(unused_imports)]
+use crate::internal::{align_offset, max};
+use crate::std140::{AsStd140, Std140};
+
+/// Wrapper type that aligns the inner type to at least 256 bytes.
+///
+/// This type is useful for ensuring correct alignment when creating dynamic
+/// uniform buffers in APIs like WebGPU.
+pub struct DynamicUniform<T>(pub T);
+
+impl<T: AsStd140> AsStd140 for DynamicUniform<T> {
+    type Output = DynamicUniformStd140<<T as AsStd140>::Output>;
+
+    fn as_std140(&self) -> Self::Output {
+        DynamicUniformStd140(self.0.as_std140())
+    }
+
+    fn from_std140(value: Self::Output) -> Self {
+        DynamicUniform(<T as AsStd140>::from_std140(value.0))
+    }
+}
+
+/// std140 variant of [`DynamicUniform`].
+#[derive(Clone, Copy)]
+#[repr(transparent)]
+pub struct DynamicUniformStd140<T>(T);
+
+unsafe impl<T: Std140> Std140 for DynamicUniformStd140<T> {
+    const ALIGNMENT: usize = max(256, T::ALIGNMENT);
+    #[cfg(const_evaluatable_checked)]
+    type Padded = crate::std140::Std140Padded<
+        Self,
+        { align_offset(core::mem::size_of::<T>(), max(256, T::ALIGNMENT)) },
+    >;
+    #[cfg(not(const_evaluatable_checked))]
+    type Padded = crate::std140::InvalidPadded;
+}
+
+unsafe impl<T: Zeroable> Zeroable for DynamicUniformStd140<T> {}
+unsafe impl<T: Pod> Pod for DynamicUniformStd140<T> {}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    use crate::std140::{self, WriteStd140};
+
+    #[test]
+    fn size_is_unchanged() {
+        let dynamic_f32 = DynamicUniform(0.0f32);
+
+        assert_eq!(dynamic_f32.std140_size(), 0.0f32.std140_size());
+    }
+
+    #[test]
+    fn alignment_applies() {
+        let mut output = Vec::new();
+        let mut writer = std140::Writer::new(&mut output);
+
+        writer.write(&DynamicUniform(0.0f32)).unwrap();
+        assert_eq!(writer.len(), 4);
+
+        writer.write(&DynamicUniform(1.0f32)).unwrap();
+        assert_eq!(writer.len(), 260);
+    }
+}
diff --git a/crates/crevice/src/std140/primitives.rs b/crates/crevice/src/std140/primitives.rs
new file mode 100644
index 0000000000..34e161e3b7
--- /dev/null
+++ b/crates/crevice/src/std140/primitives.rs
@@ -0,0 +1,175 @@
+use bytemuck::{Pod, Zeroable};
+
+use crate::glsl::Glsl;
+use crate::std140::{Std140, Std140Padded};
+
+use crate::internal::{align_offset, max};
+use core::mem::size_of;
+
+unsafe impl Std140 for f32 {
+    const ALIGNMENT: usize = 4;
+    type Padded = Std140Padded<Self, 12>;
+}
+
+unsafe impl Std140 for f64 {
+    const ALIGNMENT: usize = 8;
+    type Padded = Std140Padded<Self, 8>;
+}
+
+unsafe impl Std140 for i32 {
+    const ALIGNMENT: usize = 4;
+    type Padded = Std140Padded<Self, 12>;
+}
+
+unsafe impl Std140 for u32 {
+    const ALIGNMENT: usize = 4;
+    type Padded = Std140Padded<Self, 12>;
+}
+
+macro_rules! vectors {
+    (
+        $(
+            #[$doc:meta] align($align:literal) $glsl_name:ident $name:ident <$prim:ident> ($($field:ident),+)
+        )+
+    ) => {
+        $(
+            #[$doc]
+            #[allow(missing_docs)]
+            #[derive(Debug, Clone, Copy, PartialEq)]
+            #[repr(C)]
+            pub struct $name {
+                $(pub $field: $prim,)+
+            }
+
+            unsafe impl Zeroable for $name {}
+            unsafe impl Pod for $name {}
+
+            unsafe impl Std140 for $name {
+                const ALIGNMENT: usize = $align;
+                type Padded = Std140Padded<Self, {align_offset(size_of::<$name>(), max(16, $align))}>;
+            }
+
+            unsafe impl Glsl for $name {
+                const NAME: &'static str = stringify!($glsl_name);
+            }
+        )+
+    };
+}
+
+vectors! {
+    #[doc = "Corresponds to a GLSL `vec2` in std140 layout."] align(8) vec2 Vec2<f32>(x, y)
+    #[doc = "Corresponds to a GLSL `vec3` in std140 layout."] align(16) vec3 Vec3<f32>(x, y, z)
+    #[doc = "Corresponds to a GLSL `vec4` in std140 layout."] align(16) vec4 Vec4<f32>(x, y, z, w)
+
+    #[doc = "Corresponds to a GLSL `ivec2` in std140 layout."] align(8) ivec2 IVec2<i32>(x, y)
+    #[doc = "Corresponds to a GLSL `ivec3` in std140 layout."] align(16) ivec3 IVec3<i32>(x, y, z)
+    #[doc = "Corresponds to a GLSL `ivec4` in std140 layout."] align(16) ivec4 IVec4<i32>(x, y, z, w)
+
+    #[doc = "Corresponds to a GLSL `uvec2` in std140 layout."] align(8) uvec2 UVec2<u32>(x, y)
+    #[doc = "Corresponds to a GLSL `uvec3` in std140 layout."] align(16) uvec3 UVec3<u32>(x, y, z)
+    #[doc = "Corresponds to a GLSL `uvec4` in std140 layout."] align(16) uvec4 UVec4<u32>(x, y, z, w)
+
+    // bool vectors are disabled due to https://github.com/LPGhatguy/crevice/issues/36
+
+    // #[doc = "Corresponds to a GLSL `bvec2` in std140 layout."] align(8) bvec2 BVec2<bool>(x, y)
+    // #[doc = "Corresponds to a GLSL `bvec3` in std140 layout."] align(16) bvec3 BVec3<bool>(x, y, z)
+    // #[doc = "Corresponds to a GLSL `bvec4` in std140 layout."] align(16) bvec4 BVec4<bool>(x, y, z, w)
+
+    #[doc = "Corresponds to a GLSL `dvec2` in std140 layout."] align(16) dvec2 DVec2<f64>(x, y)
+    #[doc = "Corresponds to a GLSL `dvec3` in std140 layout."] align(32) dvec3 DVec3<f64>(x, y, z)
+    #[doc = "Corresponds to a GLSL `dvec4` in std140 layout."] align(32) dvec4 DVec4<f64>(x, y, z, w)
+}
+
+macro_rules! matrices {
+    (
+        $(
+            #[$doc:meta]
+            align($align:literal)
+            $glsl_name:ident $name:ident {
+                $($field:ident: $field_ty:ty,)+
+            }
+        )+
+    ) => {
+        $(
+            #[$doc]
+            #[allow(missing_docs)]
+            #[derive(Debug, Clone, Copy)]
+            #[repr(C)]
+            pub struct $name {
+                $(pub $field: $field_ty,)+
+            }
+
+            unsafe impl Zeroable for $name {}
+            unsafe impl Pod for $name {}
+
+            unsafe impl Std140 for $name {
+                const ALIGNMENT: usize = $align;
+                /// Matrices are technically arrays of primitives, and as such require pad at end.
+                const PAD_AT_END: bool = true;
+                type Padded = Std140Padded<Self, {align_offset(size_of::<$name>(), max(16, $align))}>;
+            }
+
+            unsafe impl Glsl for $name {
+                const NAME: &'static str = stringify!($glsl_name);
+            }
+        )+
+    };
+}
+
+matrices! {
+    #[doc = "Corresponds to a GLSL `mat2` in std140 layout."]
+    align(16)
+    mat2 Mat2 {
+        x: Vec2,
+        _pad_x: [f32; 2],
+        y: Vec2,
+        _pad_y: [f32; 2],
+    }
+
+    #[doc = "Corresponds to a GLSL `mat3` in std140 layout."]
+    align(16)
+    mat3 Mat3 {
+        x: Vec3,
+        _pad_x: f32,
+        y: Vec3,
+        _pad_y: f32,
+        z: Vec3,
+        _pad_z: f32,
+    }
+
+    #[doc = "Corresponds to a GLSL `mat4` in std140 layout."]
+    align(16)
+    mat4 Mat4 {
+        x: Vec4,
+        y: Vec4,
+        z: Vec4,
+        w: Vec4,
+    }
+
+    #[doc = "Corresponds to a GLSL `dmat2` in std140 layout."]
+    align(16)
+    dmat2 DMat2 {
+        x: DVec2,
+        y: DVec2,
+    }
+
+    #[doc = "Corresponds to a GLSL `dmat3` in std140 layout."]
+    align(32)
+    dmat3 DMat3 {
+        x: DVec3,
+        _pad_x: f64,
+        y: DVec3,
+        _pad_y: f64,
+        z: DVec3,
+        _pad_z: f64,
+    }
+
+    #[doc = "Corresponds to a GLSL `dmat3` in std140 layout."]
+    align(32)
+    dmat4 DMat4 {
+        x: DVec4,
+        y: DVec4,
+        z: DVec4,
+        w: DVec4,
+    }
+}
diff --git a/crates/crevice/src/std140/sizer.rs b/crates/crevice/src/std140/sizer.rs
new file mode 100644
index 0000000000..ee5c134595
--- /dev/null
+++ b/crates/crevice/src/std140/sizer.rs
@@ -0,0 +1,81 @@
+use core::mem::size_of;
+
+use crate::internal::align_offset;
+use crate::std140::{AsStd140, Std140};
+
+/**
+Type that computes the buffer size needed by a series of `std140` types laid
+out.
+
+This type works well well when paired with `Writer`, precomputing a buffer's
+size to alleviate the need to dynamically re-allocate buffers.
+
+## Example
+
+```glsl
+struct Frob {
+    vec3 size;
+    float frobiness;
+}
+
+buffer FROBS {
+    uint len;
+    Frob[] frobs;
+} frobs;
+```
+
+```
+use crevice::std140::{self, AsStd140};
+
+#[derive(AsStd140)]
+struct Frob {
+    size: mint::Vector3<f32>,
+    frobiness: f32,
+}
+
+// Many APIs require that buffers contain at least enough space for all
+// fixed-size bindiongs to a buffer as well as one element of any arrays, if
+// there are any.
+let mut sizer = std140::Sizer::new();
+sizer.add::<u32>();
+sizer.add::<Frob>();
+
+# fn create_buffer_with_size(size: usize) {}
+let buffer = create_buffer_with_size(sizer.len());
+# assert_eq!(sizer.len(), 32);
+```
+*/
+pub struct Sizer {
+    offset: usize,
+}
+
+impl Sizer {
+    /// Create a new `Sizer`.
+    pub fn new() -> Self {
+        Self { offset: 0 }
+    }
+
+    /// Add a type's necessary padding and size to the `Sizer`. Returns the
+    /// offset into the buffer where that type would be written.
+    pub fn add<T>(&mut self) -> usize
+    where
+        T: AsStd140,
+    {
+        let size = size_of::<<T as AsStd140>::Output>();
+        let alignment = <T as AsStd140>::Output::ALIGNMENT;
+        let padding = align_offset(self.offset, alignment);
+
+        self.offset += padding;
+        let write_here = self.offset;
+
+        self.offset += size;
+
+        write_here
+    }
+
+    /// Returns the number of bytes required to contain all the types added to
+    /// the `Sizer`.
+    pub fn len(&self) -> usize {
+        self.offset
+    }
+}
diff --git a/crates/crevice/src/std140/traits.rs b/crates/crevice/src/std140/traits.rs
new file mode 100644
index 0000000000..caa8fce6fd
--- /dev/null
+++ b/crates/crevice/src/std140/traits.rs
@@ -0,0 +1,284 @@
+use core::mem::{size_of, MaybeUninit};
+#[cfg(feature = "std")]
+use std::io::{self, Write};
+
+use bytemuck::{bytes_of, Pod, Zeroable};
+
+#[cfg(feature = "std")]
+use crate::std140::Writer;
+
+/// Trait implemented for all `std140` primitives. Generally should not be
+/// implemented outside this crate.
+pub unsafe trait Std140: Copy + Zeroable + Pod {
+    /// The required alignment of the type. Must be a power of two.
+    ///
+    /// This is distinct from the value returned by `std::mem::align_of` because
+    /// `AsStd140` structs do not use Rust's alignment. This enables them to
+    /// control and zero their padding bytes, making converting them to and from
+    /// slices safe.
+    const ALIGNMENT: usize;
+
+    /// Whether this type requires a padding at the end (ie, is a struct or an array
+    /// of primitives).
+    /// See <https://www.khronos.org/registry/OpenGL/specs/gl/glspec45.core.pdf#page=159>
+    /// (rule 4 and 9)
+    const PAD_AT_END: bool = false;
+    /// Padded type (Std140Padded specialization)
+    /// The usual implementation is
+    /// type Padded = Std140Padded<Self, {align_offset(size_of::<Self>(), max(16, ALIGNMENT))}>;
+    type Padded: Std140Convertible<Self>;
+
+    /// Casts the type to a byte array. Implementors should not override this
+    /// method.
+    ///
+    /// # Safety
+    /// This is always safe due to the requirements of [`bytemuck::Pod`] being a
+    /// prerequisite for this trait.
+    fn as_bytes(&self) -> &[u8] {
+        bytes_of(self)
+    }
+}
+
+/// Trait specifically for Std140::Padded, implements conversions between padded type and base type.
+pub trait Std140Convertible<T: Std140>: Copy {
+    /// Convert from self to Std140
+    fn into_std140(self) -> T;
+    /// Convert from Std140 to self
+    fn from_std140(_: T) -> Self;
+}
+
+impl<T: Std140> Std140Convertible<T> for T {
+    fn into_std140(self) -> T {
+        self
+    }
+    fn from_std140(also_self: T) -> Self {
+        also_self
+    }
+}
+
+/// Unfortunately, we cannot easily derive padded representation for generic Std140 types.
+/// For now, we'll just use this empty enum with no values.
+#[derive(Copy, Clone)]
+pub enum InvalidPadded {}
+impl<T: Std140> Std140Convertible<T> for InvalidPadded {
+    fn into_std140(self) -> T {
+        unimplemented!()
+    }
+    fn from_std140(_: T) -> Self {
+        unimplemented!()
+    }
+}
+/**
+Trait implemented for all types that can be turned into `std140` values.
+*
+This trait can often be `#[derive]`'d instead of manually implementing it. Any
+struct which contains only fields that also implement `AsStd140` can derive
+`AsStd140`.
+
+Types from the mint crate implement `AsStd140`, making them convenient for use
+in uniform types. Most Rust math crates, like cgmath, nalgebra, and
+ultraviolet support mint.
+
+## Example
+
+```glsl
+uniform CAMERA {
+    mat4 view;
+    mat4 projection;
+} camera;
+```
+
+```no_run
+use crevice::std140::{AsStd140, Std140};
+
+#[derive(AsStd140)]
+struct CameraUniform {
+    view: mint::ColumnMatrix4<f32>,
+    projection: mint::ColumnMatrix4<f32>,
+}
+
+let view: mint::ColumnMatrix4<f32> = todo!("your math code here");
+let projection: mint::ColumnMatrix4<f32> = todo!("your math code here");
+
+let camera = CameraUniform {
+    view,
+    projection,
+};
+
+# fn write_to_gpu_buffer(bytes: &[u8]) {}
+let camera_std140 = camera.as_std140();
+write_to_gpu_buffer(camera_std140.as_bytes());
+```
+*/
+pub trait AsStd140 {
+    /// The `std140` version of this value.
+    type Output: Std140;
+
+    /// Convert this value into the `std140` version of itself.
+    fn as_std140(&self) -> Self::Output;
+
+    /// Returns the size of the `std140` version of this type. Useful for
+    /// pre-sizing buffers.
+    fn std140_size_static() -> usize {
+        size_of::<Self::Output>()
+    }
+
+    /// Converts from `std140` version of self to self.
+    fn from_std140(val: Self::Output) -> Self;
+}
+
+impl<T> AsStd140 for T
+where
+    T: Std140,
+{
+    type Output = Self;
+
+    fn as_std140(&self) -> Self {
+        *self
+    }
+
+    fn from_std140(x: Self) -> Self {
+        x
+    }
+}
+
+#[doc(hidden)]
+#[derive(Copy, Clone, Debug)]
+pub struct Std140Padded<T: Std140, const PAD: usize> {
+    inner: T,
+    _padding: [u8; PAD],
+}
+
+unsafe impl<T: Std140, const PAD: usize> Zeroable for Std140Padded<T, PAD> {}
+unsafe impl<T: Std140, const PAD: usize> Pod for Std140Padded<T, PAD> {}
+
+impl<T: Std140, const PAD: usize> Std140Convertible<T> for Std140Padded<T, PAD> {
+    fn into_std140(self) -> T {
+        self.inner
+    }
+
+    fn from_std140(inner: T) -> Self {
+        Self {
+            inner,
+            _padding: [0u8; PAD],
+        }
+    }
+}
+
+#[doc(hidden)]
+#[derive(Copy, Clone, Debug)]
+#[repr(transparent)]
+pub struct Std140Array<T: Std140, const N: usize>([T::Padded; N]);
+
+unsafe impl<T: Std140, const N: usize> Zeroable for Std140Array<T, N> where T::Padded: Zeroable {}
+unsafe impl<T: Std140, const N: usize> Pod for Std140Array<T, N> where T::Padded: Pod {}
+unsafe impl<T: Std140, const N: usize> Std140 for Std140Array<T, N>
+where
+    T::Padded: Pod,
+{
+    const ALIGNMENT: usize = crate::internal::max(T::ALIGNMENT, 16);
+    type Padded = Self;
+}
+
+impl<T: Std140, const N: usize> Std140Array<T, N> {
+    fn uninit_array() -> [MaybeUninit<T::Padded>; N] {
+        unsafe { MaybeUninit::uninit().assume_init() }
+    }
+
+    fn from_uninit_array(a: [MaybeUninit<T::Padded>; N]) -> Self {
+        unsafe { core::mem::transmute_copy(&a) }
+    }
+}
+
+impl<T: AsStd140, const N: usize> AsStd140 for [T; N]
+where
+    <T::Output as Std140>::Padded: Pod,
+{
+    type Output = Std140Array<T::Output, N>;
+    fn as_std140(&self) -> Self::Output {
+        let mut res = Self::Output::uninit_array();
+
+        for i in 0..N {
+            res[i] = MaybeUninit::new(Std140Convertible::from_std140(self[i].as_std140()));
+        }
+
+        Self::Output::from_uninit_array(res)
+    }
+
+    fn from_std140(val: Self::Output) -> Self {
+        let mut res: [MaybeUninit<T>; N] = unsafe { MaybeUninit::uninit().assume_init() };
+        for i in 0..N {
+            res[i] = MaybeUninit::new(T::from_std140(Std140Convertible::into_std140(val.0[i])));
+        }
+        unsafe { core::mem::transmute_copy(&res) }
+    }
+}
+
+/// Trait implemented for all types that can be written into a buffer as
+/// `std140` bytes. This type is more general than [`AsStd140`]: all `AsStd140`
+/// types implement `WriteStd140`, but not the other way around.
+///
+/// While `AsStd140` requires implementers to return a type that implements the
+/// `Std140` trait, `WriteStd140` directly writes bytes using a [`Writer`]. This
+/// makes `WriteStd140` usable for writing slices or other DSTs that could not
+/// implement `AsStd140` without allocating new memory on the heap.
+#[cfg(feature = "std")]
+pub trait WriteStd140 {
+    /// Writes this value into the given [`Writer`] using `std140` layout rules.
+    ///
+    /// Should return the offset of the first byte of this type, as returned by
+    /// the first call to [`Writer::write`].
+    fn write_std140<W: Write>(&self, writer: &mut Writer<W>) -> io::Result<usize>;
+
+    /// The space required to write this value using `std140` layout rules. This
+    /// does not include alignment padding that may be needed before or after
+    /// this type when written as part of a larger buffer.
+    fn std140_size(&self) -> usize {
+        let mut writer = Writer::new(io::sink());
+        self.write_std140(&mut writer).unwrap();
+        writer.len()
+    }
+}
+
+#[cfg(feature = "std")]
+impl<T> WriteStd140 for T
+where
+    T: AsStd140,
+{
+    fn write_std140<W: Write>(&self, writer: &mut Writer<W>) -> io::Result<usize> {
+        writer.write_std140(&self.as_std140())
+    }
+
+    fn std140_size(&self) -> usize {
+        size_of::<<Self as AsStd140>::Output>()
+    }
+}
+
+#[cfg(feature = "std")]
+impl<T> WriteStd140 for [T]
+where
+    T: WriteStd140,
+{
+    fn write_std140<W: Write>(&self, writer: &mut Writer<W>) -> io::Result<usize> {
+        // if no items are written, offset is current position of the writer
+        let mut offset = writer.len();
+
+        let mut iter = self.iter();
+
+        if let Some(item) = iter.next() {
+            offset = item.write_std140(writer)?;
+        }
+
+        for item in iter {
+            item.write_std140(writer)?;
+        }
+
+        Ok(offset)
+    }
+
+    fn std140_size(&self) -> usize {
+        let mut writer = Writer::new(io::sink());
+        self.write_std140(&mut writer).unwrap();
+        writer.len()
+    }
+}
diff --git a/crates/crevice/src/std140/writer.rs b/crates/crevice/src/std140/writer.rs
new file mode 100644
index 0000000000..2a4dbc550f
--- /dev/null
+++ b/crates/crevice/src/std140/writer.rs
@@ -0,0 +1,162 @@
+use std::io::{self, Write};
+use std::mem::size_of;
+
+use bytemuck::bytes_of;
+
+use crate::internal::align_offset;
+use crate::std140::{AsStd140, Std140, WriteStd140};
+
+/**
+Type that enables writing correctly aligned `std140` values to a buffer.
+
+`Writer` is useful when many values need to be laid out in a row that cannot be
+represented by a struct alone, like dynamically sized arrays or dynamically
+laid-out values.
+
+## Example
+In this example, we'll write a length-prefixed list of lights to a buffer.
+`std140::Writer` helps align correctly, even across multiple structs, which can
+be tricky and error-prone otherwise.
+
+```glsl
+struct PointLight {
+    vec3 position;
+    vec3 color;
+    float brightness;
+};
+
+buffer POINT_LIGHTS {
+    uint len;
+    PointLight[] lights;
+} point_lights;
+```
+
+```
+use crevice::std140::{self, AsStd140};
+
+#[derive(AsStd140)]
+struct PointLight {
+    position: mint::Vector3<f32>,
+    color: mint::Vector3<f32>,
+    brightness: f32,
+}
+
+let lights = vec![
+    PointLight {
+        position: [0.0, 1.0, 0.0].into(),
+        color: [1.0, 0.0, 0.0].into(),
+        brightness: 0.6,
+    },
+    PointLight {
+        position: [0.0, 4.0, 3.0].into(),
+        color: [1.0, 1.0, 1.0].into(),
+        brightness: 1.0,
+    },
+];
+
+# fn map_gpu_buffer_for_write() -> &'static mut [u8] {
+#     Box::leak(vec![0; 1024].into_boxed_slice())
+# }
+let target_buffer = map_gpu_buffer_for_write();
+let mut writer = std140::Writer::new(target_buffer);
+
+let light_count = lights.len() as u32;
+writer.write(&light_count)?;
+
+// Crevice will automatically insert the required padding to align the
+// PointLight structure correctly. In this case, there will be 12 bytes of
+// padding between the length field and the light list.
+
+writer.write(lights.as_slice())?;
+
+# fn unmap_gpu_buffer() {}
+unmap_gpu_buffer();
+
+# Ok::<(), std::io::Error>(())
+```
+*/
+pub struct Writer<W> {
+    writer: W,
+    offset: usize,
+}
+
+impl<W: Write> Writer<W> {
+    /// Create a new `Writer`, wrapping a buffer, file, or other type that
+    /// implements [`std::io::Write`].
+    pub fn new(writer: W) -> Self {
+        Self { writer, offset: 0 }
+    }
+
+    /// Write a new value to the underlying buffer, writing zeroed padding where
+    /// necessary.
+    ///
+    /// Returns the offset into the buffer that the value was written to.
+    pub fn write<T>(&mut self, value: &T) -> io::Result<usize>
+    where
+        T: WriteStd140 + ?Sized,
+    {
+        value.write_std140(self)
+    }
+
+    /// Write an iterator of values to the underlying buffer.
+    ///
+    /// Returns the offset into the buffer that the first value was written to.
+    /// If no values were written, returns the `len()`.
+    pub fn write_iter<I, T>(&mut self, iter: I) -> io::Result<usize>
+    where
+        I: IntoIterator<Item = T>,
+        T: WriteStd140,
+    {
+        let mut offset = self.offset;
+
+        let mut iter = iter.into_iter();
+
+        if let Some(item) = iter.next() {
+            offset = item.write_std140(self)?;
+        }
+
+        for item in iter {
+            item.write_std140(self)?;
+        }
+
+        Ok(offset)
+    }
+
+    /// Write an `Std140` type to the underlying buffer.
+    pub fn write_std140<T>(&mut self, value: &T) -> io::Result<usize>
+    where
+        T: Std140,
+    {
+        let padding = align_offset(self.offset, T::ALIGNMENT);
+
+        for _ in 0..padding {
+            self.writer.write_all(&[0])?;
+        }
+        self.offset += padding;
+
+        let value = value.as_std140();
+        self.writer.write_all(bytes_of(&value))?;
+
+        let write_here = self.offset;
+        self.offset += size_of::<T>();
+
+        Ok(write_here)
+    }
+
+    /// Write a slice of values to the underlying buffer.
+    #[deprecated(
+        since = "0.6.0",
+        note = "Use `write` instead -- it now works on slices."
+    )]
+    pub fn write_slice<T>(&mut self, slice: &[T]) -> io::Result<usize>
+    where
+        T: AsStd140,
+    {
+        self.write(slice)
+    }
+
+    /// Returns the amount of data written by this `Writer`.
+    pub fn len(&self) -> usize {
+        self.offset
+    }
+}
diff --git a/crates/crevice/src/std430.rs b/crates/crevice/src/std430.rs
new file mode 100644
index 0000000000..7e1af050ce
--- /dev/null
+++ b/crates/crevice/src/std430.rs
@@ -0,0 +1,16 @@
+//! Defines traits and types for working with data adhering to GLSL's `std140`
+//! layout specification.
+
+mod primitives;
+mod sizer;
+mod traits;
+#[cfg(feature = "std")]
+mod writer;
+
+pub use self::primitives::*;
+pub use self::sizer::*;
+pub use self::traits::*;
+#[cfg(feature = "std")]
+pub use self::writer::*;
+
+pub use crevice_derive::AsStd430;
diff --git a/crates/crevice/src/std430/primitives.rs b/crates/crevice/src/std430/primitives.rs
new file mode 100644
index 0000000000..3348e82c7b
--- /dev/null
+++ b/crates/crevice/src/std430/primitives.rs
@@ -0,0 +1,173 @@
+use bytemuck::{Pod, Zeroable};
+
+use crate::glsl::Glsl;
+use crate::std430::{Std430, Std430Padded};
+
+use crate::internal::align_offset;
+use core::mem::size_of;
+
+unsafe impl Std430 for f32 {
+    const ALIGNMENT: usize = 4;
+    type Padded = Self;
+}
+
+unsafe impl Std430 for f64 {
+    const ALIGNMENT: usize = 8;
+    type Padded = Self;
+}
+
+unsafe impl Std430 for i32 {
+    const ALIGNMENT: usize = 4;
+    type Padded = Self;
+}
+
+unsafe impl Std430 for u32 {
+    const ALIGNMENT: usize = 4;
+    type Padded = Self;
+}
+
+macro_rules! vectors {
+    (
+        $(
+            #[$doc:meta] align($align:literal) $glsl_name:ident $name:ident <$prim:ident> ($($field:ident),+)
+        )+
+    ) => {
+        $(
+            #[$doc]
+            #[allow(missing_docs)]
+            #[derive(Debug, Clone, Copy)]
+            #[repr(C)]
+            pub struct $name {
+                $(pub $field: $prim,)+
+            }
+
+            unsafe impl Zeroable for $name {}
+            unsafe impl Pod for $name {}
+
+            unsafe impl Std430 for $name {
+                const ALIGNMENT: usize = $align;
+                type Padded = Std430Padded<Self, {align_offset(size_of::<$name>(), $align)}>;
+            }
+
+            unsafe impl Glsl for $name {
+                const NAME: &'static str = stringify!($glsl_name);
+            }
+        )+
+    };
+}
+
+vectors! {
+    #[doc = "Corresponds to a GLSL `vec2` in std430 layout."] align(8) vec2 Vec2<f32>(x, y)
+    #[doc = "Corresponds to a GLSL `vec3` in std430 layout."] align(16) vec3 Vec3<f32>(x, y, z)
+    #[doc = "Corresponds to a GLSL `vec4` in std430 layout."] align(16) vec4 Vec4<f32>(x, y, z, w)
+
+    #[doc = "Corresponds to a GLSL `ivec2` in std430 layout."] align(8) ivec2 IVec2<i32>(x, y)
+    #[doc = "Corresponds to a GLSL `ivec3` in std430 layout."] align(16) ivec3 IVec3<i32>(x, y, z)
+    #[doc = "Corresponds to a GLSL `ivec4` in std430 layout."] align(16) ivec4 IVec4<i32>(x, y, z, w)
+
+    #[doc = "Corresponds to a GLSL `uvec2` in std430 layout."] align(8) uvec2 UVec2<u32>(x, y)
+    #[doc = "Corresponds to a GLSL `uvec3` in std430 layout."] align(16) uvec3 UVec3<u32>(x, y, z)
+    #[doc = "Corresponds to a GLSL `uvec4` in std430 layout."] align(16) uvec4 UVec4<u32>(x, y, z, w)
+
+    // bool vectors are disabled due to https://github.com/LPGhatguy/crevice/issues/36
+
+    // #[doc = "Corresponds to a GLSL `bvec2` in std430 layout."] align(8) bvec2 BVec2<bool>(x, y)
+    // #[doc = "Corresponds to a GLSL `bvec3` in std430 layout."] align(16) bvec3 BVec3<bool>(x, y, z)
+    // #[doc = "Corresponds to a GLSL `bvec4` in std430 layout."] align(16) bvec4 BVec4<bool>(x, y, z, w)
+
+    #[doc = "Corresponds to a GLSL `dvec2` in std430 layout."] align(16) dvec2 DVec2<f64>(x, y)
+    #[doc = "Corresponds to a GLSL `dvec3` in std430 layout."] align(32) dvec3 DVec3<f64>(x, y, z)
+    #[doc = "Corresponds to a GLSL `dvec4` in std430 layout."] align(32) dvec4 DVec4<f64>(x, y, z, w)
+}
+
+macro_rules! matrices {
+    (
+        $(
+            #[$doc:meta]
+            align($align:literal)
+            $glsl_name:ident $name:ident {
+                $($field:ident: $field_ty:ty,)+
+            }
+        )+
+    ) => {
+        $(
+            #[$doc]
+            #[allow(missing_docs)]
+            #[derive(Debug, Clone, Copy)]
+            #[repr(C)]
+            pub struct $name {
+                $(pub $field: $field_ty,)+
+            }
+
+            unsafe impl Zeroable for $name {}
+            unsafe impl Pod for $name {}
+
+            unsafe impl Std430 for $name {
+                const ALIGNMENT: usize = $align;
+                /// Matrices are technically arrays of primitives, and as such require pad at end.
+                const PAD_AT_END: bool = true;
+                type Padded = Std430Padded<Self, {align_offset(size_of::<$name>(), $align)}>;
+            }
+
+            unsafe impl Glsl for $name {
+                const NAME: &'static str = stringify!($glsl_name);
+            }
+        )+
+    };
+}
+
+matrices! {
+    #[doc = "Corresponds to a GLSL `mat2` in std430 layout."]
+    align(8)
+    mat2 Mat2 {
+        x: Vec2,
+        y: Vec2,
+    }
+
+    #[doc = "Corresponds to a GLSL `mat3` in std430 layout."]
+    align(16)
+    mat3 Mat3 {
+        x: Vec3,
+        _pad_x: f32,
+        y: Vec3,
+        _pad_y: f32,
+        z: Vec3,
+        _pad_z: f32,
+    }
+
+    #[doc = "Corresponds to a GLSL `mat4` in std430 layout."]
+    align(16)
+    mat4 Mat4 {
+        x: Vec4,
+        y: Vec4,
+        z: Vec4,
+        w: Vec4,
+    }
+
+    #[doc = "Corresponds to a GLSL `dmat2` in std430 layout."]
+    align(16)
+    dmat2 DMat2 {
+        x: DVec2,
+        y: DVec2,
+    }
+
+    #[doc = "Corresponds to a GLSL `dmat3` in std430 layout."]
+    align(32)
+    dmat3 DMat3 {
+        x: DVec3,
+        _pad_x: f64,
+        y: DVec3,
+        _pad_y: f64,
+        z: DVec3,
+        _pad_z: f64,
+    }
+
+    #[doc = "Corresponds to a GLSL `dmat3` in std430 layout."]
+    align(32)
+    dmat4 DMat4 {
+        x: DVec4,
+        y: DVec4,
+        z: DVec4,
+        w: DVec4,
+    }
+}
diff --git a/crates/crevice/src/std430/sizer.rs b/crates/crevice/src/std430/sizer.rs
new file mode 100644
index 0000000000..20b7b29e0b
--- /dev/null
+++ b/crates/crevice/src/std430/sizer.rs
@@ -0,0 +1,81 @@
+use core::mem::size_of;
+
+use crate::internal::align_offset;
+use crate::std430::{AsStd430, Std430};
+
+/**
+Type that computes the buffer size needed by a series of `std430` types laid
+out.
+
+This type works well well when paired with `Writer`, precomputing a buffer's
+size to alleviate the need to dynamically re-allocate buffers.
+
+## Example
+
+```glsl
+struct Frob {
+    vec3 size;
+    float frobiness;
+}
+
+buffer FROBS {
+    uint len;
+    Frob[] frobs;
+} frobs;
+```
+
+```
+use crevice::std430::{self, AsStd430};
+
+#[derive(AsStd430)]
+struct Frob {
+    size: mint::Vector3<f32>,
+    frobiness: f32,
+}
+
+// Many APIs require that buffers contain at least enough space for all
+// fixed-size bindiongs to a buffer as well as one element of any arrays, if
+// there are any.
+let mut sizer = std430::Sizer::new();
+sizer.add::<u32>();
+sizer.add::<Frob>();
+
+# fn create_buffer_with_size(size: usize) {}
+let buffer = create_buffer_with_size(sizer.len());
+# assert_eq!(sizer.len(), 32);
+```
+*/
+pub struct Sizer {
+    offset: usize,
+}
+
+impl Sizer {
+    /// Create a new `Sizer`.
+    pub fn new() -> Self {
+        Self { offset: 0 }
+    }
+
+    /// Add a type's necessary padding and size to the `Sizer`. Returns the
+    /// offset into the buffer where that type would be written.
+    pub fn add<T>(&mut self) -> usize
+    where
+        T: AsStd430,
+    {
+        let size = size_of::<<T as AsStd430>::Output>();
+        let alignment = <T as AsStd430>::Output::ALIGNMENT;
+        let padding = align_offset(self.offset, alignment);
+
+        self.offset += padding;
+        let write_here = self.offset;
+
+        self.offset += size;
+
+        write_here
+    }
+
+    /// Returns the number of bytes required to contain all the types added to
+    /// the `Sizer`.
+    pub fn len(&self) -> usize {
+        self.offset
+    }
+}
diff --git a/crates/crevice/src/std430/traits.rs b/crates/crevice/src/std430/traits.rs
new file mode 100644
index 0000000000..6206ec7ac6
--- /dev/null
+++ b/crates/crevice/src/std430/traits.rs
@@ -0,0 +1,283 @@
+use core::mem::{size_of, MaybeUninit};
+#[cfg(feature = "std")]
+use std::io::{self, Write};
+
+use bytemuck::{bytes_of, Pod, Zeroable};
+
+#[cfg(feature = "std")]
+use crate::std430::Writer;
+
+/// Trait implemented for all `std430` primitives. Generally should not be
+/// implemented outside this crate.
+pub unsafe trait Std430: Copy + Zeroable + Pod {
+    /// The required alignment of the type. Must be a power of two.
+    ///
+    /// This is distinct from the value returned by `std::mem::align_of` because
+    /// `AsStd430` structs do not use Rust's alignment. This enables them to
+    /// control and zero their padding bytes, making converting them to and from
+    /// slices safe.
+    const ALIGNMENT: usize;
+
+    /// Whether this type requires a padding at the end (ie, is a struct or an array
+    /// of primitives).
+    /// See <https://www.khronos.org/registry/OpenGL/specs/gl/glspec45.core.pdf#page=159>
+    /// (rule 4 and 9)
+    const PAD_AT_END: bool = false;
+    /// Padded type (Std430Padded specialization)
+    /// The usual implementation is
+    /// type Padded = Std430Padded<Self, {align_offset(size_of::<Self>(), ALIGNMENT)}>;
+    type Padded: Std430Convertible<Self>;
+
+    /// Casts the type to a byte array. Implementors should not override this
+    /// method.
+    ///
+    /// # Safety
+    /// This is always safe due to the requirements of [`bytemuck::Pod`] being a
+    /// prerequisite for this trait.
+    fn as_bytes(&self) -> &[u8] {
+        bytes_of(self)
+    }
+}
+
+/// Trait specifically for Std430::Padded, implements conversions between padded type and base type.
+pub trait Std430Convertible<T: Std430>: Copy {
+    /// Convert from self to Std430
+    fn into_std430(self) -> T;
+    /// Convert from Std430 to self
+    fn from_std430(_: T) -> Self;
+}
+
+impl<T: Std430> Std430Convertible<T> for T {
+    fn into_std430(self) -> T {
+        self
+    }
+    fn from_std430(also_self: T) -> Self {
+        also_self
+    }
+}
+
+/// Unfortunately, we cannot easily derive padded representation for generic Std140 types.
+/// For now, we'll just use this empty enum with no values.
+#[derive(Copy, Clone)]
+pub enum InvalidPadded {}
+impl<T: Std430> Std430Convertible<T> for InvalidPadded {
+    fn into_std430(self) -> T {
+        unimplemented!()
+    }
+    fn from_std430(_: T) -> Self {
+        unimplemented!()
+    }
+}
+/**
+Trait implemented for all types that can be turned into `std430` values.
+
+This trait can often be `#[derive]`'d instead of manually implementing it. Any
+struct which contains only fields that also implement `AsStd430` can derive
+`AsStd430`.
+
+Types from the mint crate implement `AsStd430`, making them convenient for use
+in uniform types. Most Rust geometry crates, like cgmath, nalgebra, and
+ultraviolet support mint.
+
+## Example
+
+```glsl
+uniform CAMERA {
+    mat4 view;
+    mat4 projection;
+} camera;
+```
+
+```no_run
+use crevice::std430::{AsStd430, Std430};
+
+#[derive(AsStd430)]
+struct CameraUniform {
+    view: mint::ColumnMatrix4<f32>,
+    projection: mint::ColumnMatrix4<f32>,
+}
+
+let view: mint::ColumnMatrix4<f32> = todo!("your math code here");
+let projection: mint::ColumnMatrix4<f32> = todo!("your math code here");
+
+let camera = CameraUniform {
+    view,
+    projection,
+};
+
+# fn write_to_gpu_buffer(bytes: &[u8]) {}
+let camera_std430 = camera.as_std430();
+write_to_gpu_buffer(camera_std430.as_bytes());
+```
+*/
+pub trait AsStd430 {
+    /// The `std430` version of this value.
+    type Output: Std430;
+
+    /// Convert this value into the `std430` version of itself.
+    fn as_std430(&self) -> Self::Output;
+
+    /// Returns the size of the `std430` version of this type. Useful for
+    /// pre-sizing buffers.
+    fn std430_size_static() -> usize {
+        size_of::<Self::Output>()
+    }
+
+    /// Converts from `std430` version of self to self.
+    fn from_std430(value: Self::Output) -> Self;
+}
+
+impl<T> AsStd430 for T
+where
+    T: Std430,
+{
+    type Output = Self;
+
+    fn as_std430(&self) -> Self {
+        *self
+    }
+
+    fn from_std430(value: Self) -> Self {
+        value
+    }
+}
+
+#[doc(hidden)]
+#[derive(Copy, Clone, Debug)]
+pub struct Std430Padded<T: Std430, const PAD: usize> {
+    inner: T,
+    _padding: [u8; PAD],
+}
+
+unsafe impl<T: Std430, const PAD: usize> Zeroable for Std430Padded<T, PAD> {}
+unsafe impl<T: Std430, const PAD: usize> Pod for Std430Padded<T, PAD> {}
+
+impl<T: Std430, const PAD: usize> Std430Convertible<T> for Std430Padded<T, PAD> {
+    fn into_std430(self) -> T {
+        self.inner
+    }
+
+    fn from_std430(inner: T) -> Self {
+        Self {
+            inner,
+            _padding: [0u8; PAD],
+        }
+    }
+}
+
+#[doc(hidden)]
+#[derive(Copy, Clone, Debug)]
+#[repr(transparent)]
+pub struct Std430Array<T: Std430, const N: usize>([T::Padded; N]);
+
+unsafe impl<T: Std430, const N: usize> Zeroable for Std430Array<T, N> where T::Padded: Zeroable {}
+unsafe impl<T: Std430, const N: usize> Pod for Std430Array<T, N> where T::Padded: Pod {}
+unsafe impl<T: Std430, const N: usize> Std430 for Std430Array<T, N>
+where
+    T::Padded: Pod,
+{
+    const ALIGNMENT: usize = T::ALIGNMENT;
+    type Padded = Self;
+}
+
+impl<T: Std430, const N: usize> Std430Array<T, N> {
+    fn uninit_array() -> [MaybeUninit<T::Padded>; N] {
+        unsafe { MaybeUninit::uninit().assume_init() }
+    }
+
+    fn from_uninit_array(a: [MaybeUninit<T::Padded>; N]) -> Self {
+        unsafe { core::mem::transmute_copy(&a) }
+    }
+}
+
+impl<T: AsStd430, const N: usize> AsStd430 for [T; N]
+where
+    <T::Output as Std430>::Padded: Pod,
+{
+    type Output = Std430Array<T::Output, N>;
+    fn as_std430(&self) -> Self::Output {
+        let mut res = Self::Output::uninit_array();
+
+        for i in 0..N {
+            res[i] = MaybeUninit::new(Std430Convertible::from_std430(self[i].as_std430()));
+        }
+
+        Self::Output::from_uninit_array(res)
+    }
+
+    fn from_std430(val: Self::Output) -> Self {
+        let mut res: [MaybeUninit<T>; N] = unsafe { MaybeUninit::uninit().assume_init() };
+        for i in 0..N {
+            res[i] = MaybeUninit::new(T::from_std430(val.0[i].into_std430()));
+        }
+        unsafe { core::mem::transmute_copy(&res) }
+    }
+}
+
+/// Trait implemented for all types that can be written into a buffer as
+/// `std430` bytes. This type is more general than [`AsStd430`]: all `AsStd430`
+/// types implement `WriteStd430`, but not the other way around.
+///
+/// While `AsStd430` requires implementers to return a type that implements the
+/// `Std430` trait, `WriteStd430` directly writes bytes using a [`Writer`]. This
+/// makes `WriteStd430` usable for writing slices or other DSTs that could not
+/// implement `AsStd430` without allocating new memory on the heap.
+#[cfg(feature = "std")]
+pub trait WriteStd430 {
+    /// Writes this value into the given [`Writer`] using `std430` layout rules.
+    ///
+    /// Should return the offset of the first byte of this type, as returned by
+    /// the first call to [`Writer::write`].
+    fn write_std430<W: Write>(&self, writer: &mut Writer<W>) -> io::Result<usize>;
+
+    /// The space required to write this value using `std430` layout rules. This
+    /// does not include alignment padding that may be needed before or after
+    /// this type when written as part of a larger buffer.
+    fn std430_size(&self) -> usize {
+        let mut writer = Writer::new(io::sink());
+        self.write_std430(&mut writer).unwrap();
+        writer.len()
+    }
+}
+
+#[cfg(feature = "std")]
+impl<T> WriteStd430 for T
+where
+    T: AsStd430,
+{
+    fn write_std430<W: Write>(&self, writer: &mut Writer<W>) -> io::Result<usize> {
+        writer.write_std430(&self.as_std430())
+    }
+
+    fn std430_size(&self) -> usize {
+        size_of::<<Self as AsStd430>::Output>()
+    }
+}
+
+#[cfg(feature = "std")]
+impl<T> WriteStd430 for [T]
+where
+    T: WriteStd430,
+{
+    fn write_std430<W: Write>(&self, writer: &mut Writer<W>) -> io::Result<usize> {
+        let mut offset = writer.len();
+
+        let mut iter = self.iter();
+
+        if let Some(item) = iter.next() {
+            offset = item.write_std430(writer)?;
+        }
+
+        for item in self.iter() {
+            item.write_std430(writer)?;
+        }
+
+        Ok(offset)
+    }
+
+    fn std430_size(&self) -> usize {
+        let mut writer = Writer::new(io::sink());
+        self.write_std430(&mut writer).unwrap();
+        writer.len()
+    }
+}
diff --git a/crates/crevice/src/std430/writer.rs b/crates/crevice/src/std430/writer.rs
new file mode 100644
index 0000000000..5184555435
--- /dev/null
+++ b/crates/crevice/src/std430/writer.rs
@@ -0,0 +1,150 @@
+use std::io::{self, Write};
+use std::mem::size_of;
+
+use bytemuck::bytes_of;
+
+use crate::internal::align_offset;
+use crate::std430::{AsStd430, Std430, WriteStd430};
+
+/**
+Type that enables writing correctly aligned `std430` values to a buffer.
+
+`Writer` is useful when many values need to be laid out in a row that cannot be
+represented by a struct alone, like dynamically sized arrays or dynamically
+laid-out values.
+
+## Example
+In this example, we'll write a length-prefixed list of lights to a buffer.
+`std430::Writer` helps align correctly, even across multiple structs, which can
+be tricky and error-prone otherwise.
+
+```glsl
+struct PointLight {
+    vec3 position;
+    vec3 color;
+    float brightness;
+};
+
+buffer POINT_LIGHTS {
+    uint len;
+    PointLight[] lights;
+} point_lights;
+```
+
+```
+use crevice::std430::{self, AsStd430};
+
+#[derive(AsStd430)]
+struct PointLight {
+    position: mint::Vector3<f32>,
+    color: mint::Vector3<f32>,
+    brightness: f32,
+}
+
+let lights = vec![
+    PointLight {
+        position: [0.0, 1.0, 0.0].into(),
+        color: [1.0, 0.0, 0.0].into(),
+        brightness: 0.6,
+    },
+    PointLight {
+        position: [0.0, 4.0, 3.0].into(),
+        color: [1.0, 1.0, 1.0].into(),
+        brightness: 1.0,
+    },
+];
+
+# fn map_gpu_buffer_for_write() -> &'static mut [u8] {
+#     Box::leak(vec![0; 1024].into_boxed_slice())
+# }
+let target_buffer = map_gpu_buffer_for_write();
+let mut writer = std430::Writer::new(target_buffer);
+
+let light_count = lights.len() as u32;
+writer.write(&light_count)?;
+
+// Crevice will automatically insert the required padding to align the
+// PointLight structure correctly. In this case, there will be 12 bytes of
+// padding between the length field and the light list.
+
+writer.write(lights.as_slice())?;
+
+# fn unmap_gpu_buffer() {}
+unmap_gpu_buffer();
+
+# Ok::<(), std::io::Error>(())
+```
+*/
+pub struct Writer<W> {
+    writer: W,
+    offset: usize,
+}
+
+impl<W: Write> Writer<W> {
+    /// Create a new `Writer`, wrapping a buffer, file, or other type that
+    /// implements [`std::io::Write`].
+    pub fn new(writer: W) -> Self {
+        Self { writer, offset: 0 }
+    }
+
+    /// Write a new value to the underlying buffer, writing zeroed padding where
+    /// necessary.
+    ///
+    /// Returns the offset into the buffer that the value was written to.
+    pub fn write<T>(&mut self, value: &T) -> io::Result<usize>
+    where
+        T: WriteStd430 + ?Sized,
+    {
+        value.write_std430(self)
+    }
+
+    /// Write an iterator of values to the underlying buffer.
+    ///
+    /// Returns the offset into the buffer that the first value was written to.
+    /// If no values were written, returns the `len()`.
+    pub fn write_iter<I, T>(&mut self, iter: I) -> io::Result<usize>
+    where
+        I: IntoIterator<Item = T>,
+        T: WriteStd430,
+    {
+        let mut offset = self.offset;
+
+        let mut iter = iter.into_iter();
+
+        if let Some(item) = iter.next() {
+            offset = item.write_std430(self)?;
+        }
+
+        for item in iter {
+            item.write_std430(self)?;
+        }
+
+        Ok(offset)
+    }
+
+    /// Write an `Std430` type to the underlying buffer.
+    pub fn write_std430<T>(&mut self, value: &T) -> io::Result<usize>
+    where
+        T: Std430,
+    {
+        let padding = align_offset(self.offset, T::ALIGNMENT);
+
+        for _ in 0..padding {
+            self.writer.write_all(&[0])?;
+        }
+        self.offset += padding;
+
+        let value = value.as_std430();
+        self.writer.write_all(bytes_of(&value))?;
+
+        let write_here = self.offset;
+        self.offset += size_of::<T>();
+
+        Ok(write_here)
+    }
+
+    /// Returns the amount of data written by this `Writer`.
+    pub fn len(&self) -> usize {
+        self.offset
+    }
+}
diff --git a/crates/crevice/src/util.rs b/crates/crevice/src/util.rs
new file mode 100644
index 0000000000..9c6c2a3964
--- /dev/null
+++ b/crates/crevice/src/util.rs
@@ -0,0 +1,97 @@
+#![allow(unused_macros)]
+
+macro_rules! easy_impl {
+    ( $( $std_name:ident $imp_ty:ty { $($field:ident),* }, )* ) => {
+        $(
+            impl crate::std140::AsStd140 for $imp_ty {
+                type Output = crate::std140::$std_name;
+
+                #[inline]
+                fn as_std140(&self) -> Self::Output {
+                    crate::std140::$std_name {
+                        $(
+                            $field: self.$field.as_std140(),
+                        )*
+                        ..bytemuck::Zeroable::zeroed()
+                    }
+                }
+
+                #[inline]
+                fn from_std140(value: Self::Output) -> Self {
+                    Self {
+                        $(
+                            $field: <_ as crate::std140::AsStd140>::from_std140(value.$field),
+                        )*
+                    }
+                }
+            }
+
+            impl crate::std430::AsStd430 for $imp_ty {
+                type Output = crate::std430::$std_name;
+
+                #[inline]
+                fn as_std430(&self) -> Self::Output {
+                    crate::std430::$std_name {
+                        $(
+                            $field: self.$field.as_std430(),
+                        )*
+                        ..bytemuck::Zeroable::zeroed()
+                    }
+                }
+
+                #[inline]
+                fn from_std430(value: Self::Output) -> Self {
+                    Self {
+                        $(
+                            $field: <_ as crate::std430::AsStd430>::from_std430(value.$field),
+                        )*
+                    }
+                }
+            }
+
+            unsafe impl crate::glsl::Glsl for $imp_ty {
+                const NAME: &'static str = crate::std140::$std_name::NAME;
+            }
+        )*
+    };
+}
+
+macro_rules! minty_impl {
+    ( $( $mint_ty:ty => $imp_ty:ty, )* ) => {
+        $(
+            impl crate::std140::AsStd140 for $imp_ty {
+                type Output = <$mint_ty as crate::std140::AsStd140>::Output;
+
+                #[inline]
+                fn as_std140(&self) -> Self::Output {
+                    let mint: $mint_ty = (*self).into();
+                    mint.as_std140()
+                }
+
+                #[inline]
+                fn from_std140(value: Self::Output) -> Self {
+                    <$mint_ty>::from_std140(value).into()
+                }
+            }
+
+            impl crate::std430::AsStd430 for $imp_ty {
+                type Output = <$mint_ty as crate::std430::AsStd430>::Output;
+
+                #[inline]
+                fn as_std430(&self) -> Self::Output {
+                    let mint: $mint_ty = (*self).into();
+                    mint.as_std430()
+                }
+
+                #[inline]
+                fn from_std430(value: Self::Output) -> Self {
+                    <$mint_ty>::from_std430(value).into()
+                }
+            }
+
+            unsafe impl crate::glsl::Glsl for $imp_ty {
+                const NAME: &'static str = <$mint_ty>::NAME;
+            }
+        )*
+    };
+}
diff --git a/crates/crevice/tests/snapshots/test__generate_struct_array_glsl.snap b/crates/crevice/tests/snapshots/test__generate_struct_array_glsl.snap
new file mode 100644
index 0000000000..7829bd64ca
--- /dev/null
+++ b/crates/crevice/tests/snapshots/test__generate_struct_array_glsl.snap
@@ -0,0 +1,8 @@
+---
+source: tests/test.rs
+expression: "TestGlsl::glsl_definition()"
+
+---
+struct TestGlsl {
+	vec3 foo[8][4];
+};
diff --git a/crates/crevice/tests/snapshots/test__generate_struct_glsl.snap b/crates/crevice/tests/snapshots/test__generate_struct_glsl.snap
new file mode 100644
index 0000000000..42fc1f4cd7
--- /dev/null
+++ b/crates/crevice/tests/snapshots/test__generate_struct_glsl.snap
@@ -0,0 +1,9 @@
+---
+source: tests/test.rs
+expression: "TestGlsl::glsl_definition()"
+
+---
+struct TestGlsl {
+	vec3 foo;
+	mat2 bar;
+};
diff --git a/crates/crevice/tests/test.rs b/crates/crevice/tests/test.rs
new file mode 100644
index 0000000000..f07786c827
--- /dev/null
+++ b/crates/crevice/tests/test.rs
@@ -0,0 +1,61 @@
+use crevice::glsl::GlslStruct;
+use crevice::std140::AsStd140;
+
+#[test]
+fn there_and_back_again() {
+    #[derive(AsStd140, Debug, PartialEq)]
+    struct ThereAndBackAgain {
+        view: mint::ColumnMatrix3<f32>,
+        origin: mint::Vector3<f32>,
+    }
+
+    let x = ThereAndBackAgain {
+        view: mint::ColumnMatrix3 {
+            x: mint::Vector3 {
+                x: 1.0,
+                y: 0.0,
+                z: 0.0,
+            },
+            y: mint::Vector3 {
+                x: 0.0,
+                y: 1.0,
+                z: 0.0,
+            },
+            z: mint::Vector3 {
+                x: 0.0,
+                y: 0.0,
+                z: 1.0,
+            },
+        },
+        origin: mint::Vector3 {
+            x: 0.0,
+            y: 1.0,
+            z: 2.0,
+        },
+    };
+    let x_as = x.as_std140();
+    assert_eq!(<ThereAndBackAgain as AsStd140>::from_std140(x_as), x);
+}
+
+#[test]
+fn generate_struct_glsl() {
+    #[allow(dead_code)]
+    #[derive(GlslStruct)]
+    struct TestGlsl {
+        foo: mint::Vector3<f32>,
+        bar: mint::ColumnMatrix2<f32>,
+    }
+
+    insta::assert_display_snapshot!(TestGlsl::glsl_definition());
+}
+
+#[test]
+fn generate_struct_array_glsl() {
+    #[allow(dead_code)]
+    #[derive(GlslStruct)]
+    struct TestGlsl {
+        foo: [[mint::Vector3<f32>; 8]; 4],
+    }
+
+    insta::assert_display_snapshot!(TestGlsl::glsl_definition());
+}
diff --git a/examples/2d/pipelined_texture_atlas.rs b/examples/2d/pipelined_texture_atlas.rs
new file mode 100644
index 0000000000..ac3ec98584
--- /dev/null
+++ b/examples/2d/pipelined_texture_atlas.rs
@@ -0,0 +1,94 @@
+use bevy::{
+    asset::LoadState,
+    math::Vec3,
+    prelude::{
+        App, AssetServer, Assets, Commands, HandleUntyped, IntoSystem, Res, ResMut, State,
+        SystemSet, Transform,
+    },
+    render2::{camera::OrthographicCameraBundle, texture::Image},
+    sprite2::{
+        PipelinedSpriteBundle, PipelinedSpriteSheetBundle, TextureAtlas, TextureAtlasBuilder,
+        TextureAtlasSprite,
+    },
+    PipelinedDefaultPlugins,
+};
+
+/// In this example we generate a new texture atlas (sprite sheet) from a folder containing
+/// individual sprites
+fn main() {
+    App::new()
+        .init_resource::<RpgSpriteHandles>()
+        .add_plugins(PipelinedDefaultPlugins)
+        .add_state(AppState::Setup)
+        .add_system_set(SystemSet::on_enter(AppState::Setup).with_system(load_textures.system()))
+        .add_system_set(SystemSet::on_update(AppState::Setup).with_system(check_textures.system()))
+        .add_system_set(SystemSet::on_enter(AppState::Finished).with_system(setup.system()))
+        .run();
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+enum AppState {
+    Setup,
+    Finished,
+}
+
+#[derive(Default)]
+struct RpgSpriteHandles {
+    handles: Vec<HandleUntyped>,
+}
+
+fn load_textures(mut rpg_sprite_handles: ResMut<RpgSpriteHandles>, asset_server: Res<AssetServer>) {
+    rpg_sprite_handles.handles = asset_server.load_folder("textures/rpg").unwrap();
+}
+
+fn check_textures(
+    mut state: ResMut<State<AppState>>,
+    rpg_sprite_handles: ResMut<RpgSpriteHandles>,
+    asset_server: Res<AssetServer>,
+) {
+    if let LoadState::Loaded =
+        asset_server.get_group_load_state(rpg_sprite_handles.handles.iter().map(|handle| handle.id))
+    {
+        state.set(AppState::Finished).unwrap();
+    }
+}
+
+fn setup(
+    mut commands: Commands,
+    rpg_sprite_handles: Res<RpgSpriteHandles>,
+    asset_server: Res<AssetServer>,
+    mut texture_atlases: ResMut<Assets<TextureAtlas>>,
+    mut textures: ResMut<Assets<Image>>,
+) {
+    let mut texture_atlas_builder = TextureAtlasBuilder::default();
+    for handle in rpg_sprite_handles.handles.iter() {
+        let texture = textures.get(handle).unwrap();
+        texture_atlas_builder.add_texture(handle.clone_weak().typed::<Image>(), texture);
+    }
+
+    let texture_atlas = texture_atlas_builder.finish(&mut textures).unwrap();
+    let texture_atlas_texture = texture_atlas.texture.clone();
+    let vendor_handle = asset_server.get_handle("textures/rpg/chars/vendor/generic-rpg-vendor.png");
+    let vendor_index = texture_atlas.get_texture_index(&vendor_handle).unwrap();
+    let atlas_handle = texture_atlases.add(texture_atlas);
+
+    // set up a scene to display our texture atlas
+    commands.spawn_bundle(OrthographicCameraBundle::new_2d());
+    // draw a sprite from the atlas
+    commands.spawn_bundle(PipelinedSpriteSheetBundle {
+        transform: Transform {
+            translation: Vec3::new(150.0, 0.0, 0.0),
+            scale: Vec3::splat(4.0),
+            ..Default::default()
+        },
+        sprite: TextureAtlasSprite::new(vendor_index),
+        texture_atlas: atlas_handle,
+        ..Default::default()
+    });
+    // draw the atlas itself
+    commands.spawn_bundle(PipelinedSpriteBundle {
+        texture: texture_atlas_texture,
+        transform: Transform::from_xyz(-300.0, 0.0, 0.0),
+        ..Default::default()
+    });
+}
diff --git a/examples/3d/3d_scene_pipelined.rs b/examples/3d/3d_scene_pipelined.rs
new file mode 100644
index 0000000000..48e30cfa8c
--- /dev/null
+++ b/examples/3d/3d_scene_pipelined.rs
@@ -0,0 +1,255 @@
+use bevy::{
+    core::Time,
+    diagnostic::{FrameTimeDiagnosticsPlugin, LogDiagnosticsPlugin},
+    ecs::prelude::*,
+    input::Input,
+    math::{Quat, Vec3},
+    pbr2::{
+        AmbientLight, DirectionalLight, DirectionalLightBundle, PbrBundle, PointLight,
+        PointLightBundle, StandardMaterial,
+    },
+    prelude::{App, Assets, BuildChildren, KeyCode, Transform},
+    render2::{
+        camera::{OrthographicProjection, PerspectiveCameraBundle},
+        color::Color,
+        mesh::{shape, Mesh},
+    },
+    PipelinedDefaultPlugins,
+};
+
+fn main() {
+    App::new()
+        .add_plugins(PipelinedDefaultPlugins)
+        .add_plugin(FrameTimeDiagnosticsPlugin::default())
+        .add_plugin(LogDiagnosticsPlugin::default())
+        .add_startup_system(setup)
+        .add_system(movement)
+        .add_system(animate_light_direction)
+        .run();
+}
+
+#[derive(Component)]
+struct Movable;
+
+/// set up a simple 3D scene
+fn setup(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) {
+    // ground plane
+    commands.spawn_bundle(PbrBundle {
+        mesh: meshes.add(Mesh::from(shape::Plane { size: 10.0 })),
+        material: materials.add(StandardMaterial {
+            base_color: Color::WHITE,
+            perceptual_roughness: 1.0,
+            ..Default::default()
+        }),
+        ..Default::default()
+    });
+
+    // left wall
+    let mut transform = Transform::from_xyz(2.5, 2.5, 0.0);
+    transform.rotate(Quat::from_rotation_z(std::f32::consts::FRAC_PI_2));
+    commands.spawn_bundle(PbrBundle {
+        mesh: meshes.add(Mesh::from(shape::Box::new(5.0, 0.15, 5.0))),
+        transform,
+        material: materials.add(StandardMaterial {
+            base_color: Color::INDIGO,
+            perceptual_roughness: 1.0,
+            ..Default::default()
+        }),
+        ..Default::default()
+    });
+    // back (right) wall
+    let mut transform = Transform::from_xyz(0.0, 2.5, -2.5);
+    transform.rotate(Quat::from_rotation_x(std::f32::consts::FRAC_PI_2));
+    commands.spawn_bundle(PbrBundle {
+        mesh: meshes.add(Mesh::from(shape::Box::new(5.0, 0.15, 5.0))),
+        transform,
+        material: materials.add(StandardMaterial {
+            base_color: Color::INDIGO,
+            perceptual_roughness: 1.0,
+            ..Default::default()
+        }),
+        ..Default::default()
+    });
+
+    // cube
+    commands
+        .spawn_bundle(PbrBundle {
+            mesh: meshes.add(Mesh::from(shape::Cube { size: 1.0 })),
+            material: materials.add(StandardMaterial {
+                base_color: Color::PINK,
+                ..Default::default()
+            }),
+            transform: Transform::from_xyz(0.0, 0.5, 0.0),
+            ..Default::default()
+        })
+        .insert(Movable);
+    // sphere
+    commands
+        .spawn_bundle(PbrBundle {
+            mesh: meshes.add(Mesh::from(shape::UVSphere {
+                radius: 0.5,
+                ..Default::default()
+            })),
+            material: materials.add(StandardMaterial {
+                base_color: Color::LIME_GREEN,
+                ..Default::default()
+            }),
+            transform: Transform::from_xyz(1.5, 1.0, 1.5),
+            ..Default::default()
+        })
+        .insert(Movable);
+
+    // ambient light
+    commands.insert_resource(AmbientLight {
+        color: Color::ORANGE_RED,
+        brightness: 0.02,
+    });
+
+    // red point light
+    commands
+        .spawn_bundle(PointLightBundle {
+            // transform: Transform::from_xyz(5.0, 8.0, 2.0),
+            transform: Transform::from_xyz(1.0, 2.0, 0.0),
+            point_light: PointLight {
+                intensity: 1600.0, // lumens - roughly a 100W non-halogen incandescent bulb
+                color: Color::RED,
+                ..Default::default()
+            },
+            ..Default::default()
+        })
+        .with_children(|builder| {
+            builder.spawn_bundle(PbrBundle {
+                mesh: meshes.add(Mesh::from(shape::UVSphere {
+                    radius: 0.1,
+                    ..Default::default()
+                })),
+                material: materials.add(StandardMaterial {
+                    base_color: Color::RED,
+                    emissive: Color::rgba_linear(100.0, 0.0, 0.0, 0.0),
+                    ..Default::default()
+                }),
+                ..Default::default()
+            });
+        });
+
+    // green point light
+    commands
+        .spawn_bundle(PointLightBundle {
+            // transform: Transform::from_xyz(5.0, 8.0, 2.0),
+            transform: Transform::from_xyz(-1.0, 2.0, 0.0),
+            point_light: PointLight {
+                intensity: 1600.0, // lumens - roughly a 100W non-halogen incandescent bulb
+                color: Color::GREEN,
+                ..Default::default()
+            },
+            ..Default::default()
+        })
+        .with_children(|builder| {
+            builder.spawn_bundle(PbrBundle {
+                mesh: meshes.add(Mesh::from(shape::UVSphere {
+                    radius: 0.1,
+                    ..Default::default()
+                })),
+                material: materials.add(StandardMaterial {
+                    base_color: Color::GREEN,
+                    emissive: Color::rgba_linear(0.0, 100.0, 0.0, 0.0),
+                    ..Default::default()
+                }),
+                ..Default::default()
+            });
+        });
+
+    // blue point light
+    commands
+        .spawn_bundle(PointLightBundle {
+            // transform: Transform::from_xyz(5.0, 8.0, 2.0),
+            transform: Transform::from_xyz(0.0, 4.0, 0.0),
+            point_light: PointLight {
+                intensity: 1600.0, // lumens - roughly a 100W non-halogen incandescent bulb
+                color: Color::BLUE,
+                ..Default::default()
+            },
+            ..Default::default()
+        })
+        .with_children(|builder| {
+            builder.spawn_bundle(PbrBundle {
+                mesh: meshes.add(Mesh::from(shape::UVSphere {
+                    radius: 0.1,
+                    ..Default::default()
+                })),
+                material: materials.add(StandardMaterial {
+                    base_color: Color::BLUE,
+                    emissive: Color::rgba_linear(0.0, 0.0, 100.0, 0.0),
+                    ..Default::default()
+                }),
+                ..Default::default()
+            });
+        });
+
+    // directional 'sun' light
+    const HALF_SIZE: f32 = 10.0;
+    commands.spawn_bundle(DirectionalLightBundle {
+        directional_light: DirectionalLight {
+            // Configure the projection to better fit the scene
+            shadow_projection: OrthographicProjection {
+                left: -HALF_SIZE,
+                right: HALF_SIZE,
+                bottom: -HALF_SIZE,
+                top: HALF_SIZE,
+                near: -10.0 * HALF_SIZE,
+                far: 10.0 * HALF_SIZE,
+                ..Default::default()
+            },
+            ..Default::default()
+        },
+        transform: Transform {
+            translation: Vec3::new(0.0, 2.0, 0.0),
+            rotation: Quat::from_rotation_x(-std::f32::consts::FRAC_PI_4),
+            ..Default::default()
+        },
+        ..Default::default()
+    });
+
+    // camera
+    commands.spawn_bundle(PerspectiveCameraBundle {
+        transform: Transform::from_xyz(-2.0, 2.5, 5.0).looking_at(Vec3::ZERO, Vec3::Y),
+        ..Default::default()
+    });
+}
+
+fn animate_light_direction(
+    time: Res<Time>,
+    mut query: Query<&mut Transform, With<DirectionalLight>>,
+) {
+    for mut transform in query.iter_mut() {
+        transform.rotate(Quat::from_rotation_y(time.delta_seconds() * 0.5));
+    }
+}
+
+fn movement(
+    input: Res<Input<KeyCode>>,
+    time: Res<Time>,
+    mut query: Query<&mut Transform, With<Movable>>,
+) {
+    for mut transform in query.iter_mut() {
+        let mut direction = Vec3::ZERO;
+        if input.pressed(KeyCode::Up) {
+            direction.y += 1.0;
+        }
+        if input.pressed(KeyCode::Down) {
+            direction.y -= 1.0;
+        }
+        if input.pressed(KeyCode::Left) {
+            direction.x -= 1.0;
+        }
+        if input.pressed(KeyCode::Right) {
+            direction.x += 1.0;
+        }
+
+        transform.translation += time.delta_seconds() * 2.0 * direction;
+    }
+}
diff --git a/examples/3d/cornell_box_pipelined.rs b/examples/3d/cornell_box_pipelined.rs
new file mode 100644
index 0000000000..161b268fb7
--- /dev/null
+++ b/examples/3d/cornell_box_pipelined.rs
@@ -0,0 +1,172 @@
+use bevy::{
+    diagnostic::{FrameTimeDiagnosticsPlugin, LogDiagnosticsPlugin},
+    ecs::prelude::*,
+    math::{Mat4, Quat, Vec3},
+    pbr2::{
+        AmbientLight, DirectionalLight, DirectionalLightBundle, PbrBundle, PointLight,
+        PointLightBundle, StandardMaterial,
+    },
+    prelude::{App, Assets, BuildChildren, Transform},
+    render2::{
+        camera::{OrthographicProjection, PerspectiveCameraBundle},
+        color::Color,
+        mesh::{shape, Mesh},
+    },
+    PipelinedDefaultPlugins,
+};
+
+fn main() {
+    App::new()
+        .add_plugins(PipelinedDefaultPlugins)
+        .add_plugin(FrameTimeDiagnosticsPlugin::default())
+        .add_plugin(LogDiagnosticsPlugin::default())
+        .add_startup_system(setup)
+        .run();
+}
+
+/// set up a simple 3D scene
+fn setup(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) {
+    let box_size = 2.0;
+    let box_thickness = 0.15;
+    let box_offset = (box_size + box_thickness) / 2.0;
+
+    // left - red
+    let mut transform = Transform::from_xyz(-box_offset, box_offset, 0.0);
+    transform.rotate(Quat::from_rotation_z(std::f32::consts::FRAC_PI_2));
+    commands.spawn_bundle(PbrBundle {
+        mesh: meshes.add(Mesh::from(shape::Box::new(
+            box_size,
+            box_thickness,
+            box_size,
+        ))),
+        transform,
+        material: materials.add(StandardMaterial {
+            base_color: Color::rgb(0.63, 0.065, 0.05),
+            ..Default::default()
+        }),
+        ..Default::default()
+    });
+    // right - green
+    let mut transform = Transform::from_xyz(box_offset, box_offset, 0.0);
+    transform.rotate(Quat::from_rotation_z(std::f32::consts::FRAC_PI_2));
+    commands.spawn_bundle(PbrBundle {
+        mesh: meshes.add(Mesh::from(shape::Box::new(
+            box_size,
+            box_thickness,
+            box_size,
+        ))),
+        transform,
+        material: materials.add(StandardMaterial {
+            base_color: Color::rgb(0.14, 0.45, 0.091),
+            ..Default::default()
+        }),
+        ..Default::default()
+    });
+    // bottom - white
+    commands.spawn_bundle(PbrBundle {
+        mesh: meshes.add(Mesh::from(shape::Box::new(
+            box_size + 2.0 * box_thickness,
+            box_thickness,
+            box_size,
+        ))),
+        material: materials.add(StandardMaterial {
+            base_color: Color::rgb(0.725, 0.71, 0.68),
+            ..Default::default()
+        }),
+        ..Default::default()
+    });
+    // top - white
+    let transform = Transform::from_xyz(0.0, 2.0 * box_offset, 0.0);
+    commands.spawn_bundle(PbrBundle {
+        mesh: meshes.add(Mesh::from(shape::Box::new(
+            box_size + 2.0 * box_thickness,
+            box_thickness,
+            box_size,
+        ))),
+        transform,
+        material: materials.add(StandardMaterial {
+            base_color: Color::rgb(0.725, 0.71, 0.68),
+            ..Default::default()
+        }),
+        ..Default::default()
+    });
+    // back - white
+    let mut transform = Transform::from_xyz(0.0, box_offset, -box_offset);
+    transform.rotate(Quat::from_rotation_x(std::f32::consts::FRAC_PI_2));
+    commands.spawn_bundle(PbrBundle {
+        mesh: meshes.add(Mesh::from(shape::Box::new(
+            box_size + 2.0 * box_thickness,
+            box_thickness,
+            box_size + 2.0 * box_thickness,
+        ))),
+        transform,
+        material: materials.add(StandardMaterial {
+            base_color: Color::rgb(0.725, 0.71, 0.68),
+            ..Default::default()
+        }),
+        ..Default::default()
+    });
+
+    // ambient light
+    commands.insert_resource(AmbientLight {
+        color: Color::WHITE,
+        brightness: 0.02,
+    });
+    // top light
+    commands
+        .spawn_bundle(PbrBundle {
+            mesh: meshes.add(Mesh::from(shape::Plane { size: 0.4 })),
+            transform: Transform::from_matrix(Mat4::from_scale_rotation_translation(
+                Vec3::ONE,
+                Quat::from_rotation_x(std::f32::consts::PI),
+                Vec3::new(0.0, box_size + 0.5 * box_thickness, 0.0),
+            )),
+            material: materials.add(StandardMaterial {
+                base_color: Color::WHITE,
+                emissive: Color::WHITE * 100.0,
+                ..Default::default()
+            }),
+            ..Default::default()
+        })
+        .with_children(|builder| {
+            builder.spawn_bundle(PointLightBundle {
+                point_light: PointLight {
+                    color: Color::WHITE,
+                    intensity: 25.0,
+                    ..Default::default()
+                },
+                transform: Transform::from_translation((box_thickness + 0.05) * Vec3::Y),
+                ..Default::default()
+            });
+        });
+    // directional light
+    const HALF_SIZE: f32 = 10.0;
+    commands.spawn_bundle(DirectionalLightBundle {
+        directional_light: DirectionalLight {
+            illuminance: 10000.0,
+            shadow_projection: OrthographicProjection {
+                left: -HALF_SIZE,
+                right: HALF_SIZE,
+                bottom: -HALF_SIZE,
+                top: HALF_SIZE,
+                near: -10.0 * HALF_SIZE,
+                far: 10.0 * HALF_SIZE,
+                ..Default::default()
+            },
+            ..Default::default()
+        },
+        transform: Transform::from_rotation(Quat::from_rotation_x(-std::f32::consts::PI / 2.0)),
+        ..Default::default()
+    });
+
+    // camera
+    commands.spawn_bundle(PerspectiveCameraBundle {
+        transform: Transform::from_xyz(0.0, box_offset, 4.0)
+            .looking_at(Vec3::new(0.0, box_offset, 0.0), Vec3::Y),
+        ..Default::default()
+    });
+}
diff --git a/examples/3d/load_gltf_pipelined.rs b/examples/3d/load_gltf_pipelined.rs
new file mode 100644
index 0000000000..8b842095e9
--- /dev/null
+++ b/examples/3d/load_gltf_pipelined.rs
@@ -0,0 +1,62 @@
+use bevy::{
+    core::Time,
+    ecs::prelude::*,
+    math::{EulerRot, Quat, Vec3},
+    pbr2::{AmbientLight, DirectionalLight, DirectionalLightBundle},
+    prelude::{App, AssetServer, SpawnSceneCommands, Transform},
+    render2::{
+        camera::{OrthographicProjection, PerspectiveCameraBundle},
+        color::Color,
+    },
+    PipelinedDefaultPlugins,
+};
+
+fn main() {
+    App::new()
+        .insert_resource(AmbientLight {
+            color: Color::WHITE,
+            brightness: 1.0 / 5.0f32,
+        })
+        .add_plugins(PipelinedDefaultPlugins)
+        .add_startup_system(setup.system())
+        .add_system(animate_light_direction.system())
+        .run();
+}
+
+fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
+    commands.spawn_scene(asset_server.load("models/FlightHelmet/FlightHelmet.gltf#Scene0"));
+    commands.spawn_bundle(PerspectiveCameraBundle {
+        transform: Transform::from_xyz(0.7, 0.7, 1.0).looking_at(Vec3::new(0.0, 0.3, 0.0), Vec3::Y),
+        ..Default::default()
+    });
+    const HALF_SIZE: f32 = 1.0;
+    commands.spawn_bundle(DirectionalLightBundle {
+        directional_light: DirectionalLight {
+            shadow_projection: OrthographicProjection {
+                left: -HALF_SIZE,
+                right: HALF_SIZE,
+                bottom: -HALF_SIZE,
+                top: HALF_SIZE,
+                near: -10.0 * HALF_SIZE,
+                far: 10.0 * HALF_SIZE,
+                ..Default::default()
+            },
+            ..Default::default()
+        },
+        ..Default::default()
+    });
+}
+
+fn animate_light_direction(
+    time: Res<Time>,
+    mut query: Query<&mut Transform, With<DirectionalLight>>,
+) {
+    for mut transform in query.iter_mut() {
+        transform.rotation = Quat::from_euler(
+            EulerRot::ZYX,
+            0.0,
+            time.seconds_since_startup() as f32 * std::f32::consts::TAU / 10.0,
+            -std::f32::consts::FRAC_PI_4,
+        );
+    }
+}
diff --git a/examples/3d/many_cubes_pipelined.rs b/examples/3d/many_cubes_pipelined.rs
new file mode 100644
index 0000000000..7ed8f248a9
--- /dev/null
+++ b/examples/3d/many_cubes_pipelined.rs
@@ -0,0 +1,50 @@
+use bevy::{
+    diagnostic::{FrameTimeDiagnosticsPlugin, LogDiagnosticsPlugin},
+    ecs::prelude::*,
+    pbr2::{PbrBundle, StandardMaterial},
+    prelude::{App, Assets, Transform},
+    render2::{
+        camera::PerspectiveCameraBundle,
+        color::Color,
+        mesh::{shape, Mesh},
+    },
+    PipelinedDefaultPlugins,
+};
+
+fn main() {
+    App::new()
+        .add_plugins(PipelinedDefaultPlugins)
+        .add_plugin(FrameTimeDiagnosticsPlugin::default())
+        .add_plugin(LogDiagnosticsPlugin::default())
+        .add_startup_system(setup.system())
+        .run();
+}
+
+fn setup(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) {
+    const WIDTH: usize = 100;
+    const HEIGHT: usize = 100;
+    for x in 0..WIDTH {
+        for y in 0..HEIGHT {
+            // cube
+            commands.spawn_bundle(PbrBundle {
+                mesh: meshes.add(Mesh::from(shape::Cube { size: 1.0 })),
+                material: materials.add(StandardMaterial {
+                    base_color: Color::PINK,
+                    ..Default::default()
+                }),
+                transform: Transform::from_xyz((x as f32) * 2.0, (y as f32) * 2.0, 0.0),
+                ..Default::default()
+            });
+        }
+    }
+
+    // camera
+    commands.spawn_bundle(PerspectiveCameraBundle {
+        transform: Transform::from_xyz(80.0, 80.0, 300.0),
+        ..Default::default()
+    });
+}
diff --git a/examples/3d/msaa_pipelined.rs b/examples/3d/msaa_pipelined.rs
new file mode 100644
index 0000000000..f259ed2a22
--- /dev/null
+++ b/examples/3d/msaa_pipelined.rs
@@ -0,0 +1,68 @@
+use bevy::{
+    ecs::prelude::*,
+    input::Input,
+    math::Vec3,
+    pbr2::{PbrBundle, PointLightBundle, StandardMaterial},
+    prelude::{App, Assets, KeyCode, Transform},
+    render2::{
+        camera::PerspectiveCameraBundle,
+        color::Color,
+        mesh::{shape, Mesh},
+        view::Msaa,
+    },
+    PipelinedDefaultPlugins,
+};
+
+/// This example shows how to configure Multi-Sample Anti-Aliasing. Setting the sample count higher
+/// will result in smoother edges, but it will also increase the cost to render those edges. The
+/// range should generally be somewhere between 1 (no multi sampling, but cheap) to 8 (crisp but
+/// expensive).
+/// Note that WGPU currently only supports 1 or 4 samples.
+/// Ultimately we plan on supporting whatever is natively supported on a given device.
+/// Check out this issue for more info: https://github.com/gfx-rs/wgpu/issues/1832
+fn main() {
+    println!("Press 'm' to toggle MSAA");
+    println!("Using 4x MSAA");
+    App::new()
+        .insert_resource(Msaa { samples: 4 })
+        .add_plugins(PipelinedDefaultPlugins)
+        .add_startup_system(setup)
+        .add_system(cycle_msaa)
+        .run();
+}
+
+/// set up a simple 3D scene
+fn setup(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) {
+    // cube
+    commands.spawn_bundle(PbrBundle {
+        mesh: meshes.add(Mesh::from(shape::Cube { size: 2.0 })),
+        material: materials.add(Color::rgb(0.8, 0.7, 0.6).into()),
+        ..Default::default()
+    });
+    // light
+    commands.spawn_bundle(PointLightBundle {
+        transform: Transform::from_xyz(4.0, 8.0, 4.0),
+        ..Default::default()
+    });
+    // camera
+    commands.spawn_bundle(PerspectiveCameraBundle {
+        transform: Transform::from_xyz(-3.0, 3.0, 5.0).looking_at(Vec3::ZERO, Vec3::Y),
+        ..Default::default()
+    });
+}
+
+fn cycle_msaa(input: Res<Input<KeyCode>>, mut msaa: ResMut<Msaa>) {
+    if input.just_pressed(KeyCode::M) {
+        if msaa.samples == 4 {
+            println!("Not using MSAA");
+            msaa.samples = 1;
+        } else {
+            println!("Using 4x MSAA");
+            msaa.samples = 4;
+        }
+    }
+}
diff --git a/examples/3d/orthographic_pipelined.rs b/examples/3d/orthographic_pipelined.rs
new file mode 100644
index 0000000000..31f80170bb
--- /dev/null
+++ b/examples/3d/orthographic_pipelined.rs
@@ -0,0 +1,71 @@
+use bevy::{
+    ecs::prelude::*,
+    math::Vec3,
+    pbr2::{PbrBundle, PointLightBundle, StandardMaterial},
+    prelude::{App, Assets, Transform},
+    render2::{
+        camera::OrthographicCameraBundle,
+        color::Color,
+        mesh::{shape, Mesh},
+    },
+    PipelinedDefaultPlugins,
+};
+
+fn main() {
+    App::new()
+        .add_plugins(PipelinedDefaultPlugins)
+        .add_startup_system(setup.system())
+        .run();
+}
+
+/// set up a simple 3D scene
+fn setup(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) {
+    // set up the camera
+    let mut camera = OrthographicCameraBundle::new_3d();
+    camera.orthographic_projection.scale = 3.0;
+    camera.transform = Transform::from_xyz(5.0, 5.0, 5.0).looking_at(Vec3::ZERO, Vec3::Y);
+
+    // camera
+    commands.spawn_bundle(camera);
+
+    // plane
+    commands.spawn_bundle(PbrBundle {
+        mesh: meshes.add(Mesh::from(shape::Plane { size: 5.0 })),
+        material: materials.add(Color::rgb(0.3, 0.5, 0.3).into()),
+        ..Default::default()
+    });
+    // cubes
+    commands.spawn_bundle(PbrBundle {
+        mesh: meshes.add(Mesh::from(shape::Cube { size: 1.0 })),
+        material: materials.add(Color::rgb(0.8, 0.7, 0.6).into()),
+        transform: Transform::from_xyz(1.5, 0.5, 1.5),
+        ..Default::default()
+    });
+    commands.spawn_bundle(PbrBundle {
+        mesh: meshes.add(Mesh::from(shape::Cube { size: 1.0 })),
+        material: materials.add(Color::rgb(0.8, 0.7, 0.6).into()),
+        transform: Transform::from_xyz(1.5, 0.5, -1.5),
+        ..Default::default()
+    });
+    commands.spawn_bundle(PbrBundle {
+        mesh: meshes.add(Mesh::from(shape::Cube { size: 1.0 })),
+        material: materials.add(Color::rgb(0.8, 0.7, 0.6).into()),
+        transform: Transform::from_xyz(-1.5, 0.5, 1.5),
+        ..Default::default()
+    });
+    commands.spawn_bundle(PbrBundle {
+        mesh: meshes.add(Mesh::from(shape::Cube { size: 1.0 })),
+        material: materials.add(Color::rgb(0.8, 0.7, 0.6).into()),
+        transform: Transform::from_xyz(-1.5, 0.5, -1.5),
+        ..Default::default()
+    });
+    // light
+    commands.spawn_bundle(PointLightBundle {
+        transform: Transform::from_xyz(3.0, 8.0, 5.0),
+        ..Default::default()
+    });
+}
diff --git a/examples/3d/pbr_pipelined.rs b/examples/3d/pbr_pipelined.rs
new file mode 100644
index 0000000000..470326cab3
--- /dev/null
+++ b/examples/3d/pbr_pipelined.rs
@@ -0,0 +1,86 @@
+use bevy::{
+    ecs::prelude::*,
+    math::Vec3,
+    pbr2::{PbrBundle, PointLight, PointLightBundle, StandardMaterial},
+    prelude::{App, Assets, Transform},
+    render2::{
+        camera::{OrthographicCameraBundle, OrthographicProjection},
+        color::Color,
+        mesh::{shape, Mesh},
+    },
+    PipelinedDefaultPlugins,
+};
+
+/// This example shows how to configure Physically Based Rendering (PBR) parameters.
+fn main() {
+    App::new()
+        .add_plugins(PipelinedDefaultPlugins)
+        .add_startup_system(setup.system())
+        .run();
+}
+
+/// set up a simple 3D scene
+fn setup(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) {
+    // add entities to the world
+    for y in -2..=2 {
+        for x in -5..=5 {
+            let x01 = (x + 5) as f32 / 10.0;
+            let y01 = (y + 2) as f32 / 4.0;
+            // sphere
+            commands.spawn_bundle(PbrBundle {
+                mesh: meshes.add(Mesh::from(shape::Icosphere {
+                    radius: 0.45,
+                    subdivisions: 32,
+                })),
+                material: materials.add(StandardMaterial {
+                    base_color: Color::hex("ffd891").unwrap(),
+                    // vary key PBR parameters on a grid of spheres to show the effect
+                    metallic: y01,
+                    perceptual_roughness: x01,
+                    ..Default::default()
+                }),
+                transform: Transform::from_xyz(x as f32, y as f32 + 0.5, 0.0),
+                ..Default::default()
+            });
+        }
+    }
+    // unlit sphere
+    commands.spawn_bundle(PbrBundle {
+        mesh: meshes.add(Mesh::from(shape::Icosphere {
+            radius: 0.45,
+            subdivisions: 32,
+        })),
+        material: materials.add(StandardMaterial {
+            base_color: Color::hex("ffd891").unwrap(),
+            // vary key PBR parameters on a grid of spheres to show the effect
+            unlit: true,
+            ..Default::default()
+        }),
+        transform: Transform::from_xyz(-5.0, -2.5, 0.0),
+        ..Default::default()
+    });
+    // light
+    commands.spawn_bundle(PointLightBundle {
+        transform: Transform::from_translation(Vec3::new(50.0, 50.0, 50.0)),
+        point_light: PointLight {
+            intensity: 50000.,
+            range: 100.,
+            ..Default::default()
+        },
+        ..Default::default()
+    });
+    // camera
+    commands.spawn_bundle(OrthographicCameraBundle {
+        transform: Transform::from_translation(Vec3::new(0.0, 0.0, 8.0))
+            .looking_at(Vec3::default(), Vec3::Y),
+        orthographic_projection: OrthographicProjection {
+            scale: 0.01,
+            ..Default::default()
+        },
+        ..OrthographicCameraBundle::new_3d()
+    });
+}
diff --git a/examples/3d/render_to_texture.rs b/examples/3d/render_to_texture.rs
index ef847f9955..494d8a0f9c 100644
--- a/examples/3d/render_to_texture.rs
+++ b/examples/3d/render_to_texture.rs
@@ -13,7 +13,7 @@ use bevy::{
         },
         texture::{
             Extent3d, SamplerDescriptor, TextureDescriptor, TextureDimension, TextureFormat,
-            TextureUsage,
+            TextureUsages,
         },
     },
     window::WindowId,
@@ -66,7 +66,7 @@ fn add_render_to_texture_graph(graph: &mut RenderGraph, size: Extent3d) {
                 sample_count: 1,
                 dimension: TextureDimension::D2,
                 format: Default::default(),
-                usage: TextureUsage::OUTPUT_ATTACHMENT | TextureUsage::SAMPLED,
+                usage: TextureUsages::OUTPUT_ATTACHMENT | TextureUsages::SAMPLED,
             },
             Some(SamplerDescriptor::default()),
             Some(RENDER_TEXTURE_HANDLE),
@@ -82,7 +82,7 @@ fn add_render_to_texture_graph(graph: &mut RenderGraph, size: Extent3d) {
                 sample_count: 1,
                 dimension: TextureDimension::D2,
                 format: TextureFormat::Depth32Float,
-                usage: TextureUsage::OUTPUT_ATTACHMENT | TextureUsage::SAMPLED,
+                usage: TextureUsages::OUTPUT_ATTACHMENT | TextureUsages::SAMPLED,
             },
             None,
             None,
diff --git a/examples/3d/shadow_biases_pipelined.rs b/examples/3d/shadow_biases_pipelined.rs
new file mode 100644
index 0000000000..4126f83b61
--- /dev/null
+++ b/examples/3d/shadow_biases_pipelined.rs
@@ -0,0 +1,335 @@
+use bevy::{
+    core::Time,
+    ecs::prelude::*,
+    input::{mouse::MouseMotion, Input},
+    math::{EulerRot, Mat4, Quat, Vec2, Vec3},
+    pbr2::{
+        DirectionalLight, DirectionalLightBundle, PbrBundle, PointLight, PointLightBundle,
+        StandardMaterial,
+    },
+    prelude::{App, Assets, KeyCode, Transform},
+    render2::{
+        camera::{Camera, OrthographicProjection, PerspectiveCameraBundle},
+        color::Color,
+        mesh::{shape, Mesh},
+    },
+    PipelinedDefaultPlugins,
+};
+
+fn main() {
+    println!(
+        "Controls:
+    WSAD   - forward/back/strafe left/right
+    LShift - 'run'
+    E      - up
+    Q      - down
+    L      - switch between directional and point lights
+    1/2    - decrease/increase point light depth bias
+    3/4    - decrease/increase point light normal bias
+    5/6    - decrease/increase direction light depth bias
+    7/8    - decrease/increase direction light normal bias"
+    );
+    App::new()
+        .add_plugins(PipelinedDefaultPlugins)
+        .add_startup_system(setup)
+        .add_system(adjust_point_light_biases)
+        .add_system(toggle_light)
+        .add_system(adjust_directional_light_biases)
+        .add_system(camera_controller)
+        .run();
+}
+
+/// set up a 3D scene to test shadow biases and perspective projections
+fn setup(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) {
+    let spawn_plane_depth = 500.0f32;
+    let spawn_height = 2.0;
+    let sphere_radius = 0.25;
+
+    let white_handle = materials.add(StandardMaterial {
+        base_color: Color::WHITE,
+        perceptual_roughness: 1.0,
+        ..Default::default()
+    });
+    let sphere_handle = meshes.add(Mesh::from(shape::Icosphere {
+        radius: sphere_radius,
+        ..Default::default()
+    }));
+
+    println!("Using DirectionalLight");
+
+    commands.spawn_bundle(PointLightBundle {
+        transform: Transform::from_xyz(5.0, 5.0, 0.0),
+        point_light: PointLight {
+            intensity: 0.0,
+            range: spawn_plane_depth,
+            color: Color::WHITE,
+            shadow_depth_bias: 0.0,
+            shadow_normal_bias: 0.0,
+            ..Default::default()
+        },
+        ..Default::default()
+    });
+
+    let theta = std::f32::consts::FRAC_PI_4;
+    let light_transform = Mat4::from_euler(EulerRot::ZYX, 0.0, std::f32::consts::FRAC_PI_2, -theta);
+    commands.spawn_bundle(DirectionalLightBundle {
+        directional_light: DirectionalLight {
+            illuminance: 100000.0,
+            shadow_projection: OrthographicProjection {
+                left: -0.35,
+                right: 500.35,
+                bottom: -0.1,
+                top: 5.0,
+                near: -5.0,
+                far: 5.0,
+                ..Default::default()
+            },
+            shadow_depth_bias: 0.0,
+            shadow_normal_bias: 0.0,
+            ..Default::default()
+        },
+        transform: Transform::from_matrix(light_transform),
+        ..Default::default()
+    });
+
+    // camera
+    commands
+        .spawn_bundle(PerspectiveCameraBundle {
+            transform: Transform::from_xyz(-1.0, 1.0, 1.0)
+                .looking_at(Vec3::new(-1.0, 1.0, 0.0), Vec3::Y),
+            ..Default::default()
+        })
+        .insert(CameraController::default());
+
+    for z_i32 in -spawn_plane_depth as i32..=0 {
+        commands.spawn_bundle(PbrBundle {
+            mesh: sphere_handle.clone(),
+            material: white_handle.clone(),
+            transform: Transform::from_xyz(0.0, spawn_height, z_i32 as f32),
+            ..Default::default()
+        });
+    }
+
+    // ground plane
+    commands.spawn_bundle(PbrBundle {
+        mesh: meshes.add(Mesh::from(shape::Plane {
+            size: 2.0 * spawn_plane_depth,
+        })),
+        material: white_handle,
+        ..Default::default()
+    });
+}
+
+fn toggle_light(
+    input: Res<Input<KeyCode>>,
+    mut point_lights: Query<&mut PointLight>,
+    mut directional_lights: Query<&mut DirectionalLight>,
+) {
+    if input.just_pressed(KeyCode::L) {
+        for mut light in point_lights.iter_mut() {
+            light.intensity = if light.intensity == 0.0 {
+                println!("Using PointLight");
+                100000000.0
+            } else {
+                0.0
+            };
+        }
+        for mut light in directional_lights.iter_mut() {
+            light.illuminance = if light.illuminance == 0.0 {
+                println!("Using DirectionalLight");
+                100000.0
+            } else {
+                0.0
+            };
+        }
+    }
+}
+
+fn adjust_point_light_biases(input: Res<Input<KeyCode>>, mut query: Query<&mut PointLight>) {
+    let depth_bias_step_size = 0.01;
+    let normal_bias_step_size = 0.1;
+    for mut light in query.iter_mut() {
+        if input.just_pressed(KeyCode::Key1) {
+            light.shadow_depth_bias -= depth_bias_step_size;
+            println!("PointLight shadow_depth_bias: {}", light.shadow_depth_bias);
+        }
+        if input.just_pressed(KeyCode::Key2) {
+            light.shadow_depth_bias += depth_bias_step_size;
+            println!("PointLight shadow_depth_bias: {}", light.shadow_depth_bias);
+        }
+        if input.just_pressed(KeyCode::Key3) {
+            light.shadow_normal_bias -= normal_bias_step_size;
+            println!(
+                "PointLight shadow_normal_bias: {}",
+                light.shadow_normal_bias
+            );
+        }
+        if input.just_pressed(KeyCode::Key4) {
+            light.shadow_normal_bias += normal_bias_step_size;
+            println!(
+                "PointLight shadow_normal_bias: {}",
+                light.shadow_normal_bias
+            );
+        }
+    }
+}
+
+fn adjust_directional_light_biases(
+    input: Res<Input<KeyCode>>,
+    mut query: Query<&mut DirectionalLight>,
+) {
+    let depth_bias_step_size = 0.01;
+    let normal_bias_step_size = 0.1;
+    for mut light in query.iter_mut() {
+        if input.just_pressed(KeyCode::Key5) {
+            light.shadow_depth_bias -= depth_bias_step_size;
+            println!(
+                "DirectionalLight shadow_depth_bias: {}",
+                light.shadow_depth_bias
+            );
+        }
+        if input.just_pressed(KeyCode::Key6) {
+            light.shadow_depth_bias += depth_bias_step_size;
+            println!(
+                "DirectionalLight shadow_depth_bias: {}",
+                light.shadow_depth_bias
+            );
+        }
+        if input.just_pressed(KeyCode::Key7) {
+            light.shadow_normal_bias -= normal_bias_step_size;
+            println!(
+                "DirectionalLight shadow_normal_bias: {}",
+                light.shadow_normal_bias
+            );
+        }
+        if input.just_pressed(KeyCode::Key8) {
+            light.shadow_normal_bias += normal_bias_step_size;
+            println!(
+                "DirectionalLight shadow_normal_bias: {}",
+                light.shadow_normal_bias
+            );
+        }
+    }
+}
+
+#[derive(Component)]
+struct CameraController {
+    pub enabled: bool,
+    pub sensitivity: f32,
+    pub key_forward: KeyCode,
+    pub key_back: KeyCode,
+    pub key_left: KeyCode,
+    pub key_right: KeyCode,
+    pub key_up: KeyCode,
+    pub key_down: KeyCode,
+    pub key_run: KeyCode,
+    pub walk_speed: f32,
+    pub run_speed: f32,
+    pub friction: f32,
+    pub pitch: f32,
+    pub yaw: f32,
+    pub velocity: Vec3,
+}
+
+impl Default for CameraController {
+    fn default() -> Self {
+        Self {
+            enabled: true,
+            sensitivity: 0.5,
+            key_forward: KeyCode::W,
+            key_back: KeyCode::S,
+            key_left: KeyCode::A,
+            key_right: KeyCode::D,
+            key_up: KeyCode::E,
+            key_down: KeyCode::Q,
+            key_run: KeyCode::LShift,
+            walk_speed: 10.0,
+            run_speed: 30.0,
+            friction: 0.5,
+            pitch: 0.0,
+            yaw: 0.0,
+            velocity: Vec3::ZERO,
+        }
+    }
+}
+
+fn camera_controller(
+    time: Res<Time>,
+    mut mouse_events: EventReader<MouseMotion>,
+    key_input: Res<Input<KeyCode>>,
+    mut query: Query<(&mut Transform, &mut CameraController), With<Camera>>,
+) {
+    let dt = time.delta_seconds();
+
+    // Handle mouse input
+    let mut mouse_delta = Vec2::ZERO;
+    for mouse_event in mouse_events.iter() {
+        mouse_delta += mouse_event.delta;
+    }
+
+    for (mut transform, mut options) in query.iter_mut() {
+        if !options.enabled {
+            continue;
+        }
+
+        // Handle key input
+        let mut axis_input = Vec3::ZERO;
+        if key_input.pressed(options.key_forward) {
+            axis_input.z += 1.0;
+        }
+        if key_input.pressed(options.key_back) {
+            axis_input.z -= 1.0;
+        }
+        if key_input.pressed(options.key_right) {
+            axis_input.x += 1.0;
+        }
+        if key_input.pressed(options.key_left) {
+            axis_input.x -= 1.0;
+        }
+        if key_input.pressed(options.key_up) {
+            axis_input.y += 1.0;
+        }
+        if key_input.pressed(options.key_down) {
+            axis_input.y -= 1.0;
+        }
+
+        // Apply movement update
+        if axis_input != Vec3::ZERO {
+            let max_speed = if key_input.pressed(options.key_run) {
+                options.run_speed
+            } else {
+                options.walk_speed
+            };
+            options.velocity = axis_input.normalize() * max_speed;
+        } else {
+            let friction = options.friction.clamp(0.0, 1.0);
+            options.velocity *= 1.0 - friction;
+            if options.velocity.length_squared() < 1e-6 {
+                options.velocity = Vec3::ZERO;
+            }
+        }
+        let forward = transform.forward();
+        let right = transform.right();
+        transform.translation += options.velocity.x * dt * right
+            + options.velocity.y * dt * Vec3::Y
+            + options.velocity.z * dt * forward;
+
+        if mouse_delta != Vec2::ZERO {
+            // Apply look update
+            let (pitch, yaw) = (
+                (options.pitch - mouse_delta.y * 0.5 * options.sensitivity * dt).clamp(
+                    -0.99 * std::f32::consts::FRAC_PI_2,
+                    0.99 * std::f32::consts::FRAC_PI_2,
+                ),
+                options.yaw - mouse_delta.x * options.sensitivity * dt,
+            );
+            transform.rotation = Quat::from_euler(EulerRot::ZYX, 0.0, yaw, pitch);
+            options.pitch = pitch;
+            options.yaw = yaw;
+        }
+    }
+}
diff --git a/examples/3d/shadow_caster_receiver_pipelined.rs b/examples/3d/shadow_caster_receiver_pipelined.rs
new file mode 100644
index 0000000000..3c4b25c536
--- /dev/null
+++ b/examples/3d/shadow_caster_receiver_pipelined.rs
@@ -0,0 +1,182 @@
+use bevy::{
+    ecs::prelude::*,
+    input::Input,
+    math::{EulerRot, Mat4, Vec3},
+    pbr2::{
+        DirectionalLight, DirectionalLightBundle, NotShadowCaster, NotShadowReceiver, PbrBundle,
+        PointLight, PointLightBundle, StandardMaterial,
+    },
+    prelude::{App, Assets, Handle, KeyCode, Transform},
+    render2::{
+        camera::{OrthographicProjection, PerspectiveCameraBundle},
+        color::Color,
+        mesh::{shape, Mesh},
+    },
+    PipelinedDefaultPlugins,
+};
+
+fn main() {
+    println!(
+        "Controls:
+    C      - toggle shadow casters (i.e. casters become not, and not casters become casters)
+    R      - toggle shadow receivers (i.e. receivers become not, and not receivers become receivers)
+    L      - switch between directional and point lights"
+    );
+    App::new()
+        .add_plugins(PipelinedDefaultPlugins)
+        .add_startup_system(setup)
+        .add_system(toggle_light)
+        .add_system(toggle_shadows)
+        .run();
+}
+
+/// set up a 3D scene to test shadow biases and perspective projections
+fn setup(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) {
+    let spawn_plane_depth = 500.0f32;
+    let spawn_height = 2.0;
+    let sphere_radius = 0.25;
+
+    let white_handle = materials.add(StandardMaterial {
+        base_color: Color::WHITE,
+        perceptual_roughness: 1.0,
+        ..Default::default()
+    });
+    let sphere_handle = meshes.add(Mesh::from(shape::Icosphere {
+        radius: sphere_radius,
+        ..Default::default()
+    }));
+
+    // sphere - initially a caster
+    commands.spawn_bundle(PbrBundle {
+        mesh: sphere_handle.clone(),
+        material: materials.add(Color::RED.into()),
+        transform: Transform::from_xyz(-1.0, spawn_height, 0.0),
+        ..Default::default()
+    });
+
+    // sphere - initially not a caster
+    commands
+        .spawn_bundle(PbrBundle {
+            mesh: sphere_handle,
+            material: materials.add(Color::BLUE.into()),
+            transform: Transform::from_xyz(1.0, spawn_height, 0.0),
+            ..Default::default()
+        })
+        .insert(NotShadowCaster);
+
+    // floating plane - initially not a shadow receiver and not a caster
+    commands
+        .spawn_bundle(PbrBundle {
+            mesh: meshes.add(Mesh::from(shape::Plane { size: 20.0 })),
+            material: materials.add(Color::GREEN.into()),
+            transform: Transform::from_xyz(0.0, 1.0, -10.0),
+            ..Default::default()
+        })
+        .insert_bundle((NotShadowCaster, NotShadowReceiver));
+
+    // lower ground plane - initially a shadow receiver
+    commands.spawn_bundle(PbrBundle {
+        mesh: meshes.add(Mesh::from(shape::Plane { size: 20.0 })),
+        material: white_handle,
+        ..Default::default()
+    });
+
+    println!("Using DirectionalLight");
+
+    commands.spawn_bundle(PointLightBundle {
+        transform: Transform::from_xyz(5.0, 5.0, 0.0),
+        point_light: PointLight {
+            intensity: 0.0,
+            range: spawn_plane_depth,
+            color: Color::WHITE,
+            ..Default::default()
+        },
+        ..Default::default()
+    });
+
+    let theta = std::f32::consts::FRAC_PI_4;
+    let light_transform = Mat4::from_euler(EulerRot::ZYX, 0.0, std::f32::consts::FRAC_PI_2, -theta);
+    commands.spawn_bundle(DirectionalLightBundle {
+        directional_light: DirectionalLight {
+            illuminance: 100000.0,
+            shadow_projection: OrthographicProjection {
+                left: -10.0,
+                right: 10.0,
+                bottom: -10.0,
+                top: 10.0,
+                near: -50.0,
+                far: 50.0,
+                ..Default::default()
+            },
+            ..Default::default()
+        },
+        transform: Transform::from_matrix(light_transform),
+        ..Default::default()
+    });
+
+    // camera
+    commands.spawn_bundle(PerspectiveCameraBundle {
+        transform: Transform::from_xyz(-5.0, 5.0, 5.0)
+            .looking_at(Vec3::new(-1.0, 1.0, 0.0), Vec3::Y),
+        ..Default::default()
+    });
+}
+
+fn toggle_light(
+    input: Res<Input<KeyCode>>,
+    mut point_lights: Query<&mut PointLight>,
+    mut directional_lights: Query<&mut DirectionalLight>,
+) {
+    if input.just_pressed(KeyCode::L) {
+        for mut light in point_lights.iter_mut() {
+            light.intensity = if light.intensity == 0.0 {
+                println!("Using PointLight");
+                100000000.0
+            } else {
+                0.0
+            };
+        }
+        for mut light in directional_lights.iter_mut() {
+            light.illuminance = if light.illuminance == 0.0 {
+                println!("Using DirectionalLight");
+                100000.0
+            } else {
+                0.0
+            };
+        }
+    }
+}
+
+fn toggle_shadows(
+    mut commands: Commands,
+    input: Res<Input<KeyCode>>,
+    mut queries: QuerySet<(
+        QueryState<Entity, (With<Handle<Mesh>>, With<NotShadowCaster>)>,
+        QueryState<Entity, (With<Handle<Mesh>>, With<NotShadowReceiver>)>,
+        QueryState<Entity, (With<Handle<Mesh>>, Without<NotShadowCaster>)>,
+        QueryState<Entity, (With<Handle<Mesh>>, Without<NotShadowReceiver>)>,
+    )>,
+) {
+    if input.just_pressed(KeyCode::C) {
+        println!("Toggling casters");
+        for entity in queries.q0().iter() {
+            commands.entity(entity).remove::<NotShadowCaster>();
+        }
+        for entity in queries.q2().iter() {
+            commands.entity(entity).insert(NotShadowCaster);
+        }
+    }
+    if input.just_pressed(KeyCode::R) {
+        println!("Toggling receivers");
+        for entity in queries.q1().iter() {
+            commands.entity(entity).remove::<NotShadowReceiver>();
+        }
+        for entity in queries.q3().iter() {
+            commands.entity(entity).insert(NotShadowReceiver);
+        }
+    }
+}
diff --git a/examples/3d/texture_pipelined.rs b/examples/3d/texture_pipelined.rs
new file mode 100644
index 0000000000..f37fa182c7
--- /dev/null
+++ b/examples/3d/texture_pipelined.rs
@@ -0,0 +1,101 @@
+use bevy::{
+    ecs::prelude::*,
+    math::{Quat, Vec2, Vec3},
+    pbr2::{PbrBundle, StandardMaterial},
+    prelude::{App, AssetServer, Assets, Transform},
+    render2::{
+        camera::PerspectiveCameraBundle,
+        color::Color,
+        mesh::{shape, Mesh},
+    },
+    PipelinedDefaultPlugins,
+};
+
+/// This example shows various ways to configure texture materials in 3D
+fn main() {
+    App::new()
+        .add_plugins(PipelinedDefaultPlugins)
+        .add_startup_system(setup)
+        .run();
+}
+
+/// sets up a scene with textured entities
+fn setup(
+    mut commands: Commands,
+    asset_server: Res<AssetServer>,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) {
+    // load a texture and retrieve its aspect ratio
+    let texture_handle = asset_server.load("branding/bevy_logo_dark_big.png");
+    let aspect = 0.25;
+
+    // create a new quad mesh. this is what we will apply the texture to
+    let quad_width = 8.0;
+    let quad_handle = meshes.add(Mesh::from(shape::Quad::new(Vec2::new(
+        quad_width,
+        quad_width * aspect,
+    ))));
+
+    // this material renders the texture normally
+    let material_handle = materials.add(StandardMaterial {
+        base_color_texture: Some(texture_handle.clone()),
+        unlit: true,
+        ..Default::default()
+    });
+
+    // this material modulates the texture to make it red (and slightly transparent)
+    let red_material_handle = materials.add(StandardMaterial {
+        base_color: Color::rgba(1.0, 0.0, 0.0, 0.5),
+        base_color_texture: Some(texture_handle.clone()),
+        unlit: true,
+        ..Default::default()
+    });
+
+    // and lets make this one blue! (and also slightly transparent)
+    let blue_material_handle = materials.add(StandardMaterial {
+        base_color: Color::rgba(0.0, 0.0, 1.0, 0.5),
+        base_color_texture: Some(texture_handle),
+        unlit: true,
+        ..Default::default()
+    });
+
+    // textured quad - normal
+    commands.spawn_bundle(PbrBundle {
+        mesh: quad_handle.clone(),
+        material: material_handle,
+        transform: Transform {
+            translation: Vec3::new(0.0, 0.0, 1.5),
+            rotation: Quat::from_rotation_x(-std::f32::consts::PI / 5.0),
+            ..Default::default()
+        },
+        ..Default::default()
+    });
+    // textured quad - modulated
+    commands.spawn_bundle(PbrBundle {
+        mesh: quad_handle.clone(),
+        material: red_material_handle,
+        transform: Transform {
+            translation: Vec3::new(0.0, 0.0, 0.0),
+            rotation: Quat::from_rotation_x(-std::f32::consts::PI / 5.0),
+            ..Default::default()
+        },
+        ..Default::default()
+    });
+    // textured quad - modulated
+    commands.spawn_bundle(PbrBundle {
+        mesh: quad_handle,
+        material: blue_material_handle,
+        transform: Transform {
+            translation: Vec3::new(0.0, 0.0, -1.5),
+            rotation: Quat::from_rotation_x(-std::f32::consts::PI / 5.0),
+            ..Default::default()
+        },
+        ..Default::default()
+    });
+    // camera
+    commands.spawn_bundle(PerspectiveCameraBundle {
+        transform: Transform::from_xyz(3.0, 5.0, 8.0).looking_at(Vec3::ZERO, Vec3::Y),
+        ..Default::default()
+    });
+}
diff --git a/examples/3d/wireframe.rs b/examples/3d/wireframe.rs
index c07483cfb2..4cc291ac18 100644
--- a/examples/3d/wireframe.rs
+++ b/examples/3d/wireframe.rs
@@ -10,7 +10,7 @@ fn main() {
         .insert_resource(WgpuOptions {
             features: WgpuFeatures {
                 // The Wireframe requires NonFillPolygonMode feature
-                features: vec![WgpuFeature::NonFillPolygonMode],
+                features: vec![WgpuFeature::PolygonModeLine],
             },
             ..Default::default()
         })
diff --git a/examples/README.md b/examples/README.md
index 7796afdb16..6d8a563bd8 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -85,6 +85,7 @@ Example | File | Description
 `contributors` | [`2d/contributors.rs`](./2d/contributors.rs) | Displays each contributor as a bouncy bevy-ball!
 `many_sprites` | [`2d/many_sprites.rs`](./2d/many_sprites.rs) | Displays many sprites in a grid arragement! Used for performance testing.
 `mesh` | [`2d/mesh.rs`](./2d/mesh.rs) | Renders a custom mesh
+`pipelined_texture_atlas` | [`2d/pipelined_texture_atlas.rs`](./2d/pipelined_texture_atlas.rs) | Generates a texture atlas (sprite sheet) from individual sprites
 `sprite` | [`2d/sprite.rs`](./2d/sprite.rs) | Renders a sprite
 `sprite_sheet` | [`2d/sprite_sheet.rs`](./2d/sprite_sheet.rs) | Renders an animated sprite
 `text2d` | [`2d/text2d.rs`](./2d/text2d.rs) | Generates text in 2d
@@ -96,14 +97,24 @@ Example | File | Description
 Example | File | Description
 --- | --- | ---
 `3d_scene` | [`3d/3d_scene.rs`](./3d/3d_scene.rs) | Simple 3D scene with basic shapes and lighting
+`3d_scene_pipelined` | [`3d/3d_scene_pipelined.rs`](./3d/3d_scene_pipelined.rs) | Simple 3D scene with basic shapes and lighting
+`cornell_box_pipelined` | [`3d/cornell_box_pipelined.rs`](./3d/cornell_box_pipelined.rs) | Re-production of the cornell box
 `load_gltf` | [`3d/load_gltf.rs`](./3d/load_gltf.rs) | Loads and renders a gltf file as a scene
+`load_gltf_pipelined` | [`3d/load_gltf_pipelined.rs`](./3d/load_gltf_pipelined.rs) | Loads and renders a gltf file as a scene
+`many_cubes_pipelined` | [`3d/many_cubes_pipelined.rs`](./3d/many_cubes_pipelined.rs) | Simple benchmark to test per-entity draw overhead
 `msaa` | [`3d/msaa.rs`](./3d/msaa.rs) | Configures MSAA (Multi-Sample Anti-Aliasing) for smoother edges
+`msaa_pipelined` | [`3d/msaa_pipelined.rs`](./3d/msaa_pipelined.rs) | Configures MSAA (Multi-Sample Anti-Aliasing) for smoother edges
 `orthographic` | [`3d/orthographic.rs`](./3d/orthographic.rs) | Shows how to create a 3D orthographic view (for isometric-look games or CAD applications)
+`orthographic_pipelined` | [`3d/orthographic_pipelined.rs`](./3d/orthographic_pipelined.rs) | Shows how to create a 3D orthographic view (for isometric-look games or CAD applications)
 `parenting` | [`3d/parenting.rs`](./3d/parenting.rs) | Demonstrates parent->child relationships and relative transformations
 `pbr` | [`3d/pbr.rs`](./3d/pbr.rs) | Demonstrates use of Physically Based Rendering (PBR) properties
+`pbr_pipelined` | [`3d/pbr_pipelined.rs`](./3d/pbr_pipelined.rs) | Demonstrates use of Physically Based Rendering (PBR) properties
 `render_to_texture` | [`3d/render_to_texture.rs`](./3d/render_to_texture.rs) | Shows how to render to texture
+`shadow_caster_receiver_pipelined` | [`3d/shadow_caster_receiver_pipelined.rs`](./3d/shadow_caster_receiver_pipelined.rs) | Demonstrates how to prevent meshes from casting/receiving shadows in a 3d scene
+`shadow_biases_pipelined` | [`3d/shadow_biases_pipelined.rs`](./3d/shadow_biases_pipelined.rs) | Demonstrates how shadow biases affect shadows in a 3d scene
 `spawner` | [`3d/spawner.rs`](./3d/spawner.rs) | Renders a large number of cubes with changing position and material
 `texture` | [`3d/texture.rs`](./3d/texture.rs) | Shows configuration of texture materials
+`texture_pipelined` | [`3d/texture_pipelined.rs`](./3d/texture_pipelined.rs) | Shows configuration of texture materials
 `update_gltf_scene` | [`3d/update_gltf_scene.rs`](./3d/update_gltf_scene.rs) | Update a scene from a gltf file, either by spawning the scene as a child of another entity, or by accessing the entities of the scene
 `wireframe` | [`3d/wireframe.rs`](./3d/wireframe.rs) | Showcases wireframe rendering
 `z_sort_debug` | [`3d/z_sort_debug.rs`](./3d/z_sort_debug.rs) | Visualizes camera Z-ordering
@@ -213,10 +224,12 @@ Example | File | Description
 --- | --- | ---
 `animate_shader` | [`shader/animate_shader.rs`](./shader/animate_shader.rs) | Shows how to animate a shader by accessing a time uniform variable
 `array_texture` | [`shader/array_texture.rs`](./shader/array_texture.rs) | Illustrates how to create a texture for use with a texture2DArray shader uniform variable
+`custom_shader_pipelined` | [`shader/custom_shader_pipelined.rs`](./shader/custom_shader_pipelined.rs) | Illustrates how to create custom shaders
 `hot_shader_reloading` | [`shader/hot_shader_reloading.rs`](./shader/hot_shader_reloading.rs) | Illustrates how to load shaders such that they can be edited while the example is still running
 `mesh_custom_attribute` | [`shader/mesh_custom_attribute.rs`](./shader/mesh_custom_attribute.rs) | Illustrates how to add a custom attribute to a mesh and use it in a custom shader
 `shader_custom_material` | [`shader/shader_custom_material.rs`](./shader/shader_custom_material.rs) | Illustrates creating a custom material and a shader that uses it
 `shader_defs` | [`shader/shader_defs.rs`](./shader/shader_defs.rs) | Demonstrates creating a custom material that uses "shaders defs" (a tool to selectively toggle parts of a shader)
+`shader_defs_pipelined` | [`shader/shader_defs_pipelined.rs`](./shader/shader_defs_pipelined.rs) | Demonstrates creating a custom material that uses "shaders defs" (a tool to selectively toggle parts of a shader)
 
 ## Tests
 
@@ -229,6 +242,7 @@ Example | File | Description
 Example | File | Description
 --- | --- | ---
 `bevymark` | [`tools/bevymark.rs`](./tools/bevymark.rs) | A heavy workload to benchmark your system with Bevy
+`bevymark_pipelined` | [`tools/bevymark_pipelined.rs`](./tools/bevymark_pipelined.rs) | A heavy workload to benchmark your system with Bevy
 
 ## UI (User Interface)
 
@@ -245,6 +259,7 @@ Example | File | Description
 Example | File | Description
 --- | --- | ---
 `clear_color` | [`window/clear_color.rs`](./window/clear_color.rs) | Creates a solid color window
+`clear_color_pipelined` | [`window/clear_color_pipelined.rs`](./window/clear_color_pipelined.rs) | Creates a solid color window with the pipelined renderer
 `multiple_windows` | [`window/multiple_windows.rs`](./window/multiple_windows.rs) | Creates two windows and cameras viewing the same mesh
 `scale_factor_override` | [`window/scale_factor_override.rs`](./window/scale_factor_override.rs) | Illustrates how to customize the default window settings
 `window_settings` | [`window/window_settings.rs`](./window/window_settings.rs) | Demonstrates customizing default window settings
diff --git a/examples/shader/custom_shader_pipelined.rs b/examples/shader/custom_shader_pipelined.rs
new file mode 100644
index 0000000000..dab60f7e6d
--- /dev/null
+++ b/examples/shader/custom_shader_pipelined.rs
@@ -0,0 +1,237 @@
+use bevy::{
+    core_pipeline::Transparent3d,
+    diagnostic::{FrameTimeDiagnosticsPlugin, LogDiagnosticsPlugin},
+    ecs::{
+        prelude::*,
+        system::{lifetimeless::*, SystemParamItem},
+    },
+    math::{Vec3, Vec4},
+    pbr2::{
+        DrawMesh, MeshPipeline, MeshPipelineKey, MeshUniform, SetMeshBindGroup,
+        SetMeshViewBindGroup,
+    },
+    prelude::{AddAsset, App, AssetServer, Assets, GlobalTransform, Handle, Plugin, Transform},
+    reflect::TypeUuid,
+    render2::{
+        camera::PerspectiveCameraBundle,
+        color::Color,
+        mesh::{shape, Mesh},
+        render_asset::{PrepareAssetError, RenderAsset, RenderAssetPlugin, RenderAssets},
+        render_component::ExtractComponentPlugin,
+        render_phase::{
+            AddRenderCommand, DrawFunctions, EntityRenderCommand, RenderCommandResult, RenderPhase,
+            SetItemPipeline, TrackedRenderPass,
+        },
+        render_resource::*,
+        renderer::RenderDevice,
+        view::{ComputedVisibility, ExtractedView, Msaa, Visibility},
+        RenderApp, RenderStage,
+    },
+    PipelinedDefaultPlugins,
+};
+use crevice::std140::{AsStd140, Std140};
+
+fn main() {
+    App::new()
+        .add_plugins(PipelinedDefaultPlugins)
+        .add_plugin(FrameTimeDiagnosticsPlugin::default())
+        .add_plugin(LogDiagnosticsPlugin::default())
+        .add_plugin(CustomMaterialPlugin)
+        .add_startup_system(setup)
+        .run();
+}
+
+/// set up a simple 3D scene
+fn setup(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<CustomMaterial>>,
+) {
+    // cube
+    commands.spawn().insert_bundle((
+        meshes.add(Mesh::from(shape::Cube { size: 1.0 })),
+        Transform::from_xyz(0.0, 0.5, 0.0),
+        GlobalTransform::default(),
+        Visibility::default(),
+        ComputedVisibility::default(),
+        materials.add(CustomMaterial {
+            color: Color::GREEN,
+        }),
+    ));
+
+    // camera
+    commands.spawn_bundle(PerspectiveCameraBundle {
+        transform: Transform::from_xyz(-2.0, 2.5, 5.0).looking_at(Vec3::ZERO, Vec3::Y),
+        ..Default::default()
+    });
+}
+
+#[derive(Debug, Clone, TypeUuid)]
+#[uuid = "4ee9c363-1124-4113-890e-199d81b00281"]
+pub struct CustomMaterial {
+    color: Color,
+}
+
+#[derive(Clone)]
+pub struct GpuCustomMaterial {
+    _buffer: Buffer,
+    bind_group: BindGroup,
+}
+
+impl RenderAsset for CustomMaterial {
+    type ExtractedAsset = CustomMaterial;
+    type PreparedAsset = GpuCustomMaterial;
+    type Param = (SRes<RenderDevice>, SRes<CustomPipeline>);
+    fn extract_asset(&self) -> Self::ExtractedAsset {
+        self.clone()
+    }
+
+    fn prepare_asset(
+        extracted_asset: Self::ExtractedAsset,
+        (render_device, custom_pipeline): &mut SystemParamItem<Self::Param>,
+    ) -> Result<Self::PreparedAsset, PrepareAssetError<Self::ExtractedAsset>> {
+        let color: Vec4 = extracted_asset.color.as_rgba_linear().into();
+        let buffer = render_device.create_buffer_with_data(&BufferInitDescriptor {
+            contents: color.as_std140().as_bytes(),
+            label: None,
+            usage: BufferUsages::UNIFORM | BufferUsages::COPY_DST,
+        });
+        let bind_group = render_device.create_bind_group(&BindGroupDescriptor {
+            entries: &[BindGroupEntry {
+                binding: 0,
+                resource: buffer.as_entire_binding(),
+            }],
+            label: None,
+            layout: &custom_pipeline.material_layout,
+        });
+
+        Ok(GpuCustomMaterial {
+            _buffer: buffer,
+            bind_group,
+        })
+    }
+}
+pub struct CustomMaterialPlugin;
+
+impl Plugin for CustomMaterialPlugin {
+    fn build(&self, app: &mut App) {
+        app.add_asset::<CustomMaterial>()
+            .add_plugin(ExtractComponentPlugin::<Handle<CustomMaterial>>::default())
+            .add_plugin(RenderAssetPlugin::<CustomMaterial>::default());
+        app.sub_app(RenderApp)
+            .add_render_command::<Transparent3d, DrawCustom>()
+            .init_resource::<CustomPipeline>()
+            .init_resource::<SpecializedPipelines<CustomPipeline>>()
+            .add_system_to_stage(RenderStage::Queue, queue_custom);
+    }
+}
+
+pub struct CustomPipeline {
+    mesh_pipeline: MeshPipeline,
+    material_layout: BindGroupLayout,
+    shader: Handle<Shader>,
+}
+
+impl SpecializedPipeline for CustomPipeline {
+    type Key = MeshPipelineKey;
+
+    fn specialize(&self, key: Self::Key) -> RenderPipelineDescriptor {
+        let mut descriptor = self.mesh_pipeline.specialize(key);
+        descriptor.fragment.as_mut().unwrap().shader = self.shader.clone();
+        descriptor.layout = Some(vec![
+            self.mesh_pipeline.view_layout.clone(),
+            self.material_layout.clone(),
+            self.mesh_pipeline.mesh_layout.clone(),
+        ]);
+        descriptor
+    }
+}
+
+impl FromWorld for CustomPipeline {
+    fn from_world(world: &mut World) -> Self {
+        let asset_server = world.get_resource::<AssetServer>().unwrap();
+        let render_device = world.get_resource::<RenderDevice>().unwrap();
+        let material_layout = render_device.create_bind_group_layout(&BindGroupLayoutDescriptor {
+            entries: &[BindGroupLayoutEntry {
+                binding: 0,
+                visibility: ShaderStages::FRAGMENT,
+                ty: BindingType::Buffer {
+                    ty: BufferBindingType::Uniform,
+                    has_dynamic_offset: false,
+                    min_binding_size: BufferSize::new(Vec4::std140_size_static() as u64),
+                },
+                count: None,
+            }],
+            label: None,
+        });
+
+        CustomPipeline {
+            mesh_pipeline: world.get_resource::<MeshPipeline>().unwrap().clone(),
+            shader: asset_server.load("shaders/custom_material.wgsl"),
+            material_layout,
+        }
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+pub fn queue_custom(
+    transparent_3d_draw_functions: Res<DrawFunctions<Transparent3d>>,
+    materials: Res<RenderAssets<CustomMaterial>>,
+    custom_pipeline: Res<CustomPipeline>,
+    mut pipeline_cache: ResMut<RenderPipelineCache>,
+    mut specialized_pipelines: ResMut<SpecializedPipelines<CustomPipeline>>,
+    msaa: Res<Msaa>,
+    material_meshes: Query<(Entity, &Handle<CustomMaterial>, &MeshUniform), With<Handle<Mesh>>>,
+    mut views: Query<(&ExtractedView, &mut RenderPhase<Transparent3d>)>,
+) {
+    let draw_custom = transparent_3d_draw_functions
+        .read()
+        .get_id::<DrawCustom>()
+        .unwrap();
+    let key = MeshPipelineKey::from_msaa_samples(msaa.samples);
+    for (view, mut transparent_phase) in views.iter_mut() {
+        let view_matrix = view.transform.compute_matrix();
+        let view_row_2 = view_matrix.row(2);
+        for (entity, material_handle, mesh_uniform) in material_meshes.iter() {
+            if materials.contains_key(material_handle) {
+                transparent_phase.add(Transparent3d {
+                    entity,
+                    pipeline: specialized_pipelines.specialize(
+                        &mut pipeline_cache,
+                        &custom_pipeline,
+                        key,
+                    ),
+                    draw_function: draw_custom,
+                    distance: view_row_2.dot(mesh_uniform.transform.col(3)),
+                });
+            }
+        }
+    }
+}
+
+type DrawCustom = (
+    SetItemPipeline,
+    SetMeshViewBindGroup<0>,
+    SetCustomMaterialBindGroup,
+    SetMeshBindGroup<2>,
+    DrawMesh,
+);
+
+struct SetCustomMaterialBindGroup;
+impl EntityRenderCommand for SetCustomMaterialBindGroup {
+    type Param = (
+        SRes<RenderAssets<CustomMaterial>>,
+        SQuery<Read<Handle<CustomMaterial>>>,
+    );
+    fn render<'w>(
+        _view: Entity,
+        item: Entity,
+        (materials, query): SystemParamItem<'w, '_, Self::Param>,
+        pass: &mut TrackedRenderPass<'w>,
+    ) -> RenderCommandResult {
+        let material_handle = query.get(item).unwrap();
+        let material = materials.into_inner().get(material_handle).unwrap();
+        pass.set_bind_group(1, &material.bind_group, &[]);
+        RenderCommandResult::Success
+    }
+}
diff --git a/examples/shader/shader_defs_pipelined.rs b/examples/shader/shader_defs_pipelined.rs
new file mode 100644
index 0000000000..0856261d60
--- /dev/null
+++ b/examples/shader/shader_defs_pipelined.rs
@@ -0,0 +1,162 @@
+use bevy::{
+    core_pipeline::Transparent3d,
+    diagnostic::{FrameTimeDiagnosticsPlugin, LogDiagnosticsPlugin},
+    ecs::prelude::*,
+    math::Vec3,
+    pbr2::{
+        DrawMesh, MeshPipeline, MeshPipelineKey, MeshUniform, SetMeshBindGroup,
+        SetMeshViewBindGroup,
+    },
+    prelude::{App, AssetServer, Assets, GlobalTransform, Handle, Plugin, Transform},
+    render2::{
+        camera::PerspectiveCameraBundle,
+        mesh::{shape, Mesh},
+        render_component::{ExtractComponent, ExtractComponentPlugin},
+        render_phase::{AddRenderCommand, DrawFunctions, RenderPhase, SetItemPipeline},
+        render_resource::*,
+        view::{ComputedVisibility, ExtractedView, Msaa, Visibility},
+        RenderApp, RenderStage,
+    },
+    PipelinedDefaultPlugins,
+};
+
+pub struct IsRedPlugin;
+
+impl Plugin for IsRedPlugin {
+    fn build(&self, app: &mut App) {
+        app.add_plugin(ExtractComponentPlugin::<IsRed>::default());
+        app.sub_app(RenderApp)
+            .add_render_command::<Transparent3d, DrawIsRed>()
+            .init_resource::<IsRedPipeline>()
+            .init_resource::<SpecializedPipelines<IsRedPipeline>>()
+            .add_system_to_stage(RenderStage::Queue, queue_custom);
+    }
+}
+
+fn main() {
+    App::new()
+        .add_plugins(PipelinedDefaultPlugins)
+        .add_plugin(FrameTimeDiagnosticsPlugin::default())
+        .add_plugin(LogDiagnosticsPlugin::default())
+        .add_plugin(IsRedPlugin)
+        .add_startup_system(setup)
+        .run();
+}
+
+#[derive(Component, Hash, PartialEq, Eq, Copy, Clone)]
+struct IsRed(bool);
+
+impl ExtractComponent for IsRed {
+    type Query = &'static IsRed;
+
+    type Filter = ();
+
+    fn extract_component(item: bevy::ecs::query::QueryItem<Self::Query>) -> Self {
+        *item
+    }
+}
+
+/// set up a simple 3D scene
+fn setup(mut commands: Commands, mut meshes: ResMut<Assets<Mesh>>) {
+    // red cube
+    commands.spawn().insert_bundle((
+        meshes.add(Mesh::from(shape::Cube { size: 1.0 })),
+        IsRed(true),
+        Transform::from_xyz(-1.0, 0.5, 0.0),
+        GlobalTransform::default(),
+        Visibility::default(),
+        ComputedVisibility::default(),
+    ));
+
+    // blue cube
+    commands.spawn().insert_bundle((
+        meshes.add(Mesh::from(shape::Cube { size: 1.0 })),
+        IsRed(false),
+        Transform::from_xyz(1.0, 0.5, 0.0),
+        GlobalTransform::default(),
+        Visibility::default(),
+        ComputedVisibility::default(),
+    ));
+
+    // camera
+    commands.spawn_bundle(PerspectiveCameraBundle {
+        transform: Transform::from_xyz(-2.0, 2.5, 5.0).looking_at(Vec3::ZERO, Vec3::Y),
+        ..Default::default()
+    });
+}
+
+struct IsRedPipeline {
+    mesh_pipline: MeshPipeline,
+    shader: Handle<Shader>,
+}
+
+impl FromWorld for IsRedPipeline {
+    fn from_world(world: &mut World) -> Self {
+        let asset_server = world.get_resource::<AssetServer>().unwrap();
+        let mesh_pipeline = world.get_resource::<MeshPipeline>().unwrap();
+        let shader = asset_server.load("shaders/shader_defs.wgsl");
+        IsRedPipeline {
+            mesh_pipline: mesh_pipeline.clone(),
+            shader,
+        }
+    }
+}
+
+impl SpecializedPipeline for IsRedPipeline {
+    type Key = (IsRed, MeshPipelineKey);
+
+    fn specialize(&self, (is_red, pbr_pipeline_key): Self::Key) -> RenderPipelineDescriptor {
+        let mut shader_defs = Vec::new();
+        if is_red.0 {
+            shader_defs.push("IS_RED".to_string());
+        }
+        let mut descriptor = self.mesh_pipline.specialize(pbr_pipeline_key);
+        descriptor.vertex.shader = self.shader.clone();
+        descriptor.vertex.shader_defs = shader_defs.clone();
+        let fragment = descriptor.fragment.as_mut().unwrap();
+        fragment.shader = self.shader.clone();
+        fragment.shader_defs = shader_defs;
+        descriptor.layout = Some(vec![
+            self.mesh_pipline.view_layout.clone(),
+            self.mesh_pipline.mesh_layout.clone(),
+        ]);
+        descriptor
+    }
+}
+
+type DrawIsRed = (
+    SetItemPipeline,
+    SetMeshViewBindGroup<0>,
+    SetMeshBindGroup<1>,
+    DrawMesh,
+);
+
+fn queue_custom(
+    transparent_3d_draw_functions: Res<DrawFunctions<Transparent3d>>,
+    custom_pipeline: Res<IsRedPipeline>,
+    msaa: Res<Msaa>,
+    mut pipelines: ResMut<SpecializedPipelines<IsRedPipeline>>,
+    mut pipeline_cache: ResMut<RenderPipelineCache>,
+    material_meshes: Query<(Entity, &MeshUniform, &IsRed), With<Handle<Mesh>>>,
+    mut views: Query<(&ExtractedView, &mut RenderPhase<Transparent3d>)>,
+) {
+    let draw_custom = transparent_3d_draw_functions
+        .read()
+        .get_id::<DrawIsRed>()
+        .unwrap();
+    let key = MeshPipelineKey::from_msaa_samples(msaa.samples);
+    for (view, mut transparent_phase) in views.iter_mut() {
+        let view_matrix = view.transform.compute_matrix();
+        let view_row_2 = view_matrix.row(2);
+        for (entity, mesh_uniform, is_red) in material_meshes.iter() {
+            let pipeline =
+                pipelines.specialize(&mut pipeline_cache, &custom_pipeline, (*is_red, key));
+            transparent_phase.add(Transparent3d {
+                entity,
+                pipeline,
+                draw_function: draw_custom,
+                distance: view_row_2.dot(mesh_uniform.transform.col(3)),
+            });
+        }
+    }
+}
diff --git a/examples/tools/bevymark_pipelined.rs b/examples/tools/bevymark_pipelined.rs
new file mode 100644
index 0000000000..8807abe405
--- /dev/null
+++ b/examples/tools/bevymark_pipelined.rs
@@ -0,0 +1,284 @@
+use bevy::{
+    core::{Time, Timer},
+    diagnostic::{Diagnostics, FrameTimeDiagnosticsPlugin, LogDiagnosticsPlugin},
+    ecs::prelude::*,
+    input::Input,
+    math::Vec3,
+    prelude::{info, App, AssetServer, Handle, MouseButton, Transform},
+    render2::{camera::OrthographicCameraBundle, color::Color, texture::Image},
+    sprite2::{PipelinedSpriteBundle, Sprite},
+    window::WindowDescriptor,
+    PipelinedDefaultPlugins,
+};
+use rand::{random, Rng};
+
+const BIRDS_PER_SECOND: u32 = 10000;
+const _BASE_COLOR: Color = Color::rgb(5.0, 5.0, 5.0);
+const GRAVITY: f32 = -9.8 * 100.0;
+const MAX_VELOCITY: f32 = 750.;
+const BIRD_SCALE: f32 = 0.15;
+const HALF_BIRD_SIZE: f32 = 256. * BIRD_SCALE * 0.5;
+
+struct BevyCounter {
+    pub count: u128,
+    pub color: Color,
+}
+
+#[derive(Component)]
+struct Bird {
+    velocity: Vec3,
+}
+
+// struct BirdMaterial(Handle<ColorMaterial>);
+
+// impl FromWorld for BirdMaterial {
+//     fn from_world(world: &mut World) -> Self {
+//         let world = world.cell();
+//         let mut color_materials = world.get_resource_mut::<Assets<ColorMaterial>>().unwrap();
+//         let asset_server = world.get_resource_mut::<AssetServer>().unwrap();
+//         BirdMaterial(color_materials.add(asset_server.load("branding/icon.png").into()))
+//     }
+// }
+
+fn main() {
+    App::new()
+        .insert_resource(WindowDescriptor {
+            title: "BevyMark".to_string(),
+            width: 800.,
+            height: 600.,
+            vsync: false,
+            resizable: true,
+            ..Default::default()
+        })
+        .add_plugins(PipelinedDefaultPlugins)
+        .add_plugin(FrameTimeDiagnosticsPlugin::default())
+        .add_plugin(LogDiagnosticsPlugin::default())
+        // .add_plugin(WgpuResourceDiagnosticsPlugin::default())
+        .insert_resource(BevyCounter {
+            count: 0,
+            color: Color::WHITE,
+        })
+        // .init_resource::<BirdMaterial>()
+        .add_startup_system(setup)
+        .add_system(mouse_handler)
+        .add_system(movement_system)
+        .add_system(collision_system)
+        .add_system(counter_system)
+        .run();
+}
+
+struct BirdTexture(Handle<Image>);
+
+fn setup(
+    mut commands: Commands,
+    window: Res<WindowDescriptor>,
+    mut counter: ResMut<BevyCounter>,
+    asset_server: Res<AssetServer>,
+) {
+    let texture = asset_server.load("branding/icon.png");
+    if let Some(initial_count) = std::env::args()
+        .nth(1)
+        .and_then(|arg| arg.parse::<u128>().ok())
+    {
+        spawn_birds(
+            &mut commands,
+            &window,
+            &mut counter,
+            initial_count,
+            texture.clone_weak(),
+        );
+    }
+    commands.spawn_bundle(OrthographicCameraBundle::new_2d());
+    // commands.spawn_bundle(UiCameraBundle::default());
+    // commands.spawn_bundle(TextBundle {
+    //     text: Text {
+    //         sections: vec![
+    //             TextSection {
+    //                 value: "Bird Count: ".to_string(),
+    //                 style: TextStyle {
+    //                     font: asset_server.load("fonts/FiraSans-Bold.ttf"),
+    //                     font_size: 40.0,
+    //                     color: Color::rgb(0.0, 1.0, 0.0),
+    //                 },
+    //             },
+    //             TextSection {
+    //                 value: "".to_string(),
+    //                 style: TextStyle {
+    //                     font: asset_server.load("fonts/FiraSans-Bold.ttf"),
+    //                     font_size: 40.0,
+    //                     color: Color::rgb(0.0, 1.0, 1.0),
+    //                 },
+    //             },
+    //             TextSection {
+    //                 value: "\nAverage FPS: ".to_string(),
+    //                 style: TextStyle {
+    //                     font: asset_server.load("fonts/FiraSans-Bold.ttf"),
+    //                     font_size: 40.0,
+    //                     color: Color::rgb(0.0, 1.0, 0.0),
+    //                 },
+    //             },
+    //             TextSection {
+    //                 value: "".to_string(),
+    //                 style: TextStyle {
+    //                     font: asset_server.load("fonts/FiraSans-Bold.ttf"),
+    //                     font_size: 40.0,
+    //                     color: Color::rgb(0.0, 1.0, 1.0),
+    //                 },
+    //             },
+    //         ],
+    //         ..Default::default()
+    //     },
+    //     style: Style {
+    //         position_type: PositionType::Absolute,
+    //         position: Rect {
+    //             top: Val::Px(5.0),
+    //             left: Val::Px(5.0),
+    //             ..Default::default()
+    //         },
+    //         ..Default::default()
+    //     },
+    //     ..Default::default()
+    // });
+
+    commands.insert_resource(BirdTexture(texture));
+}
+
+#[allow(clippy::too_many_arguments)]
+fn mouse_handler(
+    mut commands: Commands,
+    _asset_server: Res<AssetServer>,
+    time: Res<Time>,
+    mouse_button_input: Res<Input<MouseButton>>,
+    window: Res<WindowDescriptor>,
+    bird_texture: Res<BirdTexture>,
+    // mut bird_material: ResMut<BirdMaterial>,
+    mut counter: ResMut<BevyCounter>,
+    // mut materials: ResMut<Assets<ColorMaterial>>,
+) {
+    // if mouse_button_input.just_pressed(MouseButton::Left) {
+    //     let mut rnd = rand::thread_rng();
+    //     let color = gen_color(&mut rnd);
+
+    //     let texture_handle = asset_server.load("branding/icon.png");
+
+    //     bird_material.0 = materials.add(ColorMaterial {
+    //         color: BASE_COLOR * color,
+    //         texture: Some(texture_handle),
+    //     });
+    // }
+    if mouse_button_input.just_released(MouseButton::Left) {
+        counter.color = Color::rgb(random(), random(), random());
+    }
+
+    if mouse_button_input.pressed(MouseButton::Left) {
+        let spawn_count = (BIRDS_PER_SECOND as f64 * time.delta_seconds_f64()) as u128;
+        spawn_birds(
+            &mut commands,
+            &window,
+            &mut counter,
+            spawn_count,
+            bird_texture.0.clone(),
+        );
+    }
+}
+
+fn spawn_birds(
+    commands: &mut Commands,
+    window: &WindowDescriptor,
+    counter: &mut BevyCounter,
+    spawn_count: u128,
+    texture: Handle<Image>,
+) {
+    let bird_x = (window.width / -2.) + HALF_BIRD_SIZE;
+    let bird_y = (window.height / 2.) - HALF_BIRD_SIZE;
+    for count in 0..spawn_count {
+        let bird_z = (counter.count + count) as f32 * 0.00001;
+        commands
+            .spawn_bundle(PipelinedSpriteBundle {
+                // material: bird_material.0.clone(),
+                texture: texture.clone(),
+                transform: Transform {
+                    translation: Vec3::new(bird_x, bird_y, bird_z),
+                    scale: Vec3::splat(BIRD_SCALE),
+                    ..Default::default()
+                },
+                sprite: Sprite {
+                    color: counter.color,
+                    ..Default::default()
+                },
+                ..Default::default()
+            })
+            .insert(Bird {
+                velocity: Vec3::new(
+                    rand::random::<f32>() * MAX_VELOCITY - (MAX_VELOCITY * 0.5),
+                    0.,
+                    0.,
+                ),
+            });
+    }
+    counter.count += spawn_count;
+}
+
+fn movement_system(time: Res<Time>, mut bird_query: Query<(&mut Bird, &mut Transform)>) {
+    for (mut bird, mut transform) in bird_query.iter_mut() {
+        transform.translation.x += bird.velocity.x * time.delta_seconds();
+        transform.translation.y += bird.velocity.y * time.delta_seconds();
+        bird.velocity.y += GRAVITY * time.delta_seconds();
+    }
+}
+
+fn collision_system(window: Res<WindowDescriptor>, mut bird_query: Query<(&mut Bird, &Transform)>) {
+    let half_width = window.width as f32 * 0.5;
+    let half_height = window.height as f32 * 0.5;
+
+    for (mut bird, transform) in bird_query.iter_mut() {
+        let x_vel = bird.velocity.x;
+        let y_vel = bird.velocity.y;
+        let x_pos = transform.translation.x;
+        let y_pos = transform.translation.y;
+
+        if (x_vel > 0. && x_pos + HALF_BIRD_SIZE > half_width)
+            || (x_vel <= 0. && x_pos - HALF_BIRD_SIZE < -(half_width))
+        {
+            bird.velocity.x = -x_vel;
+        }
+        if y_vel < 0. && y_pos - HALF_BIRD_SIZE < -half_height {
+            bird.velocity.y = -y_vel;
+        }
+    }
+}
+
+struct CountTimer {
+    timer: Timer,
+}
+
+impl Default for CountTimer {
+    fn default() -> Self {
+        Self {
+            timer: Timer::from_seconds(1.0, true),
+        }
+    }
+}
+
+fn counter_system(
+    mut timer: Local<CountTimer>,
+    _diagnostics: Res<Diagnostics>,
+    time: Res<Time>,
+    counter: Res<BevyCounter>,
+) {
+    if timer.timer.tick(time.delta()).finished() {
+        info!("counter: {}", counter.count);
+    }
+}
+
+/// Generate a color modulation
+///
+/// Because there is no `Mul<Color> for Color` instead `[f32; 3]` is
+/// used.
+fn _gen_color(rng: &mut impl Rng) -> [f32; 3] {
+    let r = rng.gen_range(0.2..1.0);
+    let g = rng.gen_range(0.2..1.0);
+    let b = rng.gen_range(0.2..1.0);
+    let v = Vec3::new(r, g, b);
+    v.normalize().into()
+}
diff --git a/examples/window/clear_color_pipelined.rs b/examples/window/clear_color_pipelined.rs
new file mode 100644
index 0000000000..a2b020119a
--- /dev/null
+++ b/examples/window/clear_color_pipelined.rs
@@ -0,0 +1,25 @@
+use bevy::{
+    core_pipeline::ClearColor,
+    prelude::*,
+    render2::{camera::OrthographicCameraBundle, color::Color},
+    PipelinedDefaultPlugins,
+};
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::rgb(0.5, 0.5, 0.9)))
+        .add_plugins(PipelinedDefaultPlugins)
+        .add_startup_system(setup)
+        .add_system(change_clear_color)
+        .run();
+}
+
+fn setup(mut commands: Commands) {
+    commands.spawn_bundle(OrthographicCameraBundle::new_2d());
+}
+
+fn change_clear_color(input: Res<Input<KeyCode>>, mut clear_color: ResMut<ClearColor>) {
+    if input.just_pressed(KeyCode::Space) {
+        clear_color.0 = Color::PURPLE;
+    }
+}
diff --git a/examples/window/multiple_windows.rs b/examples/window/multiple_windows.rs
index 57c1e2f824..d8959a64a9 100644
--- a/examples/window/multiple_windows.rs
+++ b/examples/window/multiple_windows.rs
@@ -7,7 +7,7 @@ use bevy::{
             base::MainPass, CameraNode, PassNode, RenderGraph, WindowSwapChainNode,
             WindowTextureNode,
         },
-        texture::{Extent3d, TextureDescriptor, TextureDimension, TextureFormat, TextureUsage},
+        texture::{Extent3d, TextureDescriptor, TextureDimension, TextureFormat, TextureUsages},
     },
     window::{CreateWindow, WindowDescriptor, WindowId},
 };
@@ -88,7 +88,7 @@ fn setup_pipeline(
             window_id,
             TextureDescriptor {
                 format: TextureFormat::Depth32Float,
-                usage: TextureUsage::OUTPUT_ATTACHMENT,
+                usage: TextureUsages::OUTPUT_ATTACHMENT,
                 sample_count: msaa.samples,
                 ..Default::default()
             },
@@ -165,7 +165,7 @@ fn setup_pipeline(
                     sample_count: msaa.samples,
                     dimension: TextureDimension::D2,
                     format: TextureFormat::default(),
-                    usage: TextureUsage::OUTPUT_ATTACHMENT,
+                    usage: TextureUsages::OUTPUT_ATTACHMENT,
                 },
             ),
         );
diff --git a/pipelined/bevy_core_pipeline/Cargo.toml b/pipelined/bevy_core_pipeline/Cargo.toml
new file mode 100644
index 0000000000..35dec39023
--- /dev/null
+++ b/pipelined/bevy_core_pipeline/Cargo.toml
@@ -0,0 +1,22 @@
+[package]
+name = "bevy_core_pipeline"
+version = "0.5.0"
+edition = "2021"
+authors = [
+    "Bevy Contributors <bevyengine@gmail.com>",
+    "Carter Anderson <mcanders1@gmail.com>",
+]
+description = "Provides a core render pipeline for Bevy Engine."
+homepage = "https://bevyengine.org"
+repository = "https://github.com/bevyengine/bevy"
+license = "MIT OR Apache-2.0"
+keywords = ["bevy"]
+
+[dependencies]
+# bevy
+bevy_app = { path = "../../crates/bevy_app", version = "0.5.0" }
+bevy_asset = { path = "../../crates/bevy_asset", version = "0.5.0" }
+bevy_core = { path = "../../crates/bevy_core", version = "0.5.0" }
+bevy_ecs = { path = "../../crates/bevy_ecs", version = "0.5.0" }
+bevy_render2 = { path = "../bevy_render2", version = "0.5.0" }
+
diff --git a/pipelined/bevy_core_pipeline/src/lib.rs b/pipelined/bevy_core_pipeline/src/lib.rs
new file mode 100644
index 0000000000..7da6c58887
--- /dev/null
+++ b/pipelined/bevy_core_pipeline/src/lib.rs
@@ -0,0 +1,326 @@
+mod main_pass_2d;
+mod main_pass_3d;
+mod main_pass_driver;
+
+pub use main_pass_2d::*;
+pub use main_pass_3d::*;
+pub use main_pass_driver::*;
+
+use bevy_app::{App, Plugin};
+use bevy_core::FloatOrd;
+use bevy_ecs::prelude::*;
+use bevy_render2::{
+    camera::{ActiveCameras, CameraPlugin},
+    color::Color,
+    render_graph::{EmptyNode, RenderGraph, SlotInfo, SlotType},
+    render_phase::{
+        sort_phase_system, CachedPipelinePhaseItem, DrawFunctionId, DrawFunctions, EntityPhaseItem,
+        PhaseItem, RenderPhase,
+    },
+    render_resource::*,
+    renderer::RenderDevice,
+    texture::TextureCache,
+    view::{ExtractedView, Msaa, ViewDepthTexture},
+    RenderApp, RenderStage, RenderWorld,
+};
+
+/// Resource that configures the clear color
+#[derive(Clone, Debug)]
+pub struct ClearColor(pub Color);
+
+impl Default for ClearColor {
+    fn default() -> Self {
+        Self(Color::rgb(0.4, 0.4, 0.4))
+    }
+}
+
+// Plugins that contribute to the RenderGraph should use the following label conventions:
+// 1. Graph modules should have a NAME, input module, and node module (where relevant)
+// 2. The "top level" graph is the plugin module root. Just add things like `pub mod node` directly under the plugin module
+// 3. "sub graph" modules should be nested beneath their parent graph module
+
+pub mod node {
+    pub const MAIN_PASS_DEPENDENCIES: &str = "main_pass_dependencies";
+    pub const MAIN_PASS_DRIVER: &str = "main_pass_driver";
+    pub const VIEW: &str = "view";
+}
+
+pub mod draw_2d_graph {
+    pub const NAME: &str = "draw_2d";
+    pub mod input {
+        pub const VIEW_ENTITY: &str = "view_entity";
+    }
+    pub mod node {
+        pub const MAIN_PASS: &str = "main_pass";
+    }
+}
+
+pub mod draw_3d_graph {
+    pub const NAME: &str = "draw_3d";
+    pub mod input {
+        pub const VIEW_ENTITY: &str = "view_entity";
+    }
+    pub mod node {
+        pub const MAIN_PASS: &str = "main_pass";
+    }
+}
+
+#[derive(Default)]
+pub struct CorePipelinePlugin;
+
+impl Plugin for CorePipelinePlugin {
+    fn build(&self, app: &mut App) {
+        app.init_resource::<ClearColor>();
+
+        let render_app = app.sub_app(RenderApp);
+        render_app
+            .init_resource::<DrawFunctions<Transparent2d>>()
+            .init_resource::<DrawFunctions<Opaque3d>>()
+            .init_resource::<DrawFunctions<AlphaMask3d>>()
+            .init_resource::<DrawFunctions<Transparent3d>>()
+            .add_system_to_stage(RenderStage::Extract, extract_clear_color)
+            .add_system_to_stage(RenderStage::Extract, extract_core_pipeline_camera_phases)
+            .add_system_to_stage(RenderStage::Prepare, prepare_core_views_system)
+            .add_system_to_stage(RenderStage::PhaseSort, sort_phase_system::<Transparent2d>)
+            .add_system_to_stage(RenderStage::PhaseSort, sort_phase_system::<Opaque3d>)
+            .add_system_to_stage(RenderStage::PhaseSort, sort_phase_system::<AlphaMask3d>)
+            .add_system_to_stage(RenderStage::PhaseSort, sort_phase_system::<Transparent3d>);
+
+        let pass_node_2d = MainPass2dNode::new(&mut render_app.world);
+        let pass_node_3d = MainPass3dNode::new(&mut render_app.world);
+        let mut graph = render_app.world.get_resource_mut::<RenderGraph>().unwrap();
+
+        let mut draw_2d_graph = RenderGraph::default();
+        draw_2d_graph.add_node(draw_2d_graph::node::MAIN_PASS, pass_node_2d);
+        let input_node_id = draw_2d_graph.set_input(vec![SlotInfo::new(
+            draw_2d_graph::input::VIEW_ENTITY,
+            SlotType::Entity,
+        )]);
+        draw_2d_graph
+            .add_slot_edge(
+                input_node_id,
+                draw_2d_graph::input::VIEW_ENTITY,
+                draw_2d_graph::node::MAIN_PASS,
+                MainPass2dNode::IN_VIEW,
+            )
+            .unwrap();
+        graph.add_sub_graph(draw_2d_graph::NAME, draw_2d_graph);
+
+        let mut draw_3d_graph = RenderGraph::default();
+        draw_3d_graph.add_node(draw_3d_graph::node::MAIN_PASS, pass_node_3d);
+        let input_node_id = draw_3d_graph.set_input(vec![SlotInfo::new(
+            draw_3d_graph::input::VIEW_ENTITY,
+            SlotType::Entity,
+        )]);
+        draw_3d_graph
+            .add_slot_edge(
+                input_node_id,
+                draw_3d_graph::input::VIEW_ENTITY,
+                draw_3d_graph::node::MAIN_PASS,
+                MainPass3dNode::IN_VIEW,
+            )
+            .unwrap();
+        graph.add_sub_graph(draw_3d_graph::NAME, draw_3d_graph);
+
+        graph.add_node(node::MAIN_PASS_DEPENDENCIES, EmptyNode);
+        graph.add_node(node::MAIN_PASS_DRIVER, MainPassDriverNode);
+        graph
+            .add_node_edge(node::MAIN_PASS_DEPENDENCIES, node::MAIN_PASS_DRIVER)
+            .unwrap();
+    }
+}
+
+pub struct Transparent2d {
+    pub sort_key: FloatOrd,
+    pub entity: Entity,
+    pub pipeline: CachedPipelineId,
+    pub draw_function: DrawFunctionId,
+}
+
+impl PhaseItem for Transparent2d {
+    type SortKey = FloatOrd;
+
+    #[inline]
+    fn sort_key(&self) -> Self::SortKey {
+        self.sort_key
+    }
+
+    #[inline]
+    fn draw_function(&self) -> DrawFunctionId {
+        self.draw_function
+    }
+}
+
+pub struct Opaque3d {
+    pub distance: f32,
+    pub pipeline: CachedPipelineId,
+    pub entity: Entity,
+    pub draw_function: DrawFunctionId,
+}
+
+impl PhaseItem for Opaque3d {
+    type SortKey = FloatOrd;
+
+    #[inline]
+    fn sort_key(&self) -> Self::SortKey {
+        FloatOrd(self.distance)
+    }
+
+    #[inline]
+    fn draw_function(&self) -> DrawFunctionId {
+        self.draw_function
+    }
+}
+
+impl EntityPhaseItem for Opaque3d {
+    #[inline]
+    fn entity(&self) -> Entity {
+        self.entity
+    }
+}
+
+impl CachedPipelinePhaseItem for Opaque3d {
+    #[inline]
+    fn cached_pipeline(&self) -> CachedPipelineId {
+        self.pipeline
+    }
+}
+
+pub struct AlphaMask3d {
+    pub distance: f32,
+    pub pipeline: CachedPipelineId,
+    pub entity: Entity,
+    pub draw_function: DrawFunctionId,
+}
+
+impl PhaseItem for AlphaMask3d {
+    type SortKey = FloatOrd;
+
+    #[inline]
+    fn sort_key(&self) -> Self::SortKey {
+        FloatOrd(self.distance)
+    }
+
+    #[inline]
+    fn draw_function(&self) -> DrawFunctionId {
+        self.draw_function
+    }
+}
+
+impl EntityPhaseItem for AlphaMask3d {
+    #[inline]
+    fn entity(&self) -> Entity {
+        self.entity
+    }
+}
+
+impl CachedPipelinePhaseItem for AlphaMask3d {
+    #[inline]
+    fn cached_pipeline(&self) -> CachedPipelineId {
+        self.pipeline
+    }
+}
+
+pub struct Transparent3d {
+    pub distance: f32,
+    pub pipeline: CachedPipelineId,
+    pub entity: Entity,
+    pub draw_function: DrawFunctionId,
+}
+
+impl PhaseItem for Transparent3d {
+    type SortKey = FloatOrd;
+
+    #[inline]
+    fn sort_key(&self) -> Self::SortKey {
+        FloatOrd(self.distance)
+    }
+
+    #[inline]
+    fn draw_function(&self) -> DrawFunctionId {
+        self.draw_function
+    }
+}
+
+impl EntityPhaseItem for Transparent3d {
+    #[inline]
+    fn entity(&self) -> Entity {
+        self.entity
+    }
+}
+
+impl CachedPipelinePhaseItem for Transparent3d {
+    #[inline]
+    fn cached_pipeline(&self) -> CachedPipelineId {
+        self.pipeline
+    }
+}
+
+pub fn extract_clear_color(clear_color: Res<ClearColor>, mut render_world: ResMut<RenderWorld>) {
+    // If the clear color has changed
+    if clear_color.is_changed() {
+        // Update the clear color resource in the render world
+        render_world.insert_resource(clear_color.clone())
+    }
+}
+
+pub fn extract_core_pipeline_camera_phases(
+    mut commands: Commands,
+    active_cameras: Res<ActiveCameras>,
+) {
+    if let Some(camera_2d) = active_cameras.get(CameraPlugin::CAMERA_2D) {
+        if let Some(entity) = camera_2d.entity {
+            commands
+                .get_or_spawn(entity)
+                .insert(RenderPhase::<Transparent2d>::default());
+        }
+    }
+    if let Some(camera_3d) = active_cameras.get(CameraPlugin::CAMERA_3D) {
+        if let Some(entity) = camera_3d.entity {
+            commands.get_or_spawn(entity).insert_bundle((
+                RenderPhase::<Opaque3d>::default(),
+                RenderPhase::<AlphaMask3d>::default(),
+                RenderPhase::<Transparent3d>::default(),
+            ));
+        }
+    }
+}
+
+pub fn prepare_core_views_system(
+    mut commands: Commands,
+    mut texture_cache: ResMut<TextureCache>,
+    msaa: Res<Msaa>,
+    render_device: Res<RenderDevice>,
+    views_3d: Query<
+        (Entity, &ExtractedView),
+        (
+            With<RenderPhase<Opaque3d>>,
+            With<RenderPhase<AlphaMask3d>>,
+            With<RenderPhase<Transparent3d>>,
+        ),
+    >,
+) {
+    for (entity, view) in views_3d.iter() {
+        let cached_texture = texture_cache.get(
+            &render_device,
+            TextureDescriptor {
+                label: Some("view_depth_texture"),
+                size: Extent3d {
+                    depth_or_array_layers: 1,
+                    width: view.width as u32,
+                    height: view.height as u32,
+                },
+                mip_level_count: 1,
+                sample_count: msaa.samples,
+                dimension: TextureDimension::D2,
+                format: TextureFormat::Depth32Float, /* PERF: vulkan docs recommend using 24
+                                                      * bit depth for better performance */
+                usage: TextureUsages::RENDER_ATTACHMENT,
+            },
+        );
+        commands.entity(entity).insert(ViewDepthTexture {
+            texture: cached_texture.texture,
+            view: cached_texture.default_view,
+        });
+    }
+}
diff --git a/pipelined/bevy_core_pipeline/src/main_pass_2d.rs b/pipelined/bevy_core_pipeline/src/main_pass_2d.rs
new file mode 100644
index 0000000000..86b1baa49e
--- /dev/null
+++ b/pipelined/bevy_core_pipeline/src/main_pass_2d.rs
@@ -0,0 +1,76 @@
+use crate::{ClearColor, Transparent2d};
+use bevy_ecs::prelude::*;
+use bevy_render2::{
+    render_graph::{Node, NodeRunError, RenderGraphContext, SlotInfo, SlotType},
+    render_phase::{DrawFunctions, RenderPhase, TrackedRenderPass},
+    render_resource::{LoadOp, Operations, RenderPassColorAttachment, RenderPassDescriptor},
+    renderer::RenderContext,
+    view::{ExtractedView, ViewTarget},
+};
+
+pub struct MainPass2dNode {
+    query:
+        QueryState<(&'static RenderPhase<Transparent2d>, &'static ViewTarget), With<ExtractedView>>,
+}
+
+impl MainPass2dNode {
+    pub const IN_VIEW: &'static str = "view";
+
+    pub fn new(world: &mut World) -> Self {
+        Self {
+            query: QueryState::new(world),
+        }
+    }
+}
+
+impl Node for MainPass2dNode {
+    fn input(&self) -> Vec<SlotInfo> {
+        vec![SlotInfo::new(MainPass2dNode::IN_VIEW, SlotType::Entity)]
+    }
+
+    fn update(&mut self, world: &mut World) {
+        self.query.update_archetypes(world);
+    }
+
+    fn run(
+        &self,
+        graph: &mut RenderGraphContext,
+        render_context: &mut RenderContext,
+        world: &World,
+    ) -> Result<(), NodeRunError> {
+        let view_entity = graph.get_input_entity(Self::IN_VIEW)?;
+        let (transparent_phase, target) = self
+            .query
+            .get_manual(world, view_entity)
+            .expect("view entity should exist");
+        let clear_color = world.get_resource::<ClearColor>().unwrap();
+        let pass_descriptor = RenderPassDescriptor {
+            label: Some("main_pass_2d"),
+            color_attachments: &[RenderPassColorAttachment {
+                view: &target.view,
+                resolve_target: None,
+                ops: Operations {
+                    load: LoadOp::Clear(clear_color.0.into()),
+                    store: true,
+                },
+            }],
+            depth_stencil_attachment: None,
+        };
+
+        let draw_functions = world
+            .get_resource::<DrawFunctions<Transparent2d>>()
+            .unwrap();
+
+        let render_pass = render_context
+            .command_encoder
+            .begin_render_pass(&pass_descriptor);
+
+        let mut draw_functions = draw_functions.write();
+        let mut tracked_pass = TrackedRenderPass::new(render_pass);
+        for item in transparent_phase.items.iter() {
+            let draw_function = draw_functions.get_mut(item.draw_function).unwrap();
+            draw_function.draw(world, &mut tracked_pass, view_entity, item);
+        }
+        Ok(())
+    }
+}
diff --git a/pipelined/bevy_core_pipeline/src/main_pass_3d.rs b/pipelined/bevy_core_pipeline/src/main_pass_3d.rs
new file mode 100644
index 0000000000..b63bb80949
--- /dev/null
+++ b/pipelined/bevy_core_pipeline/src/main_pass_3d.rs
@@ -0,0 +1,165 @@
+use crate::{AlphaMask3d, ClearColor, Opaque3d, Transparent3d};
+use bevy_ecs::prelude::*;
+use bevy_render2::{
+    render_graph::{Node, NodeRunError, RenderGraphContext, SlotInfo, SlotType},
+    render_phase::{DrawFunctions, RenderPhase, TrackedRenderPass},
+    render_resource::{LoadOp, Operations, RenderPassDepthStencilAttachment, RenderPassDescriptor},
+    renderer::RenderContext,
+    view::{ExtractedView, ViewDepthTexture, ViewTarget},
+};
+
+pub struct MainPass3dNode {
+    query: QueryState<
+        (
+            &'static RenderPhase<Opaque3d>,
+            &'static RenderPhase<AlphaMask3d>,
+            &'static RenderPhase<Transparent3d>,
+            &'static ViewTarget,
+            &'static ViewDepthTexture,
+        ),
+        With<ExtractedView>,
+    >,
+}
+
+impl MainPass3dNode {
+    pub const IN_VIEW: &'static str = "view";
+
+    pub fn new(world: &mut World) -> Self {
+        Self {
+            query: QueryState::new(world),
+        }
+    }
+}
+
+impl Node for MainPass3dNode {
+    fn input(&self) -> Vec<SlotInfo> {
+        vec![SlotInfo::new(MainPass3dNode::IN_VIEW, SlotType::Entity)]
+    }
+
+    fn update(&mut self, world: &mut World) {
+        self.query.update_archetypes(world);
+    }
+
+    fn run(
+        &self,
+        graph: &mut RenderGraphContext,
+        render_context: &mut RenderContext,
+        world: &World,
+    ) -> Result<(), NodeRunError> {
+        let view_entity = graph.get_input_entity(Self::IN_VIEW)?;
+        let (opaque_phase, alpha_mask_phase, transparent_phase, target, depth) = self
+            .query
+            .get_manual(world, view_entity)
+            .expect("view entity should exist");
+        let clear_color = world.get_resource::<ClearColor>().unwrap();
+
+        {
+            // Run the opaque pass, sorted front-to-back
+            // NOTE: Scoped to drop the mutable borrow of render_context
+            let pass_descriptor = RenderPassDescriptor {
+                label: Some("main_opaque_pass_3d"),
+                // NOTE: The opaque pass clears and initializes the color
+                //       buffer as well as writing to it.
+                color_attachments: &[target.get_color_attachment(Operations {
+                    load: LoadOp::Clear(clear_color.0.into()),
+                    store: true,
+                })],
+                depth_stencil_attachment: Some(RenderPassDepthStencilAttachment {
+                    view: &depth.view,
+                    // NOTE: The opaque main pass clears and writes to the depth buffer.
+                    depth_ops: Some(Operations {
+                        load: LoadOp::Clear(0.0),
+                        store: true,
+                    }),
+                    stencil_ops: None,
+                }),
+            };
+
+            let draw_functions = world.get_resource::<DrawFunctions<Opaque3d>>().unwrap();
+
+            let render_pass = render_context
+                .command_encoder
+                .begin_render_pass(&pass_descriptor);
+            let mut draw_functions = draw_functions.write();
+            let mut tracked_pass = TrackedRenderPass::new(render_pass);
+            for item in opaque_phase.items.iter() {
+                let draw_function = draw_functions.get_mut(item.draw_function).unwrap();
+                draw_function.draw(world, &mut tracked_pass, view_entity, item);
+            }
+        }
+
+        {
+            // Run the alpha mask pass, sorted front-to-back
+            // NOTE: Scoped to drop the mutable borrow of render_context
+            let pass_descriptor = RenderPassDescriptor {
+                label: Some("main_alpha_mask_pass_3d"),
+                // NOTE: The alpha_mask pass loads the color buffer as well as overwriting it where appropriate.
+                color_attachments: &[target.get_color_attachment(Operations {
+                    load: LoadOp::Load,
+                    store: true,
+                })],
+                depth_stencil_attachment: Some(RenderPassDepthStencilAttachment {
+                    view: &depth.view,
+                    // NOTE: The alpha mask pass loads the depth buffer and possibly overwrites it
+                    depth_ops: Some(Operations {
+                        load: LoadOp::Load,
+                        store: true,
+                    }),
+                    stencil_ops: None,
+                }),
+            };
+
+            let draw_functions = world.get_resource::<DrawFunctions<AlphaMask3d>>().unwrap();
+
+            let render_pass = render_context
+                .command_encoder
+                .begin_render_pass(&pass_descriptor);
+            let mut draw_functions = draw_functions.write();
+            let mut tracked_pass = TrackedRenderPass::new(render_pass);
+            for item in alpha_mask_phase.items.iter() {
+                let draw_function = draw_functions.get_mut(item.draw_function).unwrap();
+                draw_function.draw(world, &mut tracked_pass, view_entity, item);
+            }
+        }
+
+        {
+            // Run the transparent pass, sorted back-to-front
+            // NOTE: Scoped to drop the mutable borrow of render_context
+            let pass_descriptor = RenderPassDescriptor {
+                label: Some("main_transparent_pass_3d"),
+                // NOTE: The transparent pass loads the color buffer as well as overwriting it where appropriate.
+                color_attachments: &[target.get_color_attachment(Operations {
+                    load: LoadOp::Load,
+                    store: true,
+                })],
+                depth_stencil_attachment: Some(RenderPassDepthStencilAttachment {
+                    view: &depth.view,
+                    // NOTE: For the transparent pass we load the depth buffer but do not write to it.
+                    //       As the opaque and alpha mask passes run first, opaque meshes can occlude
+                    //       transparent ones.
+                    depth_ops: Some(Operations {
+                        load: LoadOp::Load,
+                        store: false,
+                    }),
+                    stencil_ops: None,
+                }),
+            };
+
+            let draw_functions = world
+                .get_resource::<DrawFunctions<Transparent3d>>()
+                .unwrap();
+
+            let render_pass = render_context
+                .command_encoder
+                .begin_render_pass(&pass_descriptor);
+            let mut draw_functions = draw_functions.write();
+            let mut tracked_pass = TrackedRenderPass::new(render_pass);
+            for item in transparent_phase.items.iter() {
+                let draw_function = draw_functions.get_mut(item.draw_function).unwrap();
+                draw_function.draw(world, &mut tracked_pass, view_entity, item);
+            }
+        }
+
+        Ok(())
+    }
+}
diff --git a/pipelined/bevy_core_pipeline/src/main_pass_driver.rs b/pipelined/bevy_core_pipeline/src/main_pass_driver.rs
new file mode 100644
index 0000000000..07382d4995
--- /dev/null
+++ b/pipelined/bevy_core_pipeline/src/main_pass_driver.rs
@@ -0,0 +1,34 @@
+use bevy_ecs::world::World;
+use bevy_render2::{
+    camera::{CameraPlugin, ExtractedCameraNames},
+    render_graph::{Node, NodeRunError, RenderGraphContext, SlotValue},
+    renderer::RenderContext,
+};
+
+pub struct MainPassDriverNode;
+
+impl Node for MainPassDriverNode {
+    fn run(
+        &self,
+        graph: &mut RenderGraphContext,
+        _render_context: &mut RenderContext,
+        world: &World,
+    ) -> Result<(), NodeRunError> {
+        let extracted_cameras = world.get_resource::<ExtractedCameraNames>().unwrap();
+        if let Some(camera_2d) = extracted_cameras.entities.get(CameraPlugin::CAMERA_2D) {
+            graph.run_sub_graph(
+                crate::draw_2d_graph::NAME,
+                vec![SlotValue::Entity(*camera_2d)],
+            )?;
+        }
+
+        if let Some(camera_3d) = extracted_cameras.entities.get(CameraPlugin::CAMERA_3D) {
+            graph.run_sub_graph(
+                crate::draw_3d_graph::NAME,
+                vec![SlotValue::Entity(*camera_3d)],
+            )?;
+        }
+
+        Ok(())
+    }
+}
diff --git a/pipelined/bevy_gltf2/Cargo.toml b/pipelined/bevy_gltf2/Cargo.toml
new file mode 100644
index 0000000000..080d004334
--- /dev/null
+++ b/pipelined/bevy_gltf2/Cargo.toml
@@ -0,0 +1,35 @@
+[package]
+name = "bevy_gltf2"
+version = "0.5.0"
+edition = "2021"
+authors = [
+    "Bevy Contributors <bevyengine@gmail.com>",
+    "Carter Anderson <mcanders1@gmail.com>",
+]
+description = "Bevy Engine GLTF loading"
+homepage = "https://bevyengine.org"
+repository = "https://github.com/bevyengine/bevy"
+license = "MIT OR Apache-2.0"
+keywords = ["bevy"]
+
+[dependencies]
+# bevy
+bevy_app = { path = "../../crates/bevy_app", version = "0.5.0" }
+bevy_asset = { path = "../../crates/bevy_asset", version = "0.5.0" }
+bevy_core = { path = "../../crates/bevy_core", version = "0.5.0" }
+bevy_ecs = { path = "../../crates/bevy_ecs", version = "0.5.0" }
+bevy_pbr2 = { path = "../bevy_pbr2", version = "0.5.0" }
+bevy_reflect = { path = "../../crates/bevy_reflect", version = "0.5.0", features = ["bevy"] }
+bevy_render2 = { path = "../bevy_render2", version = "0.5.0" }
+bevy_transform = { path = "../../crates/bevy_transform", version = "0.5.0" }
+bevy_math = { path = "../../crates/bevy_math", version = "0.5.0" }
+bevy_scene = { path = "../../crates/bevy_scene", version = "0.5.0" }
+bevy_log = { path = "../../crates/bevy_log", version = "0.5.0" }
+
+# other
+gltf = { version = "0.16.0", default-features = false, features = ["utils", "names", "KHR_materials_unlit"] }
+thiserror = "1.0"
+anyhow = "1.0.4"
+base64 = "0.13.0"
+percent-encoding = "2.1"
+wgpu = "0.11.0"
diff --git a/pipelined/bevy_gltf2/src/lib.rs b/pipelined/bevy_gltf2/src/lib.rs
new file mode 100644
index 0000000000..39cd6a9d41
--- /dev/null
+++ b/pipelined/bevy_gltf2/src/lib.rs
@@ -0,0 +1,65 @@
+use std::collections::HashMap;
+
+mod loader;
+pub use loader::*;
+
+use bevy_app::prelude::*;
+use bevy_asset::{AddAsset, Handle};
+use bevy_pbr2::StandardMaterial;
+use bevy_reflect::TypeUuid;
+use bevy_render2::mesh::Mesh;
+use bevy_scene::Scene;
+
+/// Adds support for glTF file loading to the app.
+#[derive(Default)]
+pub struct GltfPlugin;
+
+impl Plugin for GltfPlugin {
+    fn build(&self, app: &mut App) {
+        app.init_asset_loader::<GltfLoader>()
+            .add_asset::<Gltf>()
+            .add_asset::<GltfNode>()
+            .add_asset::<GltfPrimitive>()
+            .add_asset::<GltfMesh>();
+    }
+}
+
+/// Representation of a loaded glTF file.
+#[derive(Debug, TypeUuid)]
+#[uuid = "5c7d5f8a-f7b0-4e45-a09e-406c0372fea2"]
+pub struct Gltf {
+    pub scenes: Vec<Handle<Scene>>,
+    pub named_scenes: HashMap<String, Handle<Scene>>,
+    pub meshes: Vec<Handle<GltfMesh>>,
+    pub named_meshes: HashMap<String, Handle<GltfMesh>>,
+    pub materials: Vec<Handle<StandardMaterial>>,
+    pub named_materials: HashMap<String, Handle<StandardMaterial>>,
+    pub nodes: Vec<Handle<GltfNode>>,
+    pub named_nodes: HashMap<String, Handle<GltfNode>>,
+    pub default_scene: Option<Handle<Scene>>,
+}
+
+/// A glTF node with all of its child nodes, its [`GltfMesh`] and
+/// [`Transform`](bevy_transform::prelude::Transform).
+#[derive(Debug, Clone, TypeUuid)]
+#[uuid = "dad74750-1fd6-460f-ac51-0a7937563865"]
+pub struct GltfNode {
+    pub children: Vec<GltfNode>,
+    pub mesh: Option<Handle<GltfMesh>>,
+    pub transform: bevy_transform::prelude::Transform,
+}
+
+/// A glTF mesh, which may consists of multiple [`GtlfPrimitives`](GltfPrimitive).
+#[derive(Debug, Clone, TypeUuid)]
+#[uuid = "8ceaec9a-926a-4f29-8ee3-578a69f42315"]
+pub struct GltfMesh {
+    pub primitives: Vec<GltfPrimitive>,
+}
+
+/// Part of a [`GltfMesh`] that consists of a [`Mesh`] and an optional [`StandardMaterial`].
+#[derive(Debug, Clone, TypeUuid)]
+#[uuid = "cbfca302-82fd-41cb-af77-cab6b3d50af1"]
+pub struct GltfPrimitive {
+    pub mesh: Handle<Mesh>,
+    pub material: Option<Handle<StandardMaterial>>,
+}
diff --git a/pipelined/bevy_gltf2/src/loader.rs b/pipelined/bevy_gltf2/src/loader.rs
new file mode 100644
index 0000000000..560d221388
--- /dev/null
+++ b/pipelined/bevy_gltf2/src/loader.rs
@@ -0,0 +1,901 @@
+use anyhow::Result;
+use bevy_asset::{
+    AssetIoError, AssetLoader, AssetPath, BoxedFuture, Handle, LoadContext, LoadedAsset,
+};
+use bevy_core::Name;
+use bevy_ecs::world::World;
+use bevy_log::warn;
+use bevy_math::{Mat4, Vec3};
+use bevy_pbr2::{AlphaMode, PbrBundle, StandardMaterial};
+use bevy_render2::{
+    camera::{
+        Camera, CameraPlugin, CameraProjection, OrthographicProjection, PerspectiveProjection,
+    },
+    color::Color,
+    mesh::{Indices, Mesh, VertexAttributeValues},
+    primitives::Aabb,
+    texture::{Image, ImageType, TextureError},
+};
+use bevy_scene::Scene;
+use bevy_transform::{
+    hierarchy::{BuildWorldChildren, WorldChildBuilder},
+    prelude::{GlobalTransform, Transform},
+};
+use gltf::{
+    mesh::Mode,
+    texture::{MagFilter, MinFilter, WrappingMode},
+    Material, Primitive,
+};
+use std::{
+    collections::{HashMap, HashSet},
+    path::Path,
+};
+use thiserror::Error;
+use wgpu::{AddressMode, FilterMode, PrimitiveTopology, SamplerDescriptor, TextureFormat};
+
+use crate::{Gltf, GltfNode};
+
+/// An error that occurs when loading a glTF file.
+#[derive(Error, Debug)]
+pub enum GltfError {
+    #[error("unsupported primitive mode")]
+    UnsupportedPrimitive { mode: Mode },
+    #[error("invalid glTF file: {0}")]
+    Gltf(#[from] gltf::Error),
+    #[error("binary blob is missing")]
+    MissingBlob,
+    #[error("failed to decode base64 mesh data")]
+    Base64Decode(#[from] base64::DecodeError),
+    #[error("unsupported buffer format")]
+    BufferFormatUnsupported,
+    #[error("invalid image mime type: {0}")]
+    InvalidImageMimeType(String),
+    #[error("You may need to add the feature for the file format: {0}")]
+    ImageError(#[from] TextureError),
+    #[error("failed to load an asset path: {0}")]
+    AssetIoError(#[from] AssetIoError),
+}
+
+/// Loads glTF files with all of their data as their corresponding bevy representations.
+#[derive(Default)]
+pub struct GltfLoader;
+
+impl AssetLoader for GltfLoader {
+    fn load<'a>(
+        &'a self,
+        bytes: &'a [u8],
+        load_context: &'a mut LoadContext,
+    ) -> BoxedFuture<'a, Result<()>> {
+        Box::pin(async move { Ok(load_gltf(bytes, load_context).await?) })
+    }
+
+    fn extensions(&self) -> &[&str] {
+        &["gltf", "glb"]
+    }
+}
+
+/// Loads an entire glTF file.
+async fn load_gltf<'a, 'b>(
+    bytes: &'a [u8],
+    load_context: &'a mut LoadContext<'b>,
+) -> Result<(), GltfError> {
+    let gltf = gltf::Gltf::from_slice(bytes)?;
+    let buffer_data = load_buffers(&gltf, load_context, load_context.path()).await?;
+
+    let mut materials = vec![];
+    let mut named_materials = HashMap::new();
+    let mut linear_textures = HashSet::new();
+    for material in gltf.materials() {
+        let handle = load_material(&material, load_context);
+        if let Some(name) = material.name() {
+            named_materials.insert(name.to_string(), handle.clone());
+        }
+        materials.push(handle);
+        if let Some(texture) = material.normal_texture() {
+            linear_textures.insert(texture.texture().index());
+        }
+        if let Some(texture) = material.occlusion_texture() {
+            linear_textures.insert(texture.texture().index());
+        }
+        if let Some(texture) = material
+            .pbr_metallic_roughness()
+            .metallic_roughness_texture()
+        {
+            linear_textures.insert(texture.texture().index());
+        }
+    }
+
+    let mut meshes = vec![];
+    let mut named_meshes = HashMap::new();
+    for mesh in gltf.meshes() {
+        let mut primitives = vec![];
+        for primitive in mesh.primitives() {
+            let primitive_label = primitive_label(&mesh, &primitive);
+            let reader = primitive.reader(|buffer| Some(&buffer_data[buffer.index()]));
+            let primitive_topology = get_primitive_topology(primitive.mode())?;
+
+            let mut mesh = Mesh::new(primitive_topology);
+
+            if let Some(vertex_attribute) = reader
+                .read_positions()
+                .map(|v| VertexAttributeValues::Float32x3(v.collect()))
+            {
+                mesh.set_attribute(Mesh::ATTRIBUTE_POSITION, vertex_attribute);
+            }
+
+            if let Some(vertex_attribute) = reader
+                .read_normals()
+                .map(|v| VertexAttributeValues::Float32x3(v.collect()))
+            {
+                mesh.set_attribute(Mesh::ATTRIBUTE_NORMAL, vertex_attribute);
+            }
+
+            if let Some(vertex_attribute) = reader
+                .read_tangents()
+                .map(|v| VertexAttributeValues::Float32x4(v.collect()))
+            {
+                mesh.set_attribute(Mesh::ATTRIBUTE_TANGENT, vertex_attribute);
+            }
+
+            if let Some(vertex_attribute) = reader
+                .read_tex_coords(0)
+                .map(|v| VertexAttributeValues::Float32x2(v.into_f32().collect()))
+            {
+                mesh.set_attribute(Mesh::ATTRIBUTE_UV_0, vertex_attribute);
+            } else {
+                let len = mesh.count_vertices();
+                let uvs = vec![[0.0, 0.0]; len];
+                bevy_log::debug!("missing `TEXCOORD_0` vertex attribute, loading zeroed out UVs");
+                mesh.set_attribute(Mesh::ATTRIBUTE_UV_0, uvs);
+            }
+
+            // if let Some(vertex_attribute) = reader
+            //     .read_colors(0)
+            //     .map(|v| VertexAttributeValues::Float32x4(v.into_rgba_f32().collect()))
+            // {
+            //     mesh.set_attribute(Mesh::ATTRIBUTE_COLOR, vertex_attribute);
+            // }
+
+            if let Some(indices) = reader.read_indices() {
+                mesh.set_indices(Some(Indices::U32(indices.into_u32().collect())));
+            };
+
+            if mesh.attribute(Mesh::ATTRIBUTE_NORMAL).is_none() {
+                let vertex_count_before = mesh.count_vertices();
+                mesh.duplicate_vertices();
+                mesh.compute_flat_normals();
+                let vertex_count_after = mesh.count_vertices();
+
+                if vertex_count_before != vertex_count_after {
+                    bevy_log::debug!("Missing vertex normals in indexed geometry, computing them as flat. Vertex count increased from {} to {}", vertex_count_before, vertex_count_after);
+                } else {
+                    bevy_log::debug!(
+                        "Missing vertex normals in indexed geometry, computing them as flat."
+                    );
+                }
+            }
+
+            let mesh = load_context.set_labeled_asset(&primitive_label, LoadedAsset::new(mesh));
+            primitives.push(super::GltfPrimitive {
+                mesh,
+                material: primitive
+                    .material()
+                    .index()
+                    .and_then(|i| materials.get(i).cloned()),
+            });
+        }
+        let handle = load_context.set_labeled_asset(
+            &mesh_label(&mesh),
+            LoadedAsset::new(super::GltfMesh { primitives }),
+        );
+        if let Some(name) = mesh.name() {
+            named_meshes.insert(name.to_string(), handle.clone());
+        }
+        meshes.push(handle);
+    }
+
+    let mut nodes_intermediate = vec![];
+    let mut named_nodes_intermediate = HashMap::new();
+    for node in gltf.nodes() {
+        let node_label = node_label(&node);
+        nodes_intermediate.push((
+            node_label,
+            GltfNode {
+                children: vec![],
+                mesh: node
+                    .mesh()
+                    .map(|mesh| mesh.index())
+                    .and_then(|i| meshes.get(i).cloned()),
+                transform: match node.transform() {
+                    gltf::scene::Transform::Matrix { matrix } => {
+                        Transform::from_matrix(bevy_math::Mat4::from_cols_array_2d(&matrix))
+                    }
+                    gltf::scene::Transform::Decomposed {
+                        translation,
+                        rotation,
+                        scale,
+                    } => Transform {
+                        translation: bevy_math::Vec3::from(translation),
+                        rotation: bevy_math::Quat::from_vec4(rotation.into()),
+                        scale: bevy_math::Vec3::from(scale),
+                    },
+                },
+            },
+            node.children()
+                .map(|child| child.index())
+                .collect::<Vec<_>>(),
+        ));
+        if let Some(name) = node.name() {
+            named_nodes_intermediate.insert(name, node.index());
+        }
+    }
+    let nodes = resolve_node_hierarchy(nodes_intermediate)
+        .into_iter()
+        .map(|(label, node)| load_context.set_labeled_asset(&label, LoadedAsset::new(node)))
+        .collect::<Vec<bevy_asset::Handle<GltfNode>>>();
+    let named_nodes = named_nodes_intermediate
+        .into_iter()
+        .filter_map(|(name, index)| {
+            nodes
+                .get(index)
+                .map(|handle| (name.to_string(), handle.clone()))
+        })
+        .collect();
+
+    // TODO: use the threaded impl on wasm once wasm thread pool doesn't deadlock on it
+    #[cfg(target_arch = "wasm32")]
+    for gltf_texture in gltf.textures() {
+        let (texture, label) =
+            load_texture(gltf_texture, &buffer_data, &linear_textures, &load_context).await?;
+        load_context.set_labeled_asset(&label, LoadedAsset::new(texture));
+    }
+
+    #[cfg(not(target_arch = "wasm32"))]
+    load_context
+        .task_pool()
+        .scope(|scope| {
+            gltf.textures().for_each(|gltf_texture| {
+                let linear_textures = &linear_textures;
+                let load_context: &LoadContext = load_context;
+                let buffer_data = &buffer_data;
+                scope.spawn(async move {
+                    load_texture(gltf_texture, buffer_data, linear_textures, load_context).await
+                });
+            });
+        })
+        .into_iter()
+        .filter_map(|res| {
+            if let Err(err) = res.as_ref() {
+                warn!("Error loading glTF texture: {}", err);
+            }
+            res.ok()
+        })
+        .for_each(|(texture, label)| {
+            load_context.set_labeled_asset(&label, LoadedAsset::new(texture));
+        });
+
+    let mut scenes = vec![];
+    let mut named_scenes = HashMap::new();
+    for scene in gltf.scenes() {
+        let mut err = None;
+        let mut world = World::default();
+        world
+            .spawn()
+            .insert_bundle((Transform::identity(), GlobalTransform::identity()))
+            .with_children(|parent| {
+                for node in scene.nodes() {
+                    let result = load_node(&node, parent, load_context, &buffer_data);
+                    if result.is_err() {
+                        err = Some(result);
+                        return;
+                    }
+                }
+            });
+        if let Some(Err(err)) = err {
+            return Err(err);
+        }
+        let scene_handle = load_context
+            .set_labeled_asset(&scene_label(&scene), LoadedAsset::new(Scene::new(world)));
+
+        if let Some(name) = scene.name() {
+            named_scenes.insert(name.to_string(), scene_handle.clone());
+        }
+        scenes.push(scene_handle);
+    }
+
+    load_context.set_default_asset(LoadedAsset::new(Gltf {
+        default_scene: gltf
+            .default_scene()
+            .and_then(|scene| scenes.get(scene.index()))
+            .cloned(),
+        scenes,
+        named_scenes,
+        meshes,
+        named_meshes,
+        materials,
+        named_materials,
+        nodes,
+        named_nodes,
+    }));
+
+    Ok(())
+}
+
+/// Loads a glTF texture as a bevy [`Image`] and returns it together with its label.
+async fn load_texture<'a>(
+    gltf_texture: gltf::Texture<'a>,
+    buffer_data: &[Vec<u8>],
+    linear_textures: &HashSet<usize>,
+    load_context: &LoadContext<'a>,
+) -> Result<(Image, String), GltfError> {
+    let mut texture = match gltf_texture.source().source() {
+        gltf::image::Source::View { view, mime_type } => {
+            let start = view.offset() as usize;
+            let end = (view.offset() + view.length()) as usize;
+            let buffer = &buffer_data[view.buffer().index()][start..end];
+            Image::from_buffer(buffer, ImageType::MimeType(mime_type))?
+        }
+        gltf::image::Source::Uri { uri, mime_type } => {
+            let uri = percent_encoding::percent_decode_str(uri)
+                .decode_utf8()
+                .unwrap();
+            let uri = uri.as_ref();
+            let (bytes, image_type) = match DataUri::parse(uri) {
+                Ok(data_uri) => (data_uri.decode()?, ImageType::MimeType(data_uri.mime_type)),
+                Err(()) => {
+                    let parent = load_context.path().parent().unwrap();
+                    let image_path = parent.join(uri);
+                    let bytes = load_context.read_asset_bytes(image_path.clone()).await?;
+
+                    let extension = Path::new(uri).extension().unwrap().to_str().unwrap();
+                    let image_type = ImageType::Extension(extension);
+
+                    (bytes, image_type)
+                }
+            };
+
+            Image::from_buffer(
+                &bytes,
+                mime_type
+                    .map(|mt| ImageType::MimeType(mt))
+                    .unwrap_or(image_type),
+            )?
+        }
+    };
+    texture.sampler_descriptor = texture_sampler(&gltf_texture);
+    if (linear_textures).contains(&gltf_texture.index()) {
+        texture.texture_descriptor.format = TextureFormat::Rgba8Unorm;
+    }
+
+    Ok((texture, texture_label(&gltf_texture)))
+}
+
+/// Loads a glTF material as a bevy [`StandardMaterial`] and returns it.
+fn load_material(material: &Material, load_context: &mut LoadContext) -> Handle<StandardMaterial> {
+    let material_label = material_label(material);
+
+    let pbr = material.pbr_metallic_roughness();
+
+    let color = pbr.base_color_factor();
+    let base_color_texture = if let Some(info) = pbr.base_color_texture() {
+        // TODO: handle info.tex_coord() (the *set* index for the right texcoords)
+        let label = texture_label(&info.texture());
+        let path = AssetPath::new_ref(load_context.path(), Some(&label));
+        Some(load_context.get_handle(path))
+    } else {
+        None
+    };
+
+    let normal_map_texture: Option<Handle<Image>> =
+        if let Some(normal_texture) = material.normal_texture() {
+            // TODO: handle normal_texture.scale
+            // TODO: handle normal_texture.tex_coord() (the *set* index for the right texcoords)
+            let label = texture_label(&normal_texture.texture());
+            let path = AssetPath::new_ref(load_context.path(), Some(&label));
+            Some(load_context.get_handle(path))
+        } else {
+            None
+        };
+
+    let metallic_roughness_texture = if let Some(info) = pbr.metallic_roughness_texture() {
+        // TODO: handle info.tex_coord() (the *set* index for the right texcoords)
+        let label = texture_label(&info.texture());
+        let path = AssetPath::new_ref(load_context.path(), Some(&label));
+        Some(load_context.get_handle(path))
+    } else {
+        None
+    };
+
+    let occlusion_texture = if let Some(occlusion_texture) = material.occlusion_texture() {
+        // TODO: handle occlusion_texture.tex_coord() (the *set* index for the right texcoords)
+        // TODO: handle occlusion_texture.strength() (a scalar multiplier for occlusion strength)
+        let label = texture_label(&occlusion_texture.texture());
+        let path = AssetPath::new_ref(load_context.path(), Some(&label));
+        Some(load_context.get_handle(path))
+    } else {
+        None
+    };
+
+    let emissive = material.emissive_factor();
+    let emissive_texture = if let Some(info) = material.emissive_texture() {
+        // TODO: handle occlusion_texture.tex_coord() (the *set* index for the right texcoords)
+        // TODO: handle occlusion_texture.strength() (a scalar multiplier for occlusion strength)
+        let label = texture_label(&info.texture());
+        let path = AssetPath::new_ref(load_context.path(), Some(&label));
+        Some(load_context.get_handle(path))
+    } else {
+        None
+    };
+
+    load_context.set_labeled_asset(
+        &material_label,
+        LoadedAsset::new(StandardMaterial {
+            base_color: Color::rgba(color[0], color[1], color[2], color[3]),
+            base_color_texture,
+            perceptual_roughness: pbr.roughness_factor(),
+            metallic: pbr.metallic_factor(),
+            metallic_roughness_texture,
+            normal_map_texture,
+            double_sided: material.double_sided(),
+            occlusion_texture,
+            emissive: Color::rgba(emissive[0], emissive[1], emissive[2], 1.0),
+            emissive_texture,
+            unlit: material.unlit(),
+            alpha_mode: alpha_mode(material),
+            ..Default::default()
+        }),
+    )
+}
+
+/// Loads a glTF node.
+fn load_node(
+    gltf_node: &gltf::Node,
+    world_builder: &mut WorldChildBuilder,
+    load_context: &mut LoadContext,
+    buffer_data: &[Vec<u8>],
+) -> Result<(), GltfError> {
+    let transform = gltf_node.transform();
+    let mut gltf_error = None;
+    let mut node = world_builder.spawn_bundle((
+        Transform::from_matrix(Mat4::from_cols_array_2d(&transform.matrix())),
+        GlobalTransform::identity(),
+    ));
+
+    if let Some(name) = gltf_node.name() {
+        node.insert(Name::new(name.to_string()));
+    }
+
+    // create camera node
+    if let Some(camera) = gltf_node.camera() {
+        // node.insert(VisibleEntities {
+        //     ..Default::default()
+        // });
+
+        match camera.projection() {
+            gltf::camera::Projection::Orthographic(orthographic) => {
+                let xmag = orthographic.xmag();
+                let ymag = orthographic.ymag();
+                let orthographic_projection: OrthographicProjection = OrthographicProjection {
+                    left: -xmag,
+                    right: xmag,
+                    top: ymag,
+                    bottom: -ymag,
+                    far: orthographic.zfar(),
+                    near: orthographic.znear(),
+                    ..Default::default()
+                };
+
+                node.insert(Camera {
+                    name: Some(CameraPlugin::CAMERA_2D.to_owned()),
+                    projection_matrix: orthographic_projection.get_projection_matrix(),
+                    ..Default::default()
+                });
+                node.insert(orthographic_projection);
+            }
+            gltf::camera::Projection::Perspective(perspective) => {
+                let mut perspective_projection: PerspectiveProjection = PerspectiveProjection {
+                    fov: perspective.yfov(),
+                    near: perspective.znear(),
+                    ..Default::default()
+                };
+                if let Some(zfar) = perspective.zfar() {
+                    perspective_projection.far = zfar;
+                }
+                if let Some(aspect_ratio) = perspective.aspect_ratio() {
+                    perspective_projection.aspect_ratio = aspect_ratio;
+                }
+                node.insert(Camera {
+                    name: Some(CameraPlugin::CAMERA_3D.to_owned()),
+                    projection_matrix: perspective_projection.get_projection_matrix(),
+                    ..Default::default()
+                });
+                node.insert(perspective_projection);
+            }
+        }
+    }
+
+    node.with_children(|parent| {
+        if let Some(mesh) = gltf_node.mesh() {
+            // append primitives
+            for primitive in mesh.primitives() {
+                let material = primitive.material();
+                let material_label = material_label(&material);
+
+                // This will make sure we load the default material now since it would not have been
+                // added when iterating over all the gltf materials (since the default material is
+                // not explicitly listed in the gltf).
+                if !load_context.has_labeled_asset(&material_label) {
+                    load_material(&material, load_context);
+                }
+
+                let primitive_label = primitive_label(&mesh, &primitive);
+                let mesh_asset_path =
+                    AssetPath::new_ref(load_context.path(), Some(&primitive_label));
+                let material_asset_path =
+                    AssetPath::new_ref(load_context.path(), Some(&material_label));
+
+                let bounds = primitive.bounding_box();
+                parent
+                    .spawn_bundle(PbrBundle {
+                        mesh: load_context.get_handle(mesh_asset_path),
+                        material: load_context.get_handle(material_asset_path),
+                        ..Default::default()
+                    })
+                    .insert(Aabb::from_min_max(
+                        Vec3::from_slice(&bounds.min),
+                        Vec3::from_slice(&bounds.max),
+                    ));
+            }
+        }
+
+        // append other nodes
+        for child in gltf_node.children() {
+            if let Err(err) = load_node(&child, parent, load_context, buffer_data) {
+                gltf_error = Some(err);
+                return;
+            }
+        }
+    });
+    if let Some(err) = gltf_error {
+        Err(err)
+    } else {
+        Ok(())
+    }
+}
+
+/// Returns the label for the `mesh`.
+fn mesh_label(mesh: &gltf::Mesh) -> String {
+    format!("Mesh{}", mesh.index())
+}
+
+/// Returns the label for the `mesh` and `primitive`.
+fn primitive_label(mesh: &gltf::Mesh, primitive: &Primitive) -> String {
+    format!("Mesh{}/Primitive{}", mesh.index(), primitive.index())
+}
+
+/// Returns the label for the `material`.
+fn material_label(material: &gltf::Material) -> String {
+    if let Some(index) = material.index() {
+        format!("Material{}", index)
+    } else {
+        "MaterialDefault".to_string()
+    }
+}
+
+/// Returns the label for the `texture`.
+fn texture_label(texture: &gltf::Texture) -> String {
+    format!("Texture{}", texture.index())
+}
+
+/// Returns the label for the `node`.
+fn node_label(node: &gltf::Node) -> String {
+    format!("Node{}", node.index())
+}
+
+/// Returns the label for the `scene`.
+fn scene_label(scene: &gltf::Scene) -> String {
+    format!("Scene{}", scene.index())
+}
+
+/// Extracts the texture sampler data from the glTF texture.
+fn texture_sampler<'a>(texture: &gltf::Texture) -> SamplerDescriptor<'a> {
+    let gltf_sampler = texture.sampler();
+
+    SamplerDescriptor {
+        address_mode_u: texture_address_mode(&gltf_sampler.wrap_s()),
+        address_mode_v: texture_address_mode(&gltf_sampler.wrap_t()),
+
+        mag_filter: gltf_sampler
+            .mag_filter()
+            .map(|mf| match mf {
+                MagFilter::Nearest => FilterMode::Nearest,
+                MagFilter::Linear => FilterMode::Linear,
+            })
+            .unwrap_or(SamplerDescriptor::default().mag_filter),
+
+        min_filter: gltf_sampler
+            .min_filter()
+            .map(|mf| match mf {
+                MinFilter::Nearest
+                | MinFilter::NearestMipmapNearest
+                | MinFilter::NearestMipmapLinear => FilterMode::Nearest,
+                MinFilter::Linear
+                | MinFilter::LinearMipmapNearest
+                | MinFilter::LinearMipmapLinear => FilterMode::Linear,
+            })
+            .unwrap_or(SamplerDescriptor::default().min_filter),
+
+        mipmap_filter: gltf_sampler
+            .min_filter()
+            .map(|mf| match mf {
+                MinFilter::Nearest
+                | MinFilter::Linear
+                | MinFilter::NearestMipmapNearest
+                | MinFilter::LinearMipmapNearest => FilterMode::Nearest,
+                MinFilter::NearestMipmapLinear | MinFilter::LinearMipmapLinear => {
+                    FilterMode::Linear
+                }
+            })
+            .unwrap_or(SamplerDescriptor::default().mipmap_filter),
+
+        ..Default::default()
+    }
+}
+
+/// Maps the texture address mode form glTF to wgpu.
+fn texture_address_mode(gltf_address_mode: &gltf::texture::WrappingMode) -> AddressMode {
+    match gltf_address_mode {
+        WrappingMode::ClampToEdge => AddressMode::ClampToEdge,
+        WrappingMode::Repeat => AddressMode::Repeat,
+        WrappingMode::MirroredRepeat => AddressMode::MirrorRepeat,
+    }
+}
+
+/// Maps the primitive_topology form glTF to wgpu.
+fn get_primitive_topology(mode: Mode) -> Result<PrimitiveTopology, GltfError> {
+    match mode {
+        Mode::Points => Ok(PrimitiveTopology::PointList),
+        Mode::Lines => Ok(PrimitiveTopology::LineList),
+        Mode::LineStrip => Ok(PrimitiveTopology::LineStrip),
+        Mode::Triangles => Ok(PrimitiveTopology::TriangleList),
+        Mode::TriangleStrip => Ok(PrimitiveTopology::TriangleStrip),
+        mode => Err(GltfError::UnsupportedPrimitive { mode }),
+    }
+}
+
+fn alpha_mode(material: &Material) -> AlphaMode {
+    match material.alpha_mode() {
+        gltf::material::AlphaMode::Opaque => AlphaMode::Opaque,
+        gltf::material::AlphaMode::Mask => AlphaMode::Mask(material.alpha_cutoff().unwrap_or(0.5)),
+        gltf::material::AlphaMode::Blend => AlphaMode::Blend,
+    }
+}
+
+/// Loads the raw glTF buffer data for a specific glTF file.
+async fn load_buffers(
+    gltf: &gltf::Gltf,
+    load_context: &LoadContext<'_>,
+    asset_path: &Path,
+) -> Result<Vec<Vec<u8>>, GltfError> {
+    const VALID_MIME_TYPES: &[&str] = &["application/octet-stream", "application/gltf-buffer"];
+
+    let mut buffer_data = Vec::new();
+    for buffer in gltf.buffers() {
+        match buffer.source() {
+            gltf::buffer::Source::Uri(uri) => {
+                let uri = percent_encoding::percent_decode_str(uri)
+                    .decode_utf8()
+                    .unwrap();
+                let uri = uri.as_ref();
+                let buffer_bytes = match DataUri::parse(uri) {
+                    Ok(data_uri) if VALID_MIME_TYPES.contains(&data_uri.mime_type) => {
+                        data_uri.decode()?
+                    }
+                    Ok(_) => return Err(GltfError::BufferFormatUnsupported),
+                    Err(()) => {
+                        // TODO: Remove this and add dep
+                        let buffer_path = asset_path.parent().unwrap().join(uri);
+                        let buffer_bytes = load_context.read_asset_bytes(buffer_path).await?;
+                        buffer_bytes
+                    }
+                };
+                buffer_data.push(buffer_bytes);
+            }
+            gltf::buffer::Source::Bin => {
+                if let Some(blob) = gltf.blob.as_deref() {
+                    buffer_data.push(blob.into());
+                } else {
+                    return Err(GltfError::MissingBlob);
+                }
+            }
+        }
+    }
+
+    Ok(buffer_data)
+}
+
+fn resolve_node_hierarchy(
+    nodes_intermediate: Vec<(String, GltfNode, Vec<usize>)>,
+) -> Vec<(String, GltfNode)> {
+    let mut max_steps = nodes_intermediate.len();
+    let mut nodes_step = nodes_intermediate
+        .into_iter()
+        .enumerate()
+        .map(|(i, (label, node, children))| (i, label, node, children))
+        .collect::<Vec<_>>();
+    let mut nodes = std::collections::HashMap::<usize, (String, GltfNode)>::new();
+    while max_steps > 0 && !nodes_step.is_empty() {
+        if let Some((index, label, node, _)) = nodes_step
+            .iter()
+            .find(|(_, _, _, children)| children.is_empty())
+            .cloned()
+        {
+            nodes.insert(index, (label, node));
+            for (_, _, node, children) in nodes_step.iter_mut() {
+                if let Some((i, _)) = children
+                    .iter()
+                    .enumerate()
+                    .find(|(_, child_index)| **child_index == index)
+                {
+                    children.remove(i);
+
+                    if let Some((_, child_node)) = nodes.get(&index) {
+                        node.children.push(child_node.clone())
+                    }
+                }
+            }
+            nodes_step = nodes_step
+                .into_iter()
+                .filter(|(i, _, _, _)| *i != index)
+                .collect()
+        }
+        max_steps -= 1;
+    }
+
+    let mut nodes_to_sort = nodes.into_iter().collect::<Vec<_>>();
+    nodes_to_sort.sort_by_key(|(i, _)| *i);
+    nodes_to_sort
+        .into_iter()
+        .map(|(_, resolved)| resolved)
+        .collect()
+}
+
+struct DataUri<'a> {
+    mime_type: &'a str,
+    base64: bool,
+    data: &'a str,
+}
+
+fn split_once(input: &str, delimiter: char) -> Option<(&str, &str)> {
+    let mut iter = input.splitn(2, delimiter);
+    Some((iter.next()?, iter.next()?))
+}
+
+impl<'a> DataUri<'a> {
+    fn parse(uri: &'a str) -> Result<DataUri<'a>, ()> {
+        let uri = uri.strip_prefix("data:").ok_or(())?;
+        let (mime_type, data) = split_once(uri, ',').ok_or(())?;
+
+        let (mime_type, base64) = match mime_type.strip_suffix(";base64") {
+            Some(mime_type) => (mime_type, true),
+            None => (mime_type, false),
+        };
+
+        Ok(DataUri {
+            mime_type,
+            base64,
+            data,
+        })
+    }
+
+    fn decode(&self) -> Result<Vec<u8>, base64::DecodeError> {
+        if self.base64 {
+            base64::decode(self.data)
+        } else {
+            Ok(self.data.as_bytes().to_owned())
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::resolve_node_hierarchy;
+    use crate::GltfNode;
+
+    impl GltfNode {
+        fn empty() -> Self {
+            GltfNode {
+                children: vec![],
+                mesh: None,
+                transform: bevy_transform::prelude::Transform::identity(),
+            }
+        }
+    }
+    #[test]
+    fn node_hierarchy_single_node() {
+        let result = resolve_node_hierarchy(vec![("l1".to_string(), GltfNode::empty(), vec![])]);
+
+        assert_eq!(result.len(), 1);
+        assert_eq!(result[0].0, "l1");
+        assert_eq!(result[0].1.children.len(), 0);
+    }
+
+    #[test]
+    fn node_hierarchy_no_hierarchy() {
+        let result = resolve_node_hierarchy(vec![
+            ("l1".to_string(), GltfNode::empty(), vec![]),
+            ("l2".to_string(), GltfNode::empty(), vec![]),
+        ]);
+
+        assert_eq!(result.len(), 2);
+        assert_eq!(result[0].0, "l1");
+        assert_eq!(result[0].1.children.len(), 0);
+        assert_eq!(result[1].0, "l2");
+        assert_eq!(result[1].1.children.len(), 0);
+    }
+
+    #[test]
+    fn node_hierarchy_simple_hierarchy() {
+        let result = resolve_node_hierarchy(vec![
+            ("l1".to_string(), GltfNode::empty(), vec![1]),
+            ("l2".to_string(), GltfNode::empty(), vec![]),
+        ]);
+
+        assert_eq!(result.len(), 2);
+        assert_eq!(result[0].0, "l1");
+        assert_eq!(result[0].1.children.len(), 1);
+        assert_eq!(result[1].0, "l2");
+        assert_eq!(result[1].1.children.len(), 0);
+    }
+
+    #[test]
+    fn node_hierarchy_hierarchy() {
+        let result = resolve_node_hierarchy(vec![
+            ("l1".to_string(), GltfNode::empty(), vec![1]),
+            ("l2".to_string(), GltfNode::empty(), vec![2]),
+            ("l3".to_string(), GltfNode::empty(), vec![3, 4, 5]),
+            ("l4".to_string(), GltfNode::empty(), vec![6]),
+            ("l5".to_string(), GltfNode::empty(), vec![]),
+            ("l6".to_string(), GltfNode::empty(), vec![]),
+            ("l7".to_string(), GltfNode::empty(), vec![]),
+        ]);
+
+        assert_eq!(result.len(), 7);
+        assert_eq!(result[0].0, "l1");
+        assert_eq!(result[0].1.children.len(), 1);
+        assert_eq!(result[1].0, "l2");
+        assert_eq!(result[1].1.children.len(), 1);
+        assert_eq!(result[2].0, "l3");
+        assert_eq!(result[2].1.children.len(), 3);
+        assert_eq!(result[3].0, "l4");
+        assert_eq!(result[3].1.children.len(), 1);
+        assert_eq!(result[4].0, "l5");
+        assert_eq!(result[4].1.children.len(), 0);
+        assert_eq!(result[5].0, "l6");
+        assert_eq!(result[5].1.children.len(), 0);
+        assert_eq!(result[6].0, "l7");
+        assert_eq!(result[6].1.children.len(), 0);
+    }
+
+    #[test]
+    fn node_hierarchy_cyclic() {
+        let result = resolve_node_hierarchy(vec![
+            ("l1".to_string(), GltfNode::empty(), vec![1]),
+            ("l2".to_string(), GltfNode::empty(), vec![0]),
+        ]);
+
+        assert_eq!(result.len(), 0);
+    }
+
+    #[test]
+    fn node_hierarchy_missing_node() {
+        let result = resolve_node_hierarchy(vec![
+            ("l1".to_string(), GltfNode::empty(), vec![2]),
+            ("l2".to_string(), GltfNode::empty(), vec![]),
+        ]);
+
+        assert_eq!(result.len(), 1);
+        assert_eq!(result[0].0, "l2");
+        assert_eq!(result[0].1.children.len(), 0);
+    }
+}
diff --git a/pipelined/bevy_pbr2/Cargo.toml b/pipelined/bevy_pbr2/Cargo.toml
new file mode 100644
index 0000000000..d4c238d6ee
--- /dev/null
+++ b/pipelined/bevy_pbr2/Cargo.toml
@@ -0,0 +1,33 @@
+[package]
+name = "bevy_pbr2"
+version = "0.5.0"
+edition = "2021"
+authors = [
+    "Bevy Contributors <bevyengine@gmail.com>",
+    "Carter Anderson <mcanders1@gmail.com>",
+]
+description = "Adds PBR rendering to Bevy Engine"
+homepage = "https://bevyengine.org"
+repository = "https://github.com/bevyengine/bevy"
+license = "MIT"
+keywords = ["bevy"]
+
+[dependencies]
+# bevy
+bevy_app = { path = "../../crates/bevy_app", version = "0.5.0" }
+bevy_asset = { path = "../../crates/bevy_asset", version = "0.5.0" }
+bevy_core = { path = "../../crates/bevy_core", version = "0.5.0" }
+bevy_core_pipeline = { path = "../bevy_core_pipeline", version = "0.5.0" }
+bevy_ecs = { path = "../../crates/bevy_ecs", version = "0.5.0" }
+bevy_math = { path = "../../crates/bevy_math", version = "0.5.0" }
+bevy_reflect = { path = "../../crates/bevy_reflect", version = "0.5.0", features = ["bevy"] }
+bevy_render2 = { path = "../bevy_render2", version = "0.5.0" }
+bevy_transform = { path = "../../crates/bevy_transform", version = "0.5.0" }
+bevy_utils = { path = "../../crates/bevy_utils", version = "0.5.0" }
+
+# other
+bitflags = "1.2"
+# direct dependency required for derive macro
+bytemuck = { version = "1", features = ["derive"] }
+crevice = { path = "../../crates/crevice", version = "0.8.0", features = ["glam"] }
+wgpu = { version = "0.11.0", features = ["spirv"] }
diff --git a/pipelined/bevy_pbr2/src/alpha.rs b/pipelined/bevy_pbr2/src/alpha.rs
new file mode 100644
index 0000000000..9af73fc764
--- /dev/null
+++ b/pipelined/bevy_pbr2/src/alpha.rs
@@ -0,0 +1,22 @@
+use bevy_ecs::{component::Component, reflect::ReflectComponent};
+use bevy_reflect::Reflect;
+
+// FIXME: This should probably be part of bevy_render2!
+/// Alpha mode
+#[derive(Component, Debug, Reflect, Copy, Clone, PartialEq)]
+#[reflect(Component)]
+pub enum AlphaMode {
+    Opaque,
+    /// An alpha cutoff must be supplied where alpha values >= the cutoff
+    /// will be fully opaque and < will be fully transparent
+    Mask(f32),
+    Blend,
+}
+
+impl Eq for AlphaMode {}
+
+impl Default for AlphaMode {
+    fn default() -> Self {
+        AlphaMode::Opaque
+    }
+}
diff --git a/pipelined/bevy_pbr2/src/bundle.rs b/pipelined/bevy_pbr2/src/bundle.rs
new file mode 100644
index 0000000000..5295033d1e
--- /dev/null
+++ b/pipelined/bevy_pbr2/src/bundle.rs
@@ -0,0 +1,78 @@
+use crate::{DirectionalLight, PointLight, StandardMaterial};
+use bevy_asset::Handle;
+use bevy_ecs::{bundle::Bundle, component::Component};
+use bevy_render2::{
+    mesh::Mesh,
+    primitives::{CubemapFrusta, Frustum},
+    view::{ComputedVisibility, Visibility, VisibleEntities},
+};
+use bevy_transform::components::{GlobalTransform, Transform};
+
+/// A component bundle for PBR entities with a [`Mesh`] and a [`StandardMaterial`].
+#[derive(Bundle, Clone)]
+pub struct PbrBundle {
+    pub mesh: Handle<Mesh>,
+    pub material: Handle<StandardMaterial>,
+    pub transform: Transform,
+    pub global_transform: GlobalTransform,
+    /// User indication of whether an entity is visible
+    pub visibility: Visibility,
+    /// Algorithmically-computed indication of whether an entity is visible and should be extracted for rendering
+    pub computed_visibility: ComputedVisibility,
+}
+
+impl Default for PbrBundle {
+    fn default() -> Self {
+        Self {
+            mesh: Default::default(),
+            material: Default::default(),
+            transform: Default::default(),
+            global_transform: Default::default(),
+            visibility: Default::default(),
+            computed_visibility: Default::default(),
+        }
+    }
+}
+
+#[derive(Component, Clone, Debug, Default)]
+pub struct CubemapVisibleEntities {
+    data: [VisibleEntities; 6],
+}
+
+impl CubemapVisibleEntities {
+    pub fn get(&self, i: usize) -> &VisibleEntities {
+        &self.data[i]
+    }
+
+    pub fn get_mut(&mut self, i: usize) -> &mut VisibleEntities {
+        &mut self.data[i]
+    }
+
+    pub fn iter(&self) -> impl DoubleEndedIterator<Item = &VisibleEntities> {
+        self.data.iter()
+    }
+
+    pub fn iter_mut(&mut self) -> impl DoubleEndedIterator<Item = &mut VisibleEntities> {
+        self.data.iter_mut()
+    }
+}
+
+/// A component bundle for [`PointLight`] entities.
+#[derive(Debug, Bundle, Default)]
+pub struct PointLightBundle {
+    pub point_light: PointLight,
+    pub cubemap_visible_entities: CubemapVisibleEntities,
+    pub cubemap_frusta: CubemapFrusta,
+    pub transform: Transform,
+    pub global_transform: GlobalTransform,
+}
+
+/// A component bundle for [`DirectionalLight`] entities.
+#[derive(Debug, Bundle, Default)]
+pub struct DirectionalLightBundle {
+    pub directional_light: DirectionalLight,
+    pub frustum: Frustum,
+    pub visible_entities: VisibleEntities,
+    pub transform: Transform,
+    pub global_transform: GlobalTransform,
+}
diff --git a/pipelined/bevy_pbr2/src/lib.rs b/pipelined/bevy_pbr2/src/lib.rs
new file mode 100644
index 0000000000..466345b086
--- /dev/null
+++ b/pipelined/bevy_pbr2/src/lib.rs
@@ -0,0 +1,142 @@
+mod alpha;
+mod bundle;
+mod light;
+mod material;
+mod render;
+
+pub use alpha::*;
+pub use bundle::*;
+pub use light::*;
+pub use material::*;
+pub use render::*;
+
+use bevy_app::prelude::*;
+use bevy_asset::{Assets, Handle, HandleUntyped};
+use bevy_core_pipeline::{AlphaMask3d, Opaque3d, Transparent3d};
+use bevy_ecs::prelude::*;
+use bevy_reflect::TypeUuid;
+use bevy_render2::{
+    render_component::ExtractComponentPlugin,
+    render_graph::RenderGraph,
+    render_phase::{sort_phase_system, AddRenderCommand, DrawFunctions},
+    render_resource::{Shader, SpecializedPipelines},
+    view::VisibilitySystems,
+    RenderApp, RenderStage,
+};
+use bevy_transform::TransformSystem;
+
+pub mod draw_3d_graph {
+    pub mod node {
+        /// Label for the shadow pass node.
+        pub const SHADOW_PASS: &str = "shadow_pass";
+    }
+}
+
+pub const PBR_SHADER_HANDLE: HandleUntyped =
+    HandleUntyped::weak_from_u64(Shader::TYPE_UUID, 4805239651767701046);
+pub const SHADOW_SHADER_HANDLE: HandleUntyped =
+    HandleUntyped::weak_from_u64(Shader::TYPE_UUID, 1836745567947005696);
+
+/// Sets up the entire PBR infrastructure of bevy.
+#[derive(Default)]
+pub struct PbrPlugin;
+
+impl Plugin for PbrPlugin {
+    fn build(&self, app: &mut App) {
+        let mut shaders = app.world.get_resource_mut::<Assets<Shader>>().unwrap();
+        shaders.set_untracked(
+            PBR_SHADER_HANDLE,
+            Shader::from_wgsl(include_str!("render/pbr.wgsl")),
+        );
+        shaders.set_untracked(
+            SHADOW_SHADER_HANDLE,
+            Shader::from_wgsl(include_str!("render/depth.wgsl")),
+        );
+
+        app.add_plugin(StandardMaterialPlugin)
+            .add_plugin(MeshRenderPlugin)
+            .add_plugin(ExtractComponentPlugin::<Handle<StandardMaterial>>::default())
+            .init_resource::<AmbientLight>()
+            .init_resource::<DirectionalLightShadowMap>()
+            .init_resource::<PointLightShadowMap>()
+            .init_resource::<AmbientLight>()
+            .add_system_to_stage(
+                CoreStage::PostUpdate,
+                update_directional_light_frusta
+                    .label(SimulationLightSystems::UpdateDirectionalLightFrusta)
+                    .after(TransformSystem::TransformPropagate),
+            )
+            .add_system_to_stage(
+                CoreStage::PostUpdate,
+                update_point_light_frusta
+                    .label(SimulationLightSystems::UpdatePointLightFrusta)
+                    .after(TransformSystem::TransformPropagate),
+            )
+            .add_system_to_stage(
+                CoreStage::PostUpdate,
+                check_light_visibility
+                    .label(SimulationLightSystems::CheckLightVisibility)
+                    .after(TransformSystem::TransformPropagate)
+                    .after(VisibilitySystems::CalculateBounds)
+                    .after(SimulationLightSystems::UpdateDirectionalLightFrusta)
+                    .after(SimulationLightSystems::UpdatePointLightFrusta)
+                    // NOTE: This MUST be scheduled AFTER the core renderer visibility check
+                    // because that resets entity ComputedVisibility for the first view
+                    // which would override any results from this otherwise
+                    .after(VisibilitySystems::CheckVisibility),
+            );
+
+        let render_app = app.sub_app(RenderApp);
+        render_app
+            .add_system_to_stage(
+                RenderStage::Extract,
+                render::extract_lights.label(RenderLightSystems::ExtractLights),
+            )
+            .add_system_to_stage(
+                RenderStage::Prepare,
+                // this is added as an exclusive system because it contributes new views. it must run (and have Commands applied)
+                // _before_ the `prepare_views()` system is run. ideally this becomes a normal system when "stageless" features come out
+                render::prepare_lights
+                    .exclusive_system()
+                    .label(RenderLightSystems::PrepareLights),
+            )
+            .add_system_to_stage(
+                RenderStage::Queue,
+                render::queue_shadows.label(RenderLightSystems::QueueShadows),
+            )
+            .add_system_to_stage(RenderStage::Queue, queue_meshes)
+            .add_system_to_stage(RenderStage::Queue, render::queue_shadow_view_bind_group)
+            .add_system_to_stage(RenderStage::PhaseSort, sort_phase_system::<Shadow>)
+            .init_resource::<PbrPipeline>()
+            .init_resource::<ShadowPipeline>()
+            .init_resource::<DrawFunctions<Shadow>>()
+            .init_resource::<LightMeta>()
+            .init_resource::<SpecializedPipelines<PbrPipeline>>()
+            .init_resource::<SpecializedPipelines<ShadowPipeline>>();
+
+        let shadow_pass_node = ShadowPassNode::new(&mut render_app.world);
+        render_app.add_render_command::<Opaque3d, DrawPbr>();
+        render_app.add_render_command::<AlphaMask3d, DrawPbr>();
+        render_app.add_render_command::<Transparent3d, DrawPbr>();
+        render_app.add_render_command::<Shadow, DrawShadowMesh>();
+        let mut graph = render_app.world.get_resource_mut::<RenderGraph>().unwrap();
+        let draw_3d_graph = graph
+            .get_sub_graph_mut(bevy_core_pipeline::draw_3d_graph::NAME)
+            .unwrap();
+        draw_3d_graph.add_node(draw_3d_graph::node::SHADOW_PASS, shadow_pass_node);
+        draw_3d_graph
+            .add_node_edge(
+                draw_3d_graph::node::SHADOW_PASS,
+                bevy_core_pipeline::draw_3d_graph::node::MAIN_PASS,
+            )
+            .unwrap();
+        draw_3d_graph
+            .add_slot_edge(
+                draw_3d_graph.input_node().unwrap().id,
+                bevy_core_pipeline::draw_3d_graph::input::VIEW_ENTITY,
+                draw_3d_graph::node::SHADOW_PASS,
+                ShadowPassNode::IN_VIEW,
+            )
+            .unwrap();
+    }
+}
diff --git a/pipelined/bevy_pbr2/src/light.rs b/pipelined/bevy_pbr2/src/light.rs
new file mode 100644
index 0000000000..9144306d99
--- /dev/null
+++ b/pipelined/bevy_pbr2/src/light.rs
@@ -0,0 +1,378 @@
+use bevy_ecs::prelude::*;
+use bevy_math::Mat4;
+use bevy_render2::{
+    camera::{CameraProjection, OrthographicProjection},
+    color::Color,
+    primitives::{Aabb, CubemapFrusta, Frustum, Sphere},
+    view::{ComputedVisibility, RenderLayers, Visibility, VisibleEntities, VisibleEntity},
+};
+use bevy_transform::components::GlobalTransform;
+
+use crate::{CubeMapFace, CubemapVisibleEntities, CUBE_MAP_FACES};
+
+/// A light that emits light in all directions from a central point.
+///
+/// Real-world values for `intensity` (luminous power in lumens) based on the electrical power
+/// consumption of the type of real-world light are:
+///
+/// | Luminous Power (lumen) (i.e. the intensity member) | Incandescent non-halogen (Watts) | Incandescent halogen (Watts) | Compact fluorescent (Watts) | LED (Watts |
+/// |------|-----|----|--------|-------|
+/// | 200  | 25  |    | 3-5    | 3     |
+/// | 450  | 40  | 29 | 9-11   | 5-8   |
+/// | 800  | 60  |    | 13-15  | 8-12  |
+/// | 1100 | 75  | 53 | 18-20  | 10-16 |
+/// | 1600 | 100 | 72 | 24-28  | 14-17 |
+/// | 2400 | 150 |    | 30-52  | 24-30 |
+/// | 3100 | 200 |    | 49-75  | 32    |
+/// | 4000 | 300 |    | 75-100 | 40.5  |
+///
+/// Source: [Wikipedia](https://en.wikipedia.org/wiki/Lumen_(unit)#Lighting)
+#[derive(Component, Debug, Clone, Copy)]
+pub struct PointLight {
+    pub color: Color,
+    pub intensity: f32,
+    pub range: f32,
+    pub radius: f32,
+    pub shadows_enabled: bool,
+    pub shadow_depth_bias: f32,
+    /// A bias applied along the direction of the fragment's surface normal. It is scaled to the
+    /// shadow map's texel size so that it can be small close to the camera and gets larger further
+    /// away.
+    pub shadow_normal_bias: f32,
+}
+
+impl Default for PointLight {
+    fn default() -> Self {
+        PointLight {
+            color: Color::rgb(1.0, 1.0, 1.0),
+            /// Luminous power in lumens
+            intensity: 800.0, // Roughly a 60W non-halogen incandescent bulb
+            range: 20.0,
+            radius: 0.0,
+            shadows_enabled: false,
+            shadow_depth_bias: Self::DEFAULT_SHADOW_DEPTH_BIAS,
+            shadow_normal_bias: Self::DEFAULT_SHADOW_NORMAL_BIAS,
+        }
+    }
+}
+
+impl PointLight {
+    pub const DEFAULT_SHADOW_DEPTH_BIAS: f32 = 0.02;
+    pub const DEFAULT_SHADOW_NORMAL_BIAS: f32 = 0.6;
+}
+
+#[derive(Clone, Debug)]
+pub struct PointLightShadowMap {
+    pub size: usize,
+}
+
+impl Default for PointLightShadowMap {
+    fn default() -> Self {
+        Self { size: 1024 }
+    }
+}
+
+/// A Directional light.
+///
+/// Directional lights don't exist in reality but they are a good
+/// approximation for light sources VERY far away, like the sun or
+/// the moon.
+///
+/// Valid values for `illuminance` are:
+///
+/// | Illuminance (lux) | Surfaces illuminated by                        |
+/// |-------------------|------------------------------------------------|
+/// | 0.0001            | Moonless, overcast night sky (starlight)       |
+/// | 0.002             | Moonless clear night sky with airglow          |
+/// | 0.05–0.3          | Full moon on a clear night                     |
+/// | 3.4               | Dark limit of civil twilight under a clear sky |
+/// | 20–50             | Public areas with dark surroundings            |
+/// | 50                | Family living room lights                      |
+/// | 80                | Office building hallway/toilet lighting        |
+/// | 100               | Very dark overcast day                         |
+/// | 150               | Train station platforms                        |
+/// | 320–500           | Office lighting                                |
+/// | 400               | Sunrise or sunset on a clear day.              |
+/// | 1000              | Overcast day; typical TV studio lighting       |
+/// | 10,000–25,000     | Full daylight (not direct sun)                 |
+/// | 32,000–100,000    | Direct sunlight                                |
+///
+/// Source: [Wikipedia](https://en.wikipedia.org/wiki/Lux)
+#[derive(Component, Debug, Clone)]
+pub struct DirectionalLight {
+    pub color: Color,
+    /// Illuminance in lux
+    pub illuminance: f32,
+    pub shadows_enabled: bool,
+    pub shadow_projection: OrthographicProjection,
+    pub shadow_depth_bias: f32,
+    /// A bias applied along the direction of the fragment's surface normal. It is scaled to the
+    /// shadow map's texel size so that it is automatically adjusted to the orthographic projection.
+    pub shadow_normal_bias: f32,
+}
+
+impl Default for DirectionalLight {
+    fn default() -> Self {
+        let size = 100.0;
+        DirectionalLight {
+            color: Color::rgb(1.0, 1.0, 1.0),
+            illuminance: 100000.0,
+            shadows_enabled: false,
+            shadow_projection: OrthographicProjection {
+                left: -size,
+                right: size,
+                bottom: -size,
+                top: size,
+                near: -size,
+                far: size,
+                ..Default::default()
+            },
+            shadow_depth_bias: Self::DEFAULT_SHADOW_DEPTH_BIAS,
+            shadow_normal_bias: Self::DEFAULT_SHADOW_NORMAL_BIAS,
+        }
+    }
+}
+
+impl DirectionalLight {
+    pub const DEFAULT_SHADOW_DEPTH_BIAS: f32 = 0.02;
+    pub const DEFAULT_SHADOW_NORMAL_BIAS: f32 = 0.6;
+}
+
+#[derive(Clone, Debug)]
+pub struct DirectionalLightShadowMap {
+    pub size: usize,
+}
+
+impl Default for DirectionalLightShadowMap {
+    fn default() -> Self {
+        Self { size: 4096 }
+    }
+}
+
+/// An ambient light, which lights the entire scene equally.
+#[derive(Debug)]
+pub struct AmbientLight {
+    pub color: Color,
+    /// A direct scale factor multiplied with `color` before being passed to the shader.
+    pub brightness: f32,
+}
+
+impl Default for AmbientLight {
+    fn default() -> Self {
+        Self {
+            color: Color::rgb(1.0, 1.0, 1.0),
+            brightness: 0.05,
+        }
+    }
+}
+
+/// Add this component to make a [`Mesh`](bevy_render2::mesh::Mesh) not cast shadows.
+#[derive(Component)]
+pub struct NotShadowCaster;
+/// Add this component to make a [`Mesh`](bevy_render2::mesh::Mesh) not receive shadows.
+#[derive(Component)]
+pub struct NotShadowReceiver;
+
+#[derive(Debug, Hash, PartialEq, Eq, Clone, SystemLabel)]
+pub enum SimulationLightSystems {
+    UpdateDirectionalLightFrusta,
+    UpdatePointLightFrusta,
+    CheckLightVisibility,
+}
+
+pub fn update_directional_light_frusta(
+    mut views: Query<(&GlobalTransform, &DirectionalLight, &mut Frustum)>,
+) {
+    for (transform, directional_light, mut frustum) in views.iter_mut() {
+        // The frustum is used for culling meshes to the light for shadow mapping
+        // so if shadow mapping is disabled for this light, then the frustum is
+        // not needed.
+        if !directional_light.shadows_enabled {
+            continue;
+        }
+
+        let view_projection = directional_light.shadow_projection.get_projection_matrix()
+            * transform.compute_matrix().inverse();
+        *frustum = Frustum::from_view_projection(
+            &view_projection,
+            &transform.translation,
+            &transform.back(),
+            directional_light.shadow_projection.far(),
+        );
+    }
+}
+
+pub fn update_point_light_frusta(
+    mut views: Query<(&GlobalTransform, &PointLight, &mut CubemapFrusta)>,
+) {
+    let projection = Mat4::perspective_infinite_reverse_rh(std::f32::consts::FRAC_PI_2, 1.0, 0.1);
+    let view_rotations = CUBE_MAP_FACES
+        .iter()
+        .map(|CubeMapFace { target, up }| GlobalTransform::identity().looking_at(*target, *up))
+        .collect::<Vec<_>>();
+
+    for (transform, point_light, mut cubemap_frusta) in views.iter_mut() {
+        // The frusta are used for culling meshes to the light for shadow mapping
+        // so if shadow mapping is disabled for this light, then the frusta are
+        // not needed.
+        if !point_light.shadows_enabled {
+            continue;
+        }
+
+        // ignore scale because we don't want to effectively scale light radius and range
+        // by applying those as a view transform to shadow map rendering of objects
+        // and ignore rotation because we want the shadow map projections to align with the axes
+        let view_translation = GlobalTransform::from_translation(transform.translation);
+        let view_backward = transform.back();
+
+        for (view_rotation, frustum) in view_rotations.iter().zip(cubemap_frusta.iter_mut()) {
+            let view = view_translation * *view_rotation;
+            let view_projection = projection * view.compute_matrix().inverse();
+
+            *frustum = Frustum::from_view_projection(
+                &view_projection,
+                &transform.translation,
+                &view_backward,
+                point_light.range,
+            );
+        }
+    }
+}
+
+pub fn check_light_visibility(
+    mut point_lights: Query<(
+        &PointLight,
+        &GlobalTransform,
+        &CubemapFrusta,
+        &mut CubemapVisibleEntities,
+        Option<&RenderLayers>,
+    )>,
+    mut directional_lights: Query<(
+        &DirectionalLight,
+        &Frustum,
+        &mut VisibleEntities,
+        Option<&RenderLayers>,
+    )>,
+    mut visible_entity_query: Query<
+        (
+            Entity,
+            &Visibility,
+            &mut ComputedVisibility,
+            Option<&RenderLayers>,
+            Option<&Aabb>,
+            Option<&GlobalTransform>,
+        ),
+        Without<NotShadowCaster>,
+    >,
+) {
+    // Directonal lights
+    for (directional_light, frustum, mut visible_entities, maybe_view_mask) in
+        directional_lights.iter_mut()
+    {
+        visible_entities.entities.clear();
+
+        // NOTE: If shadow mapping is disabled for the light then it must have no visible entities
+        if !directional_light.shadows_enabled {
+            continue;
+        }
+
+        let view_mask = maybe_view_mask.copied().unwrap_or_default();
+
+        for (
+            entity,
+            visibility,
+            mut computed_visibility,
+            maybe_entity_mask,
+            maybe_aabb,
+            maybe_transform,
+        ) in visible_entity_query.iter_mut()
+        {
+            if !visibility.is_visible {
+                continue;
+            }
+
+            let entity_mask = maybe_entity_mask.copied().unwrap_or_default();
+            if !view_mask.intersects(&entity_mask) {
+                continue;
+            }
+
+            // If we have an aabb and transform, do frustum culling
+            if let (Some(aabb), Some(transform)) = (maybe_aabb, maybe_transform) {
+                if !frustum.intersects_obb(aabb, &transform.compute_matrix()) {
+                    continue;
+                }
+            }
+
+            computed_visibility.is_visible = true;
+            visible_entities.entities.push(VisibleEntity { entity });
+        }
+
+        // TODO: check for big changes in visible entities len() vs capacity() (ex: 2x) and resize
+        // to prevent holding unneeded memory
+    }
+
+    // Point lights
+    for (point_light, transform, cubemap_frusta, mut cubemap_visible_entities, maybe_view_mask) in
+        point_lights.iter_mut()
+    {
+        for visible_entities in cubemap_visible_entities.iter_mut() {
+            visible_entities.entities.clear();
+        }
+
+        // NOTE: If shadow mapping is disabled for the light then it must have no visible entities
+        if !point_light.shadows_enabled {
+            continue;
+        }
+
+        let view_mask = maybe_view_mask.copied().unwrap_or_default();
+        let light_sphere = Sphere {
+            center: transform.translation,
+            radius: point_light.range,
+        };
+
+        for (
+            entity,
+            visibility,
+            mut computed_visibility,
+            maybe_entity_mask,
+            maybe_aabb,
+            maybe_transform,
+        ) in visible_entity_query.iter_mut()
+        {
+            if !visibility.is_visible {
+                continue;
+            }
+
+            let entity_mask = maybe_entity_mask.copied().unwrap_or_default();
+            if !view_mask.intersects(&entity_mask) {
+                continue;
+            }
+
+            // If we have an aabb and transform, do frustum culling
+            if let (Some(aabb), Some(transform)) = (maybe_aabb, maybe_transform) {
+                let model_to_world = transform.compute_matrix();
+                // Do a cheap sphere vs obb test to prune out most meshes outside the sphere of the light
+                if !light_sphere.intersects_obb(aabb, &model_to_world) {
+                    continue;
+                }
+                for (frustum, visible_entities) in cubemap_frusta
+                    .iter()
+                    .zip(cubemap_visible_entities.iter_mut())
+                {
+                    if frustum.intersects_obb(aabb, &model_to_world) {
+                        computed_visibility.is_visible = true;
+                        visible_entities.entities.push(VisibleEntity { entity });
+                    }
+                }
+            } else {
+                computed_visibility.is_visible = true;
+                for visible_entities in cubemap_visible_entities.iter_mut() {
+                    visible_entities.entities.push(VisibleEntity { entity })
+                }
+            }
+        }
+
+        // TODO: check for big changes in visible entities len() vs capacity() (ex: 2x) and resize
+        // to prevent holding unneeded memory
+    }
+}
diff --git a/pipelined/bevy_pbr2/src/material.rs b/pipelined/bevy_pbr2/src/material.rs
new file mode 100644
index 0000000000..c2b4c4f767
--- /dev/null
+++ b/pipelined/bevy_pbr2/src/material.rs
@@ -0,0 +1,316 @@
+use crate::{AlphaMode, PbrPipeline, StandardMaterialFlags};
+use bevy_app::{App, Plugin};
+use bevy_asset::{AddAsset, Handle};
+use bevy_ecs::system::{lifetimeless::SRes, SystemParamItem};
+use bevy_math::Vec4;
+use bevy_reflect::TypeUuid;
+use bevy_render2::{
+    color::Color,
+    render_asset::{PrepareAssetError, RenderAsset, RenderAssetPlugin, RenderAssets},
+    render_resource::{BindGroup, Buffer, BufferInitDescriptor, BufferUsages},
+    renderer::RenderDevice,
+    texture::Image,
+};
+use crevice::std140::{AsStd140, Std140};
+use wgpu::{BindGroupDescriptor, BindGroupEntry, BindingResource};
+
+/// A material with "standard" properties used in PBR lighting
+/// Standard property values with pictures here
+/// <https://google.github.io/filament/Material%20Properties.pdf>.
+///
+/// May be created directly from a [`Color`] or an [`Image`].
+#[derive(Debug, Clone, TypeUuid)]
+#[uuid = "7494888b-c082-457b-aacf-517228cc0c22"]
+pub struct StandardMaterial {
+    /// Doubles as diffuse albedo for non-metallic, specular for metallic and a mix for everything
+    /// in between. If used together with a base_color_texture, this is factored into the final
+    /// base color as `base_color * base_color_texture_value`
+    pub base_color: Color,
+    pub base_color_texture: Option<Handle<Image>>,
+    // Use a color for user friendliness even though we technically don't use the alpha channel
+    // Might be used in the future for exposure correction in HDR
+    pub emissive: Color,
+    pub emissive_texture: Option<Handle<Image>>,
+    /// Linear perceptual roughness, clamped to [0.089, 1.0] in the shader
+    /// Defaults to minimum of 0.089
+    /// If used together with a roughness/metallic texture, this is factored into the final base
+    /// color as `roughness * roughness_texture_value`
+    pub perceptual_roughness: f32,
+    /// From [0.0, 1.0], dielectric to pure metallic
+    /// If used together with a roughness/metallic texture, this is factored into the final base
+    /// color as `metallic * metallic_texture_value`
+    pub metallic: f32,
+    pub metallic_roughness_texture: Option<Handle<Image>>,
+    /// Specular intensity for non-metals on a linear scale of [0.0, 1.0]
+    /// defaults to 0.5 which is mapped to 4% reflectance in the shader
+    pub reflectance: f32,
+    pub normal_map_texture: Option<Handle<Image>>,
+    pub occlusion_texture: Option<Handle<Image>>,
+    pub double_sided: bool,
+    pub unlit: bool,
+    pub alpha_mode: AlphaMode,
+}
+
+impl Default for StandardMaterial {
+    fn default() -> Self {
+        StandardMaterial {
+            base_color: Color::rgb(1.0, 1.0, 1.0),
+            base_color_texture: None,
+            emissive: Color::BLACK,
+            emissive_texture: None,
+            // This is the minimum the roughness is clamped to in shader code
+            // See <https://google.github.io/filament/Filament.html#materialsystem/parameterization/>
+            // It's the minimum floating point value that won't be rounded down to 0 in the
+            // calculations used. Although technically for 32-bit floats, 0.045 could be
+            // used.
+            perceptual_roughness: 0.089,
+            // Few materials are purely dielectric or metallic
+            // This is just a default for mostly-dielectric
+            metallic: 0.01,
+            metallic_roughness_texture: None,
+            // Minimum real-world reflectance is 2%, most materials between 2-5%
+            // Expressed in a linear scale and equivalent to 4% reflectance see
+            // <https://google.github.io/filament/Material%20Properties.pdf>
+            reflectance: 0.5,
+            occlusion_texture: None,
+            normal_map_texture: None,
+            double_sided: false,
+            unlit: false,
+            alpha_mode: AlphaMode::Opaque,
+        }
+    }
+}
+
+impl From<Color> for StandardMaterial {
+    fn from(color: Color) -> Self {
+        StandardMaterial {
+            base_color: color,
+            ..Default::default()
+        }
+    }
+}
+
+impl From<Handle<Image>> for StandardMaterial {
+    fn from(texture: Handle<Image>) -> Self {
+        StandardMaterial {
+            base_color_texture: Some(texture),
+            ..Default::default()
+        }
+    }
+}
+
+/// The GPU representation of the uniform data of a [`StandardMaterial`].
+#[derive(Clone, Default, AsStd140)]
+pub struct StandardMaterialUniformData {
+    /// Doubles as diffuse albedo for non-metallic, specular for metallic and a mix for everything
+    /// in between.
+    pub base_color: Vec4,
+    // Use a color for user friendliness even though we technically don't use the alpha channel
+    // Might be used in the future for exposure correction in HDR
+    pub emissive: Vec4,
+    /// Linear perceptual roughness, clamped to [0.089, 1.0] in the shader
+    /// Defaults to minimum of 0.089
+    pub roughness: f32,
+    /// From [0.0, 1.0], dielectric to pure metallic
+    pub metallic: f32,
+    /// Specular intensity for non-metals on a linear scale of [0.0, 1.0]
+    /// defaults to 0.5 which is mapped to 4% reflectance in the shader
+    pub reflectance: f32,
+    pub flags: u32,
+    /// When the alpha mode mask flag is set, any base color alpha above this cutoff means fully opaque,
+    /// and any below means fully transparent.
+    pub alpha_cutoff: f32,
+}
+
+/// This plugin adds the [`StandardMaterial`] asset to the app.
+pub struct StandardMaterialPlugin;
+
+impl Plugin for StandardMaterialPlugin {
+    fn build(&self, app: &mut App) {
+        app.add_plugin(RenderAssetPlugin::<StandardMaterial>::default())
+            .add_asset::<StandardMaterial>();
+    }
+}
+
+/// The GPU representation of a [`StandardMaterial`].
+#[derive(Debug, Clone)]
+pub struct GpuStandardMaterial {
+    /// A buffer containing the [`StandardMaterialUniformData`] of the material.
+    pub buffer: Buffer,
+    /// The bind group specifying how the [`StandardMaterialUniformData`] and
+    /// all the textures of the material are bound.
+    pub bind_group: BindGroup,
+    pub has_normal_map: bool,
+    pub flags: StandardMaterialFlags,
+    pub base_color_texture: Option<Handle<Image>>,
+    pub alpha_mode: AlphaMode,
+}
+
+impl RenderAsset for StandardMaterial {
+    type ExtractedAsset = StandardMaterial;
+    type PreparedAsset = GpuStandardMaterial;
+    type Param = (
+        SRes<RenderDevice>,
+        SRes<PbrPipeline>,
+        SRes<RenderAssets<Image>>,
+    );
+
+    fn extract_asset(&self) -> Self::ExtractedAsset {
+        self.clone()
+    }
+
+    fn prepare_asset(
+        material: Self::ExtractedAsset,
+        (render_device, pbr_pipeline, gpu_images): &mut SystemParamItem<Self::Param>,
+    ) -> Result<Self::PreparedAsset, PrepareAssetError<Self::ExtractedAsset>> {
+        let (base_color_texture_view, base_color_sampler) = if let Some(result) = pbr_pipeline
+            .mesh_pipeline
+            .get_image_texture(gpu_images, &material.base_color_texture)
+        {
+            result
+        } else {
+            return Err(PrepareAssetError::RetryNextUpdate(material));
+        };
+
+        let (emissive_texture_view, emissive_sampler) = if let Some(result) = pbr_pipeline
+            .mesh_pipeline
+            .get_image_texture(gpu_images, &material.emissive_texture)
+        {
+            result
+        } else {
+            return Err(PrepareAssetError::RetryNextUpdate(material));
+        };
+
+        let (metallic_roughness_texture_view, metallic_roughness_sampler) = if let Some(result) =
+            pbr_pipeline
+                .mesh_pipeline
+                .get_image_texture(gpu_images, &material.metallic_roughness_texture)
+        {
+            result
+        } else {
+            return Err(PrepareAssetError::RetryNextUpdate(material));
+        };
+        let (normal_map_texture_view, normal_map_sampler) = if let Some(result) = pbr_pipeline
+            .mesh_pipeline
+            .get_image_texture(gpu_images, &material.normal_map_texture)
+        {
+            result
+        } else {
+            return Err(PrepareAssetError::RetryNextUpdate(material));
+        };
+        let (occlusion_texture_view, occlusion_sampler) = if let Some(result) = pbr_pipeline
+            .mesh_pipeline
+            .get_image_texture(gpu_images, &material.occlusion_texture)
+        {
+            result
+        } else {
+            return Err(PrepareAssetError::RetryNextUpdate(material));
+        };
+        let mut flags = StandardMaterialFlags::NONE;
+        if material.base_color_texture.is_some() {
+            flags |= StandardMaterialFlags::BASE_COLOR_TEXTURE;
+        }
+        if material.emissive_texture.is_some() {
+            flags |= StandardMaterialFlags::EMISSIVE_TEXTURE;
+        }
+        if material.metallic_roughness_texture.is_some() {
+            flags |= StandardMaterialFlags::METALLIC_ROUGHNESS_TEXTURE;
+        }
+        if material.occlusion_texture.is_some() {
+            flags |= StandardMaterialFlags::OCCLUSION_TEXTURE;
+        }
+        if material.double_sided {
+            flags |= StandardMaterialFlags::DOUBLE_SIDED;
+        }
+        if material.unlit {
+            flags |= StandardMaterialFlags::UNLIT;
+        }
+        let has_normal_map = material.normal_map_texture.is_some();
+        // NOTE: 0.5 is from the glTF default - do we want this?
+        let mut alpha_cutoff = 0.5;
+        match material.alpha_mode {
+            AlphaMode::Opaque => flags |= StandardMaterialFlags::ALPHA_MODE_OPAQUE,
+            AlphaMode::Mask(c) => {
+                alpha_cutoff = c;
+                flags |= StandardMaterialFlags::ALPHA_MODE_MASK
+            }
+            AlphaMode::Blend => flags |= StandardMaterialFlags::ALPHA_MODE_BLEND,
+        };
+
+        let value = StandardMaterialUniformData {
+            base_color: material.base_color.as_rgba_linear().into(),
+            emissive: material.emissive.into(),
+            roughness: material.perceptual_roughness,
+            metallic: material.metallic,
+            reflectance: material.reflectance,
+            flags: flags.bits(),
+            alpha_cutoff,
+        };
+        let value_std140 = value.as_std140();
+
+        let buffer = render_device.create_buffer_with_data(&BufferInitDescriptor {
+            label: Some("pbr_standard_material_uniform_buffer"),
+            usage: BufferUsages::UNIFORM | BufferUsages::COPY_DST,
+            contents: value_std140.as_bytes(),
+        });
+        let bind_group = render_device.create_bind_group(&BindGroupDescriptor {
+            entries: &[
+                BindGroupEntry {
+                    binding: 0,
+                    resource: buffer.as_entire_binding(),
+                },
+                BindGroupEntry {
+                    binding: 1,
+                    resource: BindingResource::TextureView(base_color_texture_view),
+                },
+                BindGroupEntry {
+                    binding: 2,
+                    resource: BindingResource::Sampler(base_color_sampler),
+                },
+                BindGroupEntry {
+                    binding: 3,
+                    resource: BindingResource::TextureView(emissive_texture_view),
+                },
+                BindGroupEntry {
+                    binding: 4,
+                    resource: BindingResource::Sampler(emissive_sampler),
+                },
+                BindGroupEntry {
+                    binding: 5,
+                    resource: BindingResource::TextureView(metallic_roughness_texture_view),
+                },
+                BindGroupEntry {
+                    binding: 6,
+                    resource: BindingResource::Sampler(metallic_roughness_sampler),
+                },
+                BindGroupEntry {
+                    binding: 7,
+                    resource: BindingResource::TextureView(occlusion_texture_view),
+                },
+                BindGroupEntry {
+                    binding: 8,
+                    resource: BindingResource::Sampler(occlusion_sampler),
+                },
+                BindGroupEntry {
+                    binding: 9,
+                    resource: BindingResource::TextureView(normal_map_texture_view),
+                },
+                BindGroupEntry {
+                    binding: 10,
+                    resource: BindingResource::Sampler(normal_map_sampler),
+                },
+            ],
+            label: Some("pbr_standard_material_bind_group"),
+            layout: &pbr_pipeline.material_layout,
+        });
+
+        Ok(GpuStandardMaterial {
+            buffer,
+            bind_group,
+            flags,
+            has_normal_map,
+            base_color_texture: material.base_color_texture,
+            alpha_mode: material.alpha_mode,
+        })
+    }
+}
diff --git a/pipelined/bevy_pbr2/src/render/depth.wgsl b/pipelined/bevy_pbr2/src/render/depth.wgsl
new file mode 100644
index 0000000000..7b983b31cc
--- /dev/null
+++ b/pipelined/bevy_pbr2/src/render/depth.wgsl
@@ -0,0 +1,29 @@
+#import bevy_pbr::mesh_struct
+
+// NOTE: Keep in sync with pbr.wgsl
+[[block]]
+struct View {
+    view_proj: mat4x4<f32>;
+    projection: mat4x4<f32>;
+    world_position: vec3<f32>;
+};
+[[group(0), binding(0)]]
+var<uniform> view: View;
+
+[[group(1), binding(0)]]
+var<uniform> mesh: Mesh;
+
+struct Vertex {
+    [[location(0)]] position: vec3<f32>;
+};
+
+struct VertexOutput {
+    [[builtin(position)]] clip_position: vec4<f32>;
+};
+
+[[stage(vertex)]]
+fn vertex(vertex: Vertex) -> VertexOutput {
+    var out: VertexOutput;
+    out.clip_position = view.view_proj * mesh.model * vec4<f32>(vertex.position, 1.0);
+    return out;
+}
diff --git a/pipelined/bevy_pbr2/src/render/light.rs b/pipelined/bevy_pbr2/src/render/light.rs
new file mode 100644
index 0000000000..a1a5f2673b
--- /dev/null
+++ b/pipelined/bevy_pbr2/src/render/light.rs
@@ -0,0 +1,973 @@
+use crate::{
+    AmbientLight, CubemapVisibleEntities, DirectionalLight, DirectionalLightShadowMap, DrawMesh,
+    MeshPipeline, NotShadowCaster, PointLight, PointLightShadowMap, SetMeshBindGroup,
+    SHADOW_SHADER_HANDLE,
+};
+use bevy_asset::Handle;
+use bevy_core::FloatOrd;
+use bevy_core_pipeline::Transparent3d;
+use bevy_ecs::{
+    prelude::*,
+    system::{lifetimeless::*, SystemParamItem},
+};
+use bevy_math::{const_vec3, Mat4, Vec3, Vec4};
+use bevy_render2::{
+    camera::CameraProjection,
+    color::Color,
+    mesh::Mesh,
+    render_asset::RenderAssets,
+    render_graph::{Node, NodeRunError, RenderGraphContext, SlotInfo, SlotType},
+    render_phase::{
+        CachedPipelinePhaseItem, DrawFunctionId, DrawFunctions, EntityPhaseItem,
+        EntityRenderCommand, PhaseItem, RenderCommandResult, RenderPhase, SetItemPipeline,
+        TrackedRenderPass,
+    },
+    render_resource::*,
+    renderer::{RenderContext, RenderDevice, RenderQueue},
+    texture::*,
+    view::{
+        ExtractedView, ViewUniform, ViewUniformOffset, ViewUniforms, VisibleEntities, VisibleEntity,
+    },
+};
+use bevy_transform::components::GlobalTransform;
+use crevice::std140::AsStd140;
+use std::num::NonZeroU32;
+
+#[derive(Debug, Hash, PartialEq, Eq, Clone, SystemLabel)]
+pub enum RenderLightSystems {
+    ExtractLights,
+    PrepareLights,
+    QueueShadows,
+}
+
+pub struct ExtractedAmbientLight {
+    color: Color,
+    brightness: f32,
+}
+
+#[derive(Component)]
+pub struct ExtractedPointLight {
+    color: Color,
+    /// luminous intensity in lumens per steradian
+    intensity: f32,
+    range: f32,
+    radius: f32,
+    transform: GlobalTransform,
+    shadows_enabled: bool,
+    shadow_depth_bias: f32,
+    shadow_normal_bias: f32,
+}
+
+pub type ExtractedPointLightShadowMap = PointLightShadowMap;
+
+#[derive(Component)]
+pub struct ExtractedDirectionalLight {
+    color: Color,
+    illuminance: f32,
+    direction: Vec3,
+    projection: Mat4,
+    shadows_enabled: bool,
+    shadow_depth_bias: f32,
+    shadow_normal_bias: f32,
+}
+
+pub type ExtractedDirectionalLightShadowMap = DirectionalLightShadowMap;
+
+#[repr(C)]
+#[derive(Copy, Clone, AsStd140, Default, Debug)]
+pub struct GpuPointLight {
+    projection: Mat4,
+    color: Vec4,
+    position: Vec3,
+    inverse_square_range: f32,
+    radius: f32,
+    near: f32,
+    far: f32,
+    flags: u32,
+    shadow_depth_bias: f32,
+    shadow_normal_bias: f32,
+}
+
+// NOTE: These must match the bit flags in bevy_pbr2/src/render/pbr.frag!
+bitflags::bitflags! {
+    #[repr(transparent)]
+    struct PointLightFlags: u32 {
+        const SHADOWS_ENABLED            = (1 << 0);
+        const NONE                       = 0;
+        const UNINITIALIZED              = 0xFFFF;
+    }
+}
+
+#[repr(C)]
+#[derive(Copy, Clone, AsStd140, Default, Debug)]
+pub struct GpuDirectionalLight {
+    view_projection: Mat4,
+    color: Vec4,
+    dir_to_light: Vec3,
+    flags: u32,
+    shadow_depth_bias: f32,
+    shadow_normal_bias: f32,
+}
+
+// NOTE: These must match the bit flags in bevy_pbr2/src/render/pbr.frag!
+bitflags::bitflags! {
+    #[repr(transparent)]
+    struct DirectionalLightFlags: u32 {
+        const SHADOWS_ENABLED            = (1 << 0);
+        const NONE                       = 0;
+        const UNINITIALIZED              = 0xFFFF;
+    }
+}
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, AsStd140)]
+pub struct GpuLights {
+    // TODO: this comes first to work around a WGSL alignment issue. We need to solve this issue before releasing the renderer rework
+    point_lights: [GpuPointLight; MAX_POINT_LIGHTS],
+    directional_lights: [GpuDirectionalLight; MAX_DIRECTIONAL_LIGHTS],
+    ambient_color: Vec4,
+    n_point_lights: u32,
+    n_directional_lights: u32,
+}
+
+// NOTE: this must be kept in sync with the same constants in pbr.frag
+pub const MAX_POINT_LIGHTS: usize = 10;
+pub const MAX_DIRECTIONAL_LIGHTS: usize = 1;
+pub const POINT_SHADOW_LAYERS: u32 = (6 * MAX_POINT_LIGHTS) as u32;
+pub const DIRECTIONAL_SHADOW_LAYERS: u32 = MAX_DIRECTIONAL_LIGHTS as u32;
+pub const SHADOW_FORMAT: TextureFormat = TextureFormat::Depth32Float;
+
+pub struct ShadowPipeline {
+    pub view_layout: BindGroupLayout,
+    pub mesh_layout: BindGroupLayout,
+    pub point_light_sampler: Sampler,
+    pub directional_light_sampler: Sampler,
+}
+
+// TODO: this pattern for initializing the shaders / pipeline isn't ideal. this should be handled by the asset system
+impl FromWorld for ShadowPipeline {
+    fn from_world(world: &mut World) -> Self {
+        let world = world.cell();
+        let render_device = world.get_resource::<RenderDevice>().unwrap();
+
+        let view_layout = render_device.create_bind_group_layout(&BindGroupLayoutDescriptor {
+            entries: &[
+                // View
+                BindGroupLayoutEntry {
+                    binding: 0,
+                    visibility: ShaderStages::VERTEX | ShaderStages::FRAGMENT,
+                    ty: BindingType::Buffer {
+                        ty: BufferBindingType::Uniform,
+                        has_dynamic_offset: true,
+                        min_binding_size: BufferSize::new(ViewUniform::std140_size_static() as u64),
+                    },
+                    count: None,
+                },
+            ],
+            label: Some("shadow_view_layout"),
+        });
+
+        let mesh_pipeline = world.get_resource::<MeshPipeline>().unwrap();
+
+        ShadowPipeline {
+            view_layout,
+            mesh_layout: mesh_pipeline.mesh_layout.clone(),
+            point_light_sampler: render_device.create_sampler(&SamplerDescriptor {
+                address_mode_u: AddressMode::ClampToEdge,
+                address_mode_v: AddressMode::ClampToEdge,
+                address_mode_w: AddressMode::ClampToEdge,
+                mag_filter: FilterMode::Linear,
+                min_filter: FilterMode::Linear,
+                mipmap_filter: FilterMode::Nearest,
+                compare: Some(CompareFunction::GreaterEqual),
+                ..Default::default()
+            }),
+            directional_light_sampler: render_device.create_sampler(&SamplerDescriptor {
+                address_mode_u: AddressMode::ClampToEdge,
+                address_mode_v: AddressMode::ClampToEdge,
+                address_mode_w: AddressMode::ClampToEdge,
+                mag_filter: FilterMode::Linear,
+                min_filter: FilterMode::Linear,
+                mipmap_filter: FilterMode::Nearest,
+                compare: Some(CompareFunction::GreaterEqual),
+                ..Default::default()
+            }),
+        }
+    }
+}
+
+bitflags::bitflags! {
+    #[repr(transparent)]
+    pub struct ShadowPipelineKey: u32 {
+        const NONE               = 0;
+        const VERTEX_TANGENTS    = (1 << 0);
+    }
+}
+
+impl SpecializedPipeline for ShadowPipeline {
+    type Key = ShadowPipelineKey;
+
+    fn specialize(&self, key: Self::Key) -> RenderPipelineDescriptor {
+        let (vertex_array_stride, vertex_attributes) =
+            if key.contains(ShadowPipelineKey::VERTEX_TANGENTS) {
+                (
+                    48,
+                    vec![
+                        // Position (GOTCHA! Vertex_Position isn't first in the buffer due to how Mesh sorts attributes (alphabetically))
+                        VertexAttribute {
+                            format: VertexFormat::Float32x3,
+                            offset: 12,
+                            shader_location: 0,
+                        },
+                        // Normal
+                        VertexAttribute {
+                            format: VertexFormat::Float32x3,
+                            offset: 0,
+                            shader_location: 1,
+                        },
+                        // Uv (GOTCHA! uv is no longer third in the buffer due to how Mesh sorts attributes (alphabetically))
+                        VertexAttribute {
+                            format: VertexFormat::Float32x2,
+                            offset: 40,
+                            shader_location: 2,
+                        },
+                        // Tangent
+                        VertexAttribute {
+                            format: VertexFormat::Float32x4,
+                            offset: 24,
+                            shader_location: 3,
+                        },
+                    ],
+                )
+            } else {
+                (
+                    32,
+                    vec![
+                        // Position (GOTCHA! Vertex_Position isn't first in the buffer due to how Mesh sorts attributes (alphabetically))
+                        VertexAttribute {
+                            format: VertexFormat::Float32x3,
+                            offset: 12,
+                            shader_location: 0,
+                        },
+                        // Normal
+                        VertexAttribute {
+                            format: VertexFormat::Float32x3,
+                            offset: 0,
+                            shader_location: 1,
+                        },
+                        // Uv
+                        VertexAttribute {
+                            format: VertexFormat::Float32x2,
+                            offset: 24,
+                            shader_location: 2,
+                        },
+                    ],
+                )
+            };
+        RenderPipelineDescriptor {
+            vertex: VertexState {
+                shader: SHADOW_SHADER_HANDLE.typed::<Shader>(),
+                entry_point: "vertex".into(),
+                shader_defs: vec![],
+                buffers: vec![VertexBufferLayout {
+                    array_stride: vertex_array_stride,
+                    step_mode: VertexStepMode::Vertex,
+                    attributes: vertex_attributes,
+                }],
+            },
+            fragment: None,
+            layout: Some(vec![self.view_layout.clone(), self.mesh_layout.clone()]),
+            primitive: PrimitiveState {
+                topology: PrimitiveTopology::TriangleList,
+                strip_index_format: None,
+                front_face: FrontFace::Ccw,
+                cull_mode: None,
+                polygon_mode: PolygonMode::Fill,
+                clamp_depth: false,
+                conservative: false,
+            },
+            depth_stencil: Some(DepthStencilState {
+                format: SHADOW_FORMAT,
+                depth_write_enabled: true,
+                depth_compare: CompareFunction::GreaterEqual,
+                stencil: StencilState {
+                    front: StencilFaceState::IGNORE,
+                    back: StencilFaceState::IGNORE,
+                    read_mask: 0,
+                    write_mask: 0,
+                },
+                bias: DepthBiasState {
+                    constant: 0,
+                    slope_scale: 0.0,
+                    clamp: 0.0,
+                },
+            }),
+            multisample: MultisampleState::default(),
+            label: Some("shadow_pipeline".into()),
+        }
+    }
+}
+
+pub fn extract_lights(
+    mut commands: Commands,
+    ambient_light: Res<AmbientLight>,
+    point_light_shadow_map: Res<PointLightShadowMap>,
+    directional_light_shadow_map: Res<DirectionalLightShadowMap>,
+    mut point_lights: Query<(
+        Entity,
+        &PointLight,
+        &mut CubemapVisibleEntities,
+        &GlobalTransform,
+    )>,
+    mut directional_lights: Query<(
+        Entity,
+        &DirectionalLight,
+        &mut VisibleEntities,
+        &GlobalTransform,
+    )>,
+) {
+    commands.insert_resource(ExtractedAmbientLight {
+        color: ambient_light.color,
+        brightness: ambient_light.brightness,
+    });
+    commands.insert_resource::<ExtractedPointLightShadowMap>(point_light_shadow_map.clone());
+    commands.insert_resource::<ExtractedDirectionalLightShadowMap>(
+        directional_light_shadow_map.clone(),
+    );
+    // This is the point light shadow map texel size for one face of the cube as a distance of 1.0
+    // world unit from the light.
+    // point_light_texel_size = 2.0 * 1.0 * tan(PI / 4.0) / cube face width in texels
+    // PI / 4.0 is half the cube face fov, tan(PI / 4.0) = 1.0, so this simplifies to:
+    // point_light_texel_size = 2.0 / cube face width in texels
+    // NOTE: When using various PCF kernel sizes, this will need to be adjusted, according to:
+    // https://catlikecoding.com/unity/tutorials/custom-srp/point-and-spot-shadows/
+    let point_light_texel_size = 2.0 / point_light_shadow_map.size as f32;
+    for (entity, point_light, cubemap_visible_entities, transform) in point_lights.iter_mut() {
+        let render_cubemap_visible_entities = std::mem::take(cubemap_visible_entities.into_inner());
+        commands.get_or_spawn(entity).insert_bundle((
+            ExtractedPointLight {
+                color: point_light.color,
+                // NOTE: Map from luminous power in lumens to luminous intensity in lumens per steradian
+                // for a point light. See https://google.github.io/filament/Filament.html#mjx-eqn-pointLightLuminousPower
+                // for details.
+                intensity: point_light.intensity / (4.0 * std::f32::consts::PI),
+                range: point_light.range,
+                radius: point_light.radius,
+                transform: *transform,
+                shadows_enabled: point_light.shadows_enabled,
+                shadow_depth_bias: point_light.shadow_depth_bias,
+                // The factor of SQRT_2 is for the worst-case diagonal offset
+                shadow_normal_bias: point_light.shadow_normal_bias
+                    * point_light_texel_size
+                    * std::f32::consts::SQRT_2,
+            },
+            render_cubemap_visible_entities,
+        ));
+    }
+    for (entity, directional_light, visible_entities, transform) in directional_lights.iter_mut() {
+        // Calulate the directional light shadow map texel size using the largest x,y dimension of
+        // the orthographic projection divided by the shadow map resolution
+        // NOTE: When using various PCF kernel sizes, this will need to be adjusted, according to:
+        // https://catlikecoding.com/unity/tutorials/custom-srp/directional-shadows/
+        let largest_dimension = (directional_light.shadow_projection.right
+            - directional_light.shadow_projection.left)
+            .max(
+                directional_light.shadow_projection.top
+                    - directional_light.shadow_projection.bottom,
+            );
+        let directional_light_texel_size =
+            largest_dimension / directional_light_shadow_map.size as f32;
+        let render_visible_entities = std::mem::take(visible_entities.into_inner());
+        commands.get_or_spawn(entity).insert_bundle((
+            ExtractedDirectionalLight {
+                color: directional_light.color,
+                illuminance: directional_light.illuminance,
+                direction: transform.forward(),
+                projection: directional_light.shadow_projection.get_projection_matrix(),
+                shadows_enabled: directional_light.shadows_enabled,
+                shadow_depth_bias: directional_light.shadow_depth_bias,
+                // The factor of SQRT_2 is for the worst-case diagonal offset
+                shadow_normal_bias: directional_light.shadow_normal_bias
+                    * directional_light_texel_size
+                    * std::f32::consts::SQRT_2,
+            },
+            render_visible_entities,
+        ));
+    }
+}
+
+// Can't do `Vec3::Y * -1.0` because mul isn't const
+const NEGATIVE_X: Vec3 = const_vec3!([-1.0, 0.0, 0.0]);
+const NEGATIVE_Y: Vec3 = const_vec3!([0.0, -1.0, 0.0]);
+const NEGATIVE_Z: Vec3 = const_vec3!([0.0, 0.0, -1.0]);
+
+pub(crate) struct CubeMapFace {
+    pub(crate) target: Vec3,
+    pub(crate) up: Vec3,
+}
+
+// see https://www.khronos.org/opengl/wiki/Cubemap_Texture
+pub(crate) const CUBE_MAP_FACES: [CubeMapFace; 6] = [
+    // 0 	GL_TEXTURE_CUBE_MAP_POSITIVE_X
+    CubeMapFace {
+        target: NEGATIVE_X,
+        up: NEGATIVE_Y,
+    },
+    // 1 	GL_TEXTURE_CUBE_MAP_NEGATIVE_X
+    CubeMapFace {
+        target: Vec3::X,
+        up: NEGATIVE_Y,
+    },
+    // 2 	GL_TEXTURE_CUBE_MAP_POSITIVE_Y
+    CubeMapFace {
+        target: NEGATIVE_Y,
+        up: Vec3::Z,
+    },
+    // 3 	GL_TEXTURE_CUBE_MAP_NEGATIVE_Y
+    CubeMapFace {
+        target: Vec3::Y,
+        up: NEGATIVE_Z,
+    },
+    // 4 	GL_TEXTURE_CUBE_MAP_POSITIVE_Z
+    CubeMapFace {
+        target: NEGATIVE_Z,
+        up: NEGATIVE_Y,
+    },
+    // 5 	GL_TEXTURE_CUBE_MAP_NEGATIVE_Z
+    CubeMapFace {
+        target: Vec3::Z,
+        up: NEGATIVE_Y,
+    },
+];
+
+fn face_index_to_name(face_index: usize) -> &'static str {
+    match face_index {
+        0 => "+x",
+        1 => "-x",
+        2 => "+y",
+        3 => "-y",
+        4 => "+z",
+        5 => "-z",
+        _ => "invalid",
+    }
+}
+
+#[derive(Component)]
+pub struct ShadowView {
+    pub depth_texture_view: TextureView,
+    pub pass_name: String,
+}
+
+#[derive(Component)]
+pub struct ViewShadowBindings {
+    pub point_light_depth_texture: Texture,
+    pub point_light_depth_texture_view: TextureView,
+    pub directional_light_depth_texture: Texture,
+    pub directional_light_depth_texture_view: TextureView,
+}
+
+#[derive(Component)]
+pub struct ViewLightEntities {
+    pub lights: Vec<Entity>,
+}
+
+#[derive(Component)]
+pub struct ViewLightsUniformOffset {
+    pub offset: u32,
+}
+
+#[derive(Default)]
+pub struct LightMeta {
+    pub view_gpu_lights: DynamicUniformVec<GpuLights>,
+    pub shadow_view_bind_group: Option<BindGroup>,
+}
+
+#[derive(Component)]
+pub enum LightEntity {
+    Directional {
+        light_entity: Entity,
+    },
+    Point {
+        light_entity: Entity,
+        face_index: usize,
+    },
+}
+
+#[allow(clippy::too_many_arguments)]
+pub fn prepare_lights(
+    mut commands: Commands,
+    mut texture_cache: ResMut<TextureCache>,
+    render_device: Res<RenderDevice>,
+    render_queue: Res<RenderQueue>,
+    mut light_meta: ResMut<LightMeta>,
+    views: Query<Entity, With<RenderPhase<Transparent3d>>>,
+    ambient_light: Res<ExtractedAmbientLight>,
+    point_light_shadow_map: Res<ExtractedPointLightShadowMap>,
+    directional_light_shadow_map: Res<ExtractedDirectionalLightShadowMap>,
+    point_lights: Query<(Entity, &ExtractedPointLight)>,
+    directional_lights: Query<(Entity, &ExtractedDirectionalLight)>,
+) {
+    light_meta.view_gpu_lights.clear();
+
+    let ambient_color = ambient_light.color.as_rgba_linear() * ambient_light.brightness;
+    // Pre-calculate for PointLights
+    let cube_face_projection =
+        Mat4::perspective_infinite_reverse_rh(std::f32::consts::FRAC_PI_2, 1.0, 0.1);
+    let cube_face_rotations = CUBE_MAP_FACES
+        .iter()
+        .map(|CubeMapFace { target, up }| GlobalTransform::identity().looking_at(*target, *up))
+        .collect::<Vec<_>>();
+
+    // set up light data for each view
+    for entity in views.iter() {
+        let point_light_depth_texture = texture_cache.get(
+            &render_device,
+            TextureDescriptor {
+                size: Extent3d {
+                    width: point_light_shadow_map.size as u32,
+                    height: point_light_shadow_map.size as u32,
+                    depth_or_array_layers: POINT_SHADOW_LAYERS,
+                },
+                mip_level_count: 1,
+                sample_count: 1,
+                dimension: TextureDimension::D2,
+                format: SHADOW_FORMAT,
+                label: Some("point_light_shadow_map_texture"),
+                usage: TextureUsages::RENDER_ATTACHMENT | TextureUsages::TEXTURE_BINDING,
+            },
+        );
+        let directional_light_depth_texture = texture_cache.get(
+            &render_device,
+            TextureDescriptor {
+                size: Extent3d {
+                    width: directional_light_shadow_map.size as u32,
+                    height: directional_light_shadow_map.size as u32,
+                    depth_or_array_layers: DIRECTIONAL_SHADOW_LAYERS,
+                },
+                mip_level_count: 1,
+                sample_count: 1,
+                dimension: TextureDimension::D2,
+                format: SHADOW_FORMAT,
+                label: Some("directional_light_shadow_map_texture"),
+                usage: TextureUsages::RENDER_ATTACHMENT | TextureUsages::TEXTURE_BINDING,
+            },
+        );
+        let mut view_lights = Vec::new();
+
+        let mut gpu_lights = GpuLights {
+            ambient_color: ambient_color.into(),
+            n_point_lights: point_lights.iter().len() as u32,
+            n_directional_lights: directional_lights.iter().len() as u32,
+            point_lights: [GpuPointLight::default(); MAX_POINT_LIGHTS],
+            directional_lights: [GpuDirectionalLight::default(); MAX_DIRECTIONAL_LIGHTS],
+        };
+
+        // TODO: this should select lights based on relevance to the view instead of the first ones that show up in a query
+        for (light_index, (light_entity, light)) in point_lights.iter().enumerate() {
+            // ignore scale because we don't want to effectively scale light radius and range
+            // by applying those as a view transform to shadow map rendering of objects
+            // and ignore rotation because we want the shadow map projections to align with the axes
+            let view_translation = GlobalTransform::from_translation(light.transform.translation);
+
+            if light.shadows_enabled {
+                for (face_index, view_rotation) in cube_face_rotations.iter().enumerate() {
+                    let depth_texture_view =
+                        point_light_depth_texture
+                            .texture
+                            .create_view(&TextureViewDescriptor {
+                                label: Some("point_light_shadow_map_texture_view"),
+                                format: None,
+                                dimension: Some(TextureViewDimension::D2),
+                                aspect: TextureAspect::All,
+                                base_mip_level: 0,
+                                mip_level_count: None,
+                                base_array_layer: (light_index * 6 + face_index) as u32,
+                                array_layer_count: NonZeroU32::new(1),
+                            });
+
+                    let view_light_entity = commands
+                        .spawn()
+                        .insert_bundle((
+                            ShadowView {
+                                depth_texture_view,
+                                pass_name: format!(
+                                    "shadow pass point light {} {}",
+                                    light_index,
+                                    face_index_to_name(face_index)
+                                ),
+                            },
+                            ExtractedView {
+                                width: point_light_shadow_map.size as u32,
+                                height: point_light_shadow_map.size as u32,
+                                transform: view_translation * *view_rotation,
+                                projection: cube_face_projection,
+                            },
+                            RenderPhase::<Shadow>::default(),
+                            LightEntity::Point {
+                                light_entity,
+                                face_index,
+                            },
+                        ))
+                        .id();
+                    view_lights.push(view_light_entity);
+                }
+            }
+
+            let mut flags = PointLightFlags::NONE;
+            if light.shadows_enabled {
+                flags |= PointLightFlags::SHADOWS_ENABLED;
+            }
+
+            gpu_lights.point_lights[light_index] = GpuPointLight {
+                projection: cube_face_projection,
+                // premultiply color by intensity
+                // we don't use the alpha at all, so no reason to multiply only [0..3]
+                color: (light.color.as_rgba_linear() * light.intensity).into(),
+                radius: light.radius,
+                position: light.transform.translation,
+                inverse_square_range: 1.0 / (light.range * light.range),
+                near: 0.1,
+                far: light.range,
+                flags: flags.bits,
+                shadow_depth_bias: light.shadow_depth_bias,
+                shadow_normal_bias: light.shadow_normal_bias,
+            };
+        }
+
+        for (i, (light_entity, light)) in directional_lights
+            .iter()
+            .enumerate()
+            .take(MAX_DIRECTIONAL_LIGHTS)
+        {
+            // direction is negated to be ready for N.L
+            let dir_to_light = -light.direction;
+
+            // convert from illuminance (lux) to candelas
+            //
+            // exposure is hard coded at the moment but should be replaced
+            // by values coming from the camera
+            // see: https://google.github.io/filament/Filament.html#imagingpipeline/physicallybasedcamera/exposuresettings
+            const APERTURE: f32 = 4.0;
+            const SHUTTER_SPEED: f32 = 1.0 / 250.0;
+            const SENSITIVITY: f32 = 100.0;
+            let ev100 =
+                f32::log2(APERTURE * APERTURE / SHUTTER_SPEED) - f32::log2(SENSITIVITY / 100.0);
+            let exposure = 1.0 / (f32::powf(2.0, ev100) * 1.2);
+            let intensity = light.illuminance * exposure;
+
+            // NOTE: A directional light seems to have to have an eye position on the line along the direction of the light
+            //       through the world origin. I (Rob Swain) do not yet understand why it cannot be translated away from this.
+            let view = Mat4::look_at_rh(Vec3::ZERO, light.direction, Vec3::Y);
+            // NOTE: This orthographic projection defines the volume within which shadows from a directional light can be cast
+            let projection = light.projection;
+
+            let mut flags = DirectionalLightFlags::NONE;
+            if light.shadows_enabled {
+                flags |= DirectionalLightFlags::SHADOWS_ENABLED;
+            }
+
+            gpu_lights.directional_lights[i] = GpuDirectionalLight {
+                // premultiply color by intensity
+                // we don't use the alpha at all, so no reason to multiply only [0..3]
+                color: (light.color.as_rgba_linear() * intensity).into(),
+                dir_to_light,
+                // NOTE: * view is correct, it should not be view.inverse() here
+                view_projection: projection * view,
+                flags: flags.bits,
+                shadow_depth_bias: light.shadow_depth_bias,
+                shadow_normal_bias: light.shadow_normal_bias,
+            };
+
+            if light.shadows_enabled {
+                let depth_texture_view =
+                    directional_light_depth_texture
+                        .texture
+                        .create_view(&TextureViewDescriptor {
+                            label: Some("directional_light_shadow_map_texture_view"),
+                            format: None,
+                            dimension: Some(TextureViewDimension::D2),
+                            aspect: TextureAspect::All,
+                            base_mip_level: 0,
+                            mip_level_count: None,
+                            base_array_layer: i as u32,
+                            array_layer_count: NonZeroU32::new(1),
+                        });
+
+                let view_light_entity = commands
+                    .spawn()
+                    .insert_bundle((
+                        ShadowView {
+                            depth_texture_view,
+                            pass_name: format!("shadow pass directional light {}", i),
+                        },
+                        ExtractedView {
+                            width: directional_light_shadow_map.size as u32,
+                            height: directional_light_shadow_map.size as u32,
+                            transform: GlobalTransform::from_matrix(view.inverse()),
+                            projection,
+                        },
+                        RenderPhase::<Shadow>::default(),
+                        LightEntity::Directional { light_entity },
+                    ))
+                    .id();
+                view_lights.push(view_light_entity);
+            }
+        }
+        let point_light_depth_texture_view =
+            point_light_depth_texture
+                .texture
+                .create_view(&TextureViewDescriptor {
+                    label: Some("point_light_shadow_map_array_texture_view"),
+                    format: None,
+                    dimension: Some(TextureViewDimension::CubeArray),
+                    aspect: TextureAspect::All,
+                    base_mip_level: 0,
+                    mip_level_count: None,
+                    base_array_layer: 0,
+                    array_layer_count: None,
+                });
+        let directional_light_depth_texture_view = directional_light_depth_texture
+            .texture
+            .create_view(&TextureViewDescriptor {
+                label: Some("directional_light_shadow_map_array_texture_view"),
+                format: None,
+                dimension: Some(TextureViewDimension::D2Array),
+                aspect: TextureAspect::All,
+                base_mip_level: 0,
+                mip_level_count: None,
+                base_array_layer: 0,
+                array_layer_count: None,
+            });
+
+        commands.entity(entity).insert_bundle((
+            ViewShadowBindings {
+                point_light_depth_texture: point_light_depth_texture.texture,
+                point_light_depth_texture_view,
+                directional_light_depth_texture: directional_light_depth_texture.texture,
+                directional_light_depth_texture_view,
+            },
+            ViewLightEntities {
+                lights: view_lights,
+            },
+            ViewLightsUniformOffset {
+                offset: light_meta.view_gpu_lights.push(gpu_lights),
+            },
+        ));
+    }
+
+    light_meta
+        .view_gpu_lights
+        .write_buffer(&render_device, &render_queue);
+}
+
+pub fn queue_shadow_view_bind_group(
+    render_device: Res<RenderDevice>,
+    shadow_pipeline: Res<ShadowPipeline>,
+    mut light_meta: ResMut<LightMeta>,
+    view_uniforms: Res<ViewUniforms>,
+) {
+    if let Some(view_binding) = view_uniforms.uniforms.binding() {
+        light_meta.shadow_view_bind_group =
+            Some(render_device.create_bind_group(&BindGroupDescriptor {
+                entries: &[BindGroupEntry {
+                    binding: 0,
+                    resource: view_binding,
+                }],
+                label: Some("shadow_view_bind_group"),
+                layout: &shadow_pipeline.view_layout,
+            }));
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+pub fn queue_shadows(
+    shadow_draw_functions: Res<DrawFunctions<Shadow>>,
+    shadow_pipeline: Res<ShadowPipeline>,
+    casting_meshes: Query<&Handle<Mesh>, Without<NotShadowCaster>>,
+    render_meshes: Res<RenderAssets<Mesh>>,
+    mut pipelines: ResMut<SpecializedPipelines<ShadowPipeline>>,
+    mut pipeline_cache: ResMut<RenderPipelineCache>,
+    view_lights: Query<&ViewLightEntities>,
+    mut view_light_shadow_phases: Query<(&LightEntity, &mut RenderPhase<Shadow>)>,
+    point_light_entities: Query<&CubemapVisibleEntities, With<ExtractedPointLight>>,
+    directional_light_entities: Query<&VisibleEntities, With<ExtractedDirectionalLight>>,
+) {
+    for view_lights in view_lights.iter() {
+        let draw_shadow_mesh = shadow_draw_functions
+            .read()
+            .get_id::<DrawShadowMesh>()
+            .unwrap();
+        for view_light_entity in view_lights.lights.iter().copied() {
+            let (light_entity, mut shadow_phase) =
+                view_light_shadow_phases.get_mut(view_light_entity).unwrap();
+            let visible_entities = match light_entity {
+                LightEntity::Directional { light_entity } => directional_light_entities
+                    .get(*light_entity)
+                    .expect("Failed to get directional light visible entities"),
+                LightEntity::Point {
+                    light_entity,
+                    face_index,
+                } => point_light_entities
+                    .get(*light_entity)
+                    .expect("Failed to get point light visible entities")
+                    .get(*face_index),
+            };
+            // NOTE: Lights with shadow mapping disabled will have no visible entities
+            //       so no meshes will be queued
+            for VisibleEntity { entity, .. } in visible_entities.iter() {
+                let mut key = ShadowPipelineKey::empty();
+                if let Ok(mesh_handle) = casting_meshes.get(*entity) {
+                    if let Some(mesh) = render_meshes.get(mesh_handle) {
+                        if mesh.has_tangents {
+                            key |= ShadowPipelineKey::VERTEX_TANGENTS;
+                        }
+                    }
+                    let pipeline_id =
+                        pipelines.specialize(&mut pipeline_cache, &shadow_pipeline, key);
+
+                    shadow_phase.add(Shadow {
+                        draw_function: draw_shadow_mesh,
+                        pipeline: pipeline_id,
+                        entity: *entity,
+                        distance: 0.0, // TODO: sort back-to-front
+                    });
+                }
+            }
+        }
+    }
+}
+
+pub struct Shadow {
+    pub distance: f32,
+    pub entity: Entity,
+    pub pipeline: CachedPipelineId,
+    pub draw_function: DrawFunctionId,
+}
+
+impl PhaseItem for Shadow {
+    type SortKey = FloatOrd;
+
+    #[inline]
+    fn sort_key(&self) -> Self::SortKey {
+        FloatOrd(self.distance)
+    }
+
+    #[inline]
+    fn draw_function(&self) -> DrawFunctionId {
+        self.draw_function
+    }
+}
+
+impl EntityPhaseItem for Shadow {
+    fn entity(&self) -> Entity {
+        self.entity
+    }
+}
+
+impl CachedPipelinePhaseItem for Shadow {
+    #[inline]
+    fn cached_pipeline(&self) -> CachedPipelineId {
+        self.pipeline
+    }
+}
+
+pub struct ShadowPassNode {
+    main_view_query: QueryState<&'static ViewLightEntities>,
+    view_light_query: QueryState<(&'static ShadowView, &'static RenderPhase<Shadow>)>,
+}
+
+impl ShadowPassNode {
+    pub const IN_VIEW: &'static str = "view";
+
+    pub fn new(world: &mut World) -> Self {
+        Self {
+            main_view_query: QueryState::new(world),
+            view_light_query: QueryState::new(world),
+        }
+    }
+}
+
+impl Node for ShadowPassNode {
+    fn input(&self) -> Vec<SlotInfo> {
+        vec![SlotInfo::new(ShadowPassNode::IN_VIEW, SlotType::Entity)]
+    }
+
+    fn update(&mut self, world: &mut World) {
+        self.main_view_query.update_archetypes(world);
+        self.view_light_query.update_archetypes(world);
+    }
+
+    fn run(
+        &self,
+        graph: &mut RenderGraphContext,
+        render_context: &mut RenderContext,
+        world: &World,
+    ) -> Result<(), NodeRunError> {
+        let view_entity = graph.get_input_entity(Self::IN_VIEW)?;
+        if let Ok(view_lights) = self.main_view_query.get_manual(world, view_entity) {
+            for view_light_entity in view_lights.lights.iter().copied() {
+                let (view_light, shadow_phase) = self
+                    .view_light_query
+                    .get_manual(world, view_light_entity)
+                    .unwrap();
+                let pass_descriptor = RenderPassDescriptor {
+                    label: Some(&view_light.pass_name),
+                    color_attachments: &[],
+                    depth_stencil_attachment: Some(RenderPassDepthStencilAttachment {
+                        view: &view_light.depth_texture_view,
+                        depth_ops: Some(Operations {
+                            load: LoadOp::Clear(0.0),
+                            store: true,
+                        }),
+                        stencil_ops: None,
+                    }),
+                };
+
+                let draw_functions = world.get_resource::<DrawFunctions<Shadow>>().unwrap();
+                let render_pass = render_context
+                    .command_encoder
+                    .begin_render_pass(&pass_descriptor);
+                let mut draw_functions = draw_functions.write();
+                let mut tracked_pass = TrackedRenderPass::new(render_pass);
+                for item in shadow_phase.items.iter() {
+                    let draw_function = draw_functions.get_mut(item.draw_function).unwrap();
+                    draw_function.draw(world, &mut tracked_pass, view_light_entity, item);
+                }
+            }
+        }
+
+        Ok(())
+    }
+}
+
+pub type DrawShadowMesh = (
+    SetItemPipeline,
+    SetShadowViewBindGroup<0>,
+    SetMeshBindGroup<1>,
+    DrawMesh,
+);
+
+pub struct SetShadowViewBindGroup<const I: usize>;
+impl<const I: usize> EntityRenderCommand for SetShadowViewBindGroup<I> {
+    type Param = (SRes<LightMeta>, SQuery<Read<ViewUniformOffset>>);
+    #[inline]
+    fn render<'w>(
+        view: Entity,
+        _item: Entity,
+        (light_meta, view_query): SystemParamItem<'w, '_, Self::Param>,
+        pass: &mut TrackedRenderPass<'w>,
+    ) -> RenderCommandResult {
+        let view_uniform_offset = view_query.get(view).unwrap();
+        pass.set_bind_group(
+            I,
+            light_meta
+                .into_inner()
+                .shadow_view_bind_group
+                .as_ref()
+                .unwrap(),
+            &[view_uniform_offset.offset],
+        );
+
+        RenderCommandResult::Success
+    }
+}
diff --git a/pipelined/bevy_pbr2/src/render/mesh.rs b/pipelined/bevy_pbr2/src/render/mesh.rs
new file mode 100644
index 0000000000..567745f919
--- /dev/null
+++ b/pipelined/bevy_pbr2/src/render/mesh.rs
@@ -0,0 +1,656 @@
+use crate::{
+    GpuLights, LightMeta, NotShadowCaster, NotShadowReceiver, ShadowPipeline,
+    ViewLightsUniformOffset, ViewShadowBindings,
+};
+use bevy_app::Plugin;
+use bevy_asset::{Assets, Handle, HandleUntyped};
+use bevy_ecs::{
+    prelude::*,
+    system::{lifetimeless::*, SystemParamItem},
+};
+use bevy_math::Mat4;
+use bevy_reflect::TypeUuid;
+use bevy_render2::{
+    mesh::Mesh,
+    render_asset::RenderAssets,
+    render_component::{ComponentUniforms, DynamicUniformIndex, UniformComponentPlugin},
+    render_phase::{EntityRenderCommand, RenderCommandResult, TrackedRenderPass},
+    render_resource::*,
+    renderer::{RenderDevice, RenderQueue},
+    texture::{BevyDefault, GpuImage, Image, TextureFormatPixelInfo},
+    view::{ComputedVisibility, ViewUniform, ViewUniformOffset, ViewUniforms},
+    RenderApp, RenderStage,
+};
+use bevy_transform::components::GlobalTransform;
+use crevice::std140::AsStd140;
+use wgpu::{
+    Extent3d, ImageCopyTexture, ImageDataLayout, Origin3d, TextureDimension, TextureFormat,
+    TextureViewDescriptor,
+};
+
+#[derive(Default)]
+pub struct MeshRenderPlugin;
+
+pub const MESH_VIEW_BIND_GROUP_HANDLE: HandleUntyped =
+    HandleUntyped::weak_from_u64(Shader::TYPE_UUID, 9076678235888822571);
+pub const MESH_STRUCT_HANDLE: HandleUntyped =
+    HandleUntyped::weak_from_u64(Shader::TYPE_UUID, 2506024101911992377);
+pub const MESH_SHADER_HANDLE: HandleUntyped =
+    HandleUntyped::weak_from_u64(Shader::TYPE_UUID, 3252377289100772450);
+
+impl Plugin for MeshRenderPlugin {
+    fn build(&self, app: &mut bevy_app::App) {
+        let mut shaders = app.world.get_resource_mut::<Assets<Shader>>().unwrap();
+        shaders.set_untracked(
+            MESH_SHADER_HANDLE,
+            Shader::from_wgsl(include_str!("mesh.wgsl")),
+        );
+        shaders.set_untracked(
+            MESH_STRUCT_HANDLE,
+            Shader::from_wgsl(include_str!("mesh_struct.wgsl"))
+                .with_import_path("bevy_pbr::mesh_struct"),
+        );
+        shaders.set_untracked(
+            MESH_VIEW_BIND_GROUP_HANDLE,
+            Shader::from_wgsl(include_str!("mesh_view_bind_group.wgsl"))
+                .with_import_path("bevy_pbr::mesh_view_bind_group"),
+        );
+
+        app.add_plugin(UniformComponentPlugin::<MeshUniform>::default());
+
+        app.sub_app(RenderApp)
+            .init_resource::<MeshPipeline>()
+            .add_system_to_stage(RenderStage::Extract, extract_meshes)
+            .add_system_to_stage(RenderStage::Queue, queue_mesh_bind_group)
+            .add_system_to_stage(RenderStage::Queue, queue_mesh_view_bind_groups);
+    }
+}
+
+#[derive(Component, AsStd140, Clone)]
+pub struct MeshUniform {
+    pub transform: Mat4,
+    pub inverse_transpose_model: Mat4,
+    pub flags: u32,
+}
+
+// NOTE: These must match the bit flags in bevy_pbr2/src/render/mesh.wgsl!
+bitflags::bitflags! {
+    #[repr(transparent)]
+    struct MeshFlags: u32 {
+        const SHADOW_RECEIVER            = (1 << 0);
+        const NONE                       = 0;
+        const UNINITIALIZED              = 0xFFFF;
+    }
+}
+
+pub fn extract_meshes(
+    mut commands: Commands,
+    mut previous_caster_len: Local<usize>,
+    mut previous_not_caster_len: Local<usize>,
+    caster_query: Query<
+        (
+            Entity,
+            &ComputedVisibility,
+            &GlobalTransform,
+            &Handle<Mesh>,
+            Option<&NotShadowReceiver>,
+        ),
+        Without<NotShadowCaster>,
+    >,
+    not_caster_query: Query<
+        (
+            Entity,
+            &ComputedVisibility,
+            &GlobalTransform,
+            &Handle<Mesh>,
+            Option<&NotShadowReceiver>,
+        ),
+        With<NotShadowCaster>,
+    >,
+) {
+    let mut caster_values = Vec::with_capacity(*previous_caster_len);
+    for (entity, computed_visibility, transform, handle, not_receiver) in caster_query.iter() {
+        if !computed_visibility.is_visible {
+            continue;
+        }
+        let transform = transform.compute_matrix();
+        caster_values.push((
+            entity,
+            (
+                handle.clone_weak(),
+                MeshUniform {
+                    flags: if not_receiver.is_some() {
+                        MeshFlags::empty().bits
+                    } else {
+                        MeshFlags::SHADOW_RECEIVER.bits
+                    },
+                    transform,
+                    inverse_transpose_model: transform.inverse().transpose(),
+                },
+            ),
+        ));
+    }
+    *previous_caster_len = caster_values.len();
+    commands.insert_or_spawn_batch(caster_values);
+
+    let mut not_caster_values = Vec::with_capacity(*previous_not_caster_len);
+    for (entity, computed_visibility, transform, handle, not_receiver) in not_caster_query.iter() {
+        if !computed_visibility.is_visible {
+            continue;
+        }
+        let transform = transform.compute_matrix();
+        not_caster_values.push((
+            entity,
+            (
+                handle.clone_weak(),
+                MeshUniform {
+                    flags: if not_receiver.is_some() {
+                        MeshFlags::empty().bits
+                    } else {
+                        MeshFlags::SHADOW_RECEIVER.bits
+                    },
+                    transform,
+                    inverse_transpose_model: transform.inverse().transpose(),
+                },
+                NotShadowCaster,
+            ),
+        ));
+    }
+    *previous_not_caster_len = not_caster_values.len();
+    commands.insert_or_spawn_batch(not_caster_values);
+}
+
+#[derive(Clone)]
+pub struct MeshPipeline {
+    pub view_layout: BindGroupLayout,
+    pub mesh_layout: BindGroupLayout,
+    // This dummy white texture is to be used in place of optional StandardMaterial textures
+    pub dummy_white_gpu_image: GpuImage,
+}
+
+impl FromWorld for MeshPipeline {
+    fn from_world(world: &mut World) -> Self {
+        let render_device = world.get_resource::<RenderDevice>().unwrap();
+        let view_layout = render_device.create_bind_group_layout(&BindGroupLayoutDescriptor {
+            entries: &[
+                // View
+                BindGroupLayoutEntry {
+                    binding: 0,
+                    visibility: ShaderStages::VERTEX | ShaderStages::FRAGMENT,
+                    ty: BindingType::Buffer {
+                        ty: BufferBindingType::Uniform,
+                        has_dynamic_offset: true,
+                        min_binding_size: BufferSize::new(ViewUniform::std140_size_static() as u64),
+                    },
+                    count: None,
+                },
+                // Lights
+                BindGroupLayoutEntry {
+                    binding: 1,
+                    visibility: ShaderStages::FRAGMENT,
+                    ty: BindingType::Buffer {
+                        ty: BufferBindingType::Uniform,
+                        has_dynamic_offset: true,
+                        min_binding_size: BufferSize::new(GpuLights::std140_size_static() as u64),
+                    },
+                    count: None,
+                },
+                // Point Shadow Texture Cube Array
+                BindGroupLayoutEntry {
+                    binding: 2,
+                    visibility: ShaderStages::FRAGMENT,
+                    ty: BindingType::Texture {
+                        multisampled: false,
+                        sample_type: TextureSampleType::Depth,
+                        view_dimension: TextureViewDimension::CubeArray,
+                    },
+                    count: None,
+                },
+                // Point Shadow Texture Array Sampler
+                BindGroupLayoutEntry {
+                    binding: 3,
+                    visibility: ShaderStages::FRAGMENT,
+                    ty: BindingType::Sampler {
+                        comparison: true,
+                        filtering: true,
+                    },
+                    count: None,
+                },
+                // Directional Shadow Texture Array
+                BindGroupLayoutEntry {
+                    binding: 4,
+                    visibility: ShaderStages::FRAGMENT,
+                    ty: BindingType::Texture {
+                        multisampled: false,
+                        sample_type: TextureSampleType::Depth,
+                        view_dimension: TextureViewDimension::D2Array,
+                    },
+                    count: None,
+                },
+                // Directional Shadow Texture Array Sampler
+                BindGroupLayoutEntry {
+                    binding: 5,
+                    visibility: ShaderStages::FRAGMENT,
+                    ty: BindingType::Sampler {
+                        comparison: true,
+                        filtering: true,
+                    },
+                    count: None,
+                },
+            ],
+            label: Some("mesh_view_layout"),
+        });
+
+        let mesh_layout = render_device.create_bind_group_layout(&BindGroupLayoutDescriptor {
+            entries: &[BindGroupLayoutEntry {
+                binding: 0,
+                visibility: ShaderStages::VERTEX | ShaderStages::FRAGMENT,
+                ty: BindingType::Buffer {
+                    ty: BufferBindingType::Uniform,
+                    has_dynamic_offset: true,
+                    min_binding_size: BufferSize::new(MeshUniform::std140_size_static() as u64),
+                },
+                count: None,
+            }],
+            label: Some("mesh_layout"),
+        });
+        // A 1x1x1 'all 1.0' texture to use as a dummy texture to use in place of optional StandardMaterial textures
+        let dummy_white_gpu_image = {
+            let image = Image::new_fill(
+                Extent3d::default(),
+                TextureDimension::D2,
+                &[255u8; 4],
+                TextureFormat::bevy_default(),
+            );
+            let texture = render_device.create_texture(&image.texture_descriptor);
+            let sampler = render_device.create_sampler(&image.sampler_descriptor);
+
+            let format_size = image.texture_descriptor.format.pixel_size();
+            let render_queue = world.get_resource_mut::<RenderQueue>().unwrap();
+            render_queue.write_texture(
+                ImageCopyTexture {
+                    texture: &texture,
+                    mip_level: 0,
+                    origin: Origin3d::ZERO,
+                    aspect: wgpu::TextureAspect::All,
+                },
+                &image.data,
+                ImageDataLayout {
+                    offset: 0,
+                    bytes_per_row: Some(
+                        std::num::NonZeroU32::new(
+                            image.texture_descriptor.size.width * format_size as u32,
+                        )
+                        .unwrap(),
+                    ),
+                    rows_per_image: None,
+                },
+                image.texture_descriptor.size,
+            );
+
+            let texture_view = texture.create_view(&TextureViewDescriptor::default());
+            GpuImage {
+                texture,
+                texture_view,
+                sampler,
+            }
+        };
+        MeshPipeline {
+            view_layout,
+            mesh_layout,
+            dummy_white_gpu_image,
+        }
+    }
+}
+
+impl MeshPipeline {
+    pub fn get_image_texture<'a>(
+        &'a self,
+        gpu_images: &'a RenderAssets<Image>,
+        handle_option: &Option<Handle<Image>>,
+    ) -> Option<(&'a TextureView, &'a Sampler)> {
+        if let Some(handle) = handle_option {
+            let gpu_image = gpu_images.get(handle)?;
+            Some((&gpu_image.texture_view, &gpu_image.sampler))
+        } else {
+            Some((
+                &self.dummy_white_gpu_image.texture_view,
+                &self.dummy_white_gpu_image.sampler,
+            ))
+        }
+    }
+}
+
+bitflags::bitflags! {
+    #[repr(transparent)]
+    // NOTE: Apparently quadro drivers support up to 64x MSAA.
+    /// MSAA uses the highest 6 bits for the MSAA sample count - 1 to support up to 64x MSAA.
+    pub struct MeshPipelineKey: u32 {
+        const NONE                        = 0;
+        const VERTEX_TANGENTS             = (1 << 0);
+        const TRANSPARENT_MAIN_PASS       = (1 << 1);
+        const MSAA_RESERVED_BITS          = MeshPipelineKey::MSAA_MASK_BITS << MeshPipelineKey::MSAA_SHIFT_BITS;
+    }
+}
+
+impl MeshPipelineKey {
+    const MSAA_MASK_BITS: u32 = 0b111111;
+    const MSAA_SHIFT_BITS: u32 = 32 - 6;
+
+    pub fn from_msaa_samples(msaa_samples: u32) -> Self {
+        let msaa_bits = ((msaa_samples - 1) & Self::MSAA_MASK_BITS) << Self::MSAA_SHIFT_BITS;
+        MeshPipelineKey::from_bits(msaa_bits).unwrap()
+    }
+
+    pub fn msaa_samples(&self) -> u32 {
+        ((self.bits >> Self::MSAA_SHIFT_BITS) & Self::MSAA_MASK_BITS) + 1
+    }
+}
+
+impl SpecializedPipeline for MeshPipeline {
+    type Key = MeshPipelineKey;
+
+    fn specialize(&self, key: Self::Key) -> RenderPipelineDescriptor {
+        let (vertex_array_stride, vertex_attributes) =
+            if key.contains(MeshPipelineKey::VERTEX_TANGENTS) {
+                (
+                    48,
+                    vec![
+                        // Position (GOTCHA! Vertex_Position isn't first in the buffer due to how Mesh sorts attributes (alphabetically))
+                        VertexAttribute {
+                            format: VertexFormat::Float32x3,
+                            offset: 12,
+                            shader_location: 0,
+                        },
+                        // Normal
+                        VertexAttribute {
+                            format: VertexFormat::Float32x3,
+                            offset: 0,
+                            shader_location: 1,
+                        },
+                        // Uv (GOTCHA! uv is no longer third in the buffer due to how Mesh sorts attributes (alphabetically))
+                        VertexAttribute {
+                            format: VertexFormat::Float32x2,
+                            offset: 40,
+                            shader_location: 2,
+                        },
+                        // Tangent
+                        VertexAttribute {
+                            format: VertexFormat::Float32x4,
+                            offset: 24,
+                            shader_location: 3,
+                        },
+                    ],
+                )
+            } else {
+                (
+                    32,
+                    vec![
+                        // Position (GOTCHA! Vertex_Position isn't first in the buffer due to how Mesh sorts attributes (alphabetically))
+                        VertexAttribute {
+                            format: VertexFormat::Float32x3,
+                            offset: 12,
+                            shader_location: 0,
+                        },
+                        // Normal
+                        VertexAttribute {
+                            format: VertexFormat::Float32x3,
+                            offset: 0,
+                            shader_location: 1,
+                        },
+                        // Uv
+                        VertexAttribute {
+                            format: VertexFormat::Float32x2,
+                            offset: 24,
+                            shader_location: 2,
+                        },
+                    ],
+                )
+            };
+        let mut shader_defs = Vec::new();
+        if key.contains(MeshPipelineKey::VERTEX_TANGENTS) {
+            shader_defs.push(String::from("VERTEX_TANGENTS"));
+        }
+
+        let (label, blend, depth_write_enabled);
+        if key.contains(MeshPipelineKey::TRANSPARENT_MAIN_PASS) {
+            label = "transparent_mesh_pipeline".into();
+            blend = Some(BlendState::ALPHA_BLENDING);
+            // For the transparent pass, fragments that are closer will be alpha blended
+            // but their depth is not written to the depth buffer
+            depth_write_enabled = false;
+        } else {
+            label = "opaque_mesh_pipeline".into();
+            blend = Some(BlendState::REPLACE);
+            // For the opaque and alpha mask passes, fragments that are closer will replace
+            // the current fragment value in the output and the depth is written to the
+            // depth buffer
+            depth_write_enabled = true;
+        }
+
+        RenderPipelineDescriptor {
+            vertex: VertexState {
+                shader: MESH_SHADER_HANDLE.typed::<Shader>(),
+                entry_point: "vertex".into(),
+                shader_defs: shader_defs.clone(),
+                buffers: vec![VertexBufferLayout {
+                    array_stride: vertex_array_stride,
+                    step_mode: VertexStepMode::Vertex,
+                    attributes: vertex_attributes,
+                }],
+            },
+            fragment: Some(FragmentState {
+                shader: MESH_SHADER_HANDLE.typed::<Shader>(),
+                shader_defs,
+                entry_point: "fragment".into(),
+                targets: vec![ColorTargetState {
+                    format: TextureFormat::bevy_default(),
+                    blend,
+                    write_mask: ColorWrites::ALL,
+                }],
+            }),
+            layout: Some(vec![self.view_layout.clone(), self.mesh_layout.clone()]),
+            primitive: PrimitiveState {
+                front_face: FrontFace::Ccw,
+                cull_mode: Some(Face::Back),
+                polygon_mode: PolygonMode::Fill,
+                clamp_depth: false,
+                conservative: false,
+                topology: PrimitiveTopology::TriangleList,
+                strip_index_format: None,
+            },
+            depth_stencil: Some(DepthStencilState {
+                format: TextureFormat::Depth32Float,
+                depth_write_enabled,
+                depth_compare: CompareFunction::Greater,
+                stencil: StencilState {
+                    front: StencilFaceState::IGNORE,
+                    back: StencilFaceState::IGNORE,
+                    read_mask: 0,
+                    write_mask: 0,
+                },
+                bias: DepthBiasState {
+                    constant: 0,
+                    slope_scale: 0.0,
+                    clamp: 0.0,
+                },
+            }),
+            multisample: MultisampleState {
+                count: key.msaa_samples(),
+                mask: !0,
+                alpha_to_coverage_enabled: false,
+            },
+            label: Some(label),
+        }
+    }
+}
+
+pub struct MeshBindGroup {
+    pub value: BindGroup,
+}
+
+pub fn queue_mesh_bind_group(
+    mut commands: Commands,
+    mesh_pipeline: Res<MeshPipeline>,
+    render_device: Res<RenderDevice>,
+    mesh_uniforms: Res<ComponentUniforms<MeshUniform>>,
+) {
+    if let Some(binding) = mesh_uniforms.uniforms().binding() {
+        commands.insert_resource(MeshBindGroup {
+            value: render_device.create_bind_group(&BindGroupDescriptor {
+                entries: &[BindGroupEntry {
+                    binding: 0,
+                    resource: binding,
+                }],
+                label: Some("mesh_bind_group"),
+                layout: &mesh_pipeline.mesh_layout,
+            }),
+        });
+    }
+}
+
+#[derive(Component)]
+pub struct MeshViewBindGroup {
+    pub value: BindGroup,
+}
+
+pub fn queue_mesh_view_bind_groups(
+    mut commands: Commands,
+    render_device: Res<RenderDevice>,
+    mesh_pipeline: Res<MeshPipeline>,
+    shadow_pipeline: Res<ShadowPipeline>,
+    light_meta: Res<LightMeta>,
+    view_uniforms: Res<ViewUniforms>,
+    mut views: Query<(Entity, &ViewShadowBindings)>,
+) {
+    if let (Some(view_binding), Some(light_binding)) = (
+        view_uniforms.uniforms.binding(),
+        light_meta.view_gpu_lights.binding(),
+    ) {
+        for (entity, view_shadow_bindings) in views.iter_mut() {
+            let view_bind_group = render_device.create_bind_group(&BindGroupDescriptor {
+                entries: &[
+                    BindGroupEntry {
+                        binding: 0,
+                        resource: view_binding.clone(),
+                    },
+                    BindGroupEntry {
+                        binding: 1,
+                        resource: light_binding.clone(),
+                    },
+                    BindGroupEntry {
+                        binding: 2,
+                        resource: BindingResource::TextureView(
+                            &view_shadow_bindings.point_light_depth_texture_view,
+                        ),
+                    },
+                    BindGroupEntry {
+                        binding: 3,
+                        resource: BindingResource::Sampler(&shadow_pipeline.point_light_sampler),
+                    },
+                    BindGroupEntry {
+                        binding: 4,
+                        resource: BindingResource::TextureView(
+                            &view_shadow_bindings.directional_light_depth_texture_view,
+                        ),
+                    },
+                    BindGroupEntry {
+                        binding: 5,
+                        resource: BindingResource::Sampler(
+                            &shadow_pipeline.directional_light_sampler,
+                        ),
+                    },
+                ],
+                label: Some("mesh_view_bind_group"),
+                layout: &mesh_pipeline.view_layout,
+            });
+
+            commands.entity(entity).insert(MeshViewBindGroup {
+                value: view_bind_group,
+            });
+        }
+    }
+}
+
+pub struct SetMeshViewBindGroup<const I: usize>;
+impl<const I: usize> EntityRenderCommand for SetMeshViewBindGroup<I> {
+    type Param = SQuery<(
+        Read<ViewUniformOffset>,
+        Read<ViewLightsUniformOffset>,
+        Read<MeshViewBindGroup>,
+    )>;
+    #[inline]
+    fn render<'w>(
+        view: Entity,
+        _item: Entity,
+        view_query: SystemParamItem<'w, '_, Self::Param>,
+        pass: &mut TrackedRenderPass<'w>,
+    ) -> RenderCommandResult {
+        let (view_uniform, view_lights, mesh_view_bind_group) = view_query.get(view).unwrap();
+        pass.set_bind_group(
+            I,
+            &mesh_view_bind_group.value,
+            &[view_uniform.offset, view_lights.offset],
+        );
+
+        RenderCommandResult::Success
+    }
+}
+
+pub struct SetMeshBindGroup<const I: usize>;
+impl<const I: usize> EntityRenderCommand for SetMeshBindGroup<I> {
+    type Param = (
+        SRes<MeshBindGroup>,
+        SQuery<Read<DynamicUniformIndex<MeshUniform>>>,
+    );
+    #[inline]
+    fn render<'w>(
+        _view: Entity,
+        item: Entity,
+        (mesh_bind_group, mesh_query): SystemParamItem<'w, '_, Self::Param>,
+        pass: &mut TrackedRenderPass<'w>,
+    ) -> RenderCommandResult {
+        let mesh_index = mesh_query.get(item).unwrap();
+        pass.set_bind_group(
+            I,
+            &mesh_bind_group.into_inner().value,
+            &[mesh_index.index()],
+        );
+        RenderCommandResult::Success
+    }
+}
+
+pub struct DrawMesh;
+impl EntityRenderCommand for DrawMesh {
+    type Param = (SRes<RenderAssets<Mesh>>, SQuery<Read<Handle<Mesh>>>);
+    #[inline]
+    fn render<'w>(
+        _view: Entity,
+        item: Entity,
+        (meshes, mesh_query): SystemParamItem<'w, '_, Self::Param>,
+        pass: &mut TrackedRenderPass<'w>,
+    ) -> RenderCommandResult {
+        let mesh_handle = mesh_query.get(item).unwrap();
+        let gpu_mesh = meshes.into_inner().get(mesh_handle).unwrap();
+        pass.set_vertex_buffer(0, gpu_mesh.vertex_buffer.slice(..));
+        if let Some(index_info) = &gpu_mesh.index_info {
+            pass.set_index_buffer(index_info.buffer.slice(..), 0, index_info.index_format);
+            pass.draw_indexed(0..index_info.count, 0, 0..1);
+        } else {
+            panic!("non-indexed drawing not supported yet")
+        }
+
+        RenderCommandResult::Success
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::MeshPipelineKey;
+    #[test]
+    fn mesh_key_msaa_samples() {
+        for i in 1..=64 {
+            assert_eq!(MeshPipelineKey::from_msaa_samples(i).msaa_samples(), i);
+        }
+    }
+}
diff --git a/pipelined/bevy_pbr2/src/render/mesh.wgsl b/pipelined/bevy_pbr2/src/render/mesh.wgsl
new file mode 100644
index 0000000000..0bb20aeea0
--- /dev/null
+++ b/pipelined/bevy_pbr2/src/render/mesh.wgsl
@@ -0,0 +1,65 @@
+#import bevy_pbr::mesh_view_bind_group
+#import bevy_pbr::mesh_struct
+
+struct Vertex {
+    [[location(0)]] position: vec3<f32>;
+    [[location(1)]] normal: vec3<f32>;
+    [[location(2)]] uv: vec2<f32>;
+#ifdef VERTEX_TANGENTS
+    [[location(3)]] tangent: vec4<f32>;
+#endif
+};
+
+struct VertexOutput {
+    [[builtin(position)]] clip_position: vec4<f32>;
+    [[location(0)]] world_position: vec4<f32>;
+    [[location(1)]] world_normal: vec3<f32>;
+    [[location(2)]] uv: vec2<f32>;
+#ifdef VERTEX_TANGENTS
+    [[location(3)]] world_tangent: vec4<f32>;
+#endif
+};
+
+[[group(2), binding(0)]]
+var<uniform> mesh: Mesh;
+
+[[stage(vertex)]]
+fn vertex(vertex: Vertex) -> VertexOutput {
+    let world_position = mesh.model * vec4<f32>(vertex.position, 1.0);
+
+    var out: VertexOutput;
+    out.uv = vertex.uv;
+    out.world_position = world_position;
+    out.clip_position = view.view_proj * world_position;
+    out.world_normal = mat3x3<f32>(
+        mesh.inverse_transpose_model[0].xyz,
+        mesh.inverse_transpose_model[1].xyz,
+        mesh.inverse_transpose_model[2].xyz
+    ) * vertex.normal;
+#ifdef VERTEX_TANGENTS
+    out.world_tangent = vec4<f32>(
+        mat3x3<f32>(
+            mesh.model[0].xyz,
+            mesh.model[1].xyz,
+            mesh.model[2].xyz
+        ) * vertex.tangent.xyz,
+        vertex.tangent.w
+    );
+#endif
+    return out;
+}
+
+struct FragmentInput {
+    [[builtin(front_facing)]] is_front: bool;
+    [[location(0)]] world_position: vec4<f32>;
+    [[location(1)]] world_normal: vec3<f32>;
+    [[location(2)]] uv: vec2<f32>;
+#ifdef VERTEX_TANGENTS
+    [[location(3)]] world_tangent: vec4<f32>;
+#endif
+};
+
+[[stage(fragment)]]
+fn fragment(in: FragmentInput) -> [[location(0)]] vec4<f32> {
+    return vec4<f32>(1.0, 0.0, 1.0, 1.0);
+}
\ No newline at end of file
diff --git a/pipelined/bevy_pbr2/src/render/mesh_struct.wgsl b/pipelined/bevy_pbr2/src/render/mesh_struct.wgsl
new file mode 100644
index 0000000000..672f6a021a
--- /dev/null
+++ b/pipelined/bevy_pbr2/src/render/mesh_struct.wgsl
@@ -0,0 +1,9 @@
+[[block]]
+struct Mesh {
+    model: mat4x4<f32>;
+    inverse_transpose_model: mat4x4<f32>;
+    // 'flags' is a bit field indicating various options. u32 is 32 bits so we have up to 32 options.
+    flags: u32;
+};
+
+let MESH_FLAGS_SHADOW_RECEIVER_BIT: u32 = 1u;
diff --git a/pipelined/bevy_pbr2/src/render/mesh_view_bind_group.wgsl b/pipelined/bevy_pbr2/src/render/mesh_view_bind_group.wgsl
new file mode 100644
index 0000000000..a9eb0f60d8
--- /dev/null
+++ b/pipelined/bevy_pbr2/src/render/mesh_view_bind_group.wgsl
@@ -0,0 +1,58 @@
+[[block]]
+struct View {
+    view_proj: mat4x4<f32>;
+    projection: mat4x4<f32>;
+    world_position: vec3<f32>;
+};
+
+struct PointLight {
+    projection: mat4x4<f32>;
+    color: vec4<f32>;
+    position: vec3<f32>;
+    inverse_square_range: f32;
+    radius: f32;
+    near: f32;
+    far: f32;
+    // 'flags' is a bit field indicating various options. u32 is 32 bits so we have up to 32 options.
+    flags: u32;
+    shadow_depth_bias: f32;
+    shadow_normal_bias: f32;
+};
+
+let POINT_LIGHT_FLAGS_SHADOWS_ENABLED_BIT: u32 = 1u;
+
+struct DirectionalLight {
+    view_projection: mat4x4<f32>;
+    color: vec4<f32>;
+    direction_to_light: vec3<f32>;
+    // 'flags' is a bit field indicating various options. u32 is 32 bits so we have up to 32 options.
+    flags: u32;
+    shadow_depth_bias: f32;
+    shadow_normal_bias: f32;
+};
+
+let DIRECTIONAL_LIGHT_FLAGS_SHADOWS_ENABLED_BIT: u32 = 1u;
+
+[[block]]
+struct Lights {
+    // NOTE: this array size must be kept in sync with the constants defined bevy_pbr2/src/render/light.rs
+    // TODO: this can be removed if we move to storage buffers for light arrays
+    point_lights: array<PointLight, 10>;
+    directional_lights: array<DirectionalLight, 1>;
+    ambient_color: vec4<f32>;
+    n_point_lights: u32;
+    n_directional_lights: u32;
+};
+
+[[group(0), binding(0)]]
+var<uniform> view: View;
+[[group(0), binding(1)]]
+var<uniform> lights: Lights;
+[[group(0), binding(2)]]
+var point_shadow_textures: texture_depth_cube_array;
+[[group(0), binding(3)]]
+var point_shadow_textures_sampler: sampler_comparison;
+[[group(0), binding(4)]]
+var directional_shadow_textures: texture_depth_2d_array;
+[[group(0), binding(5)]]
+var directional_shadow_textures_sampler: sampler_comparison;
diff --git a/pipelined/bevy_pbr2/src/render/mod.rs b/pipelined/bevy_pbr2/src/render/mod.rs
new file mode 100644
index 0000000000..348f7db955
--- /dev/null
+++ b/pipelined/bevy_pbr2/src/render/mod.rs
@@ -0,0 +1,347 @@
+mod light;
+mod mesh;
+
+pub use light::*;
+pub use mesh::*;
+
+use crate::{AlphaMode, StandardMaterial, StandardMaterialUniformData, PBR_SHADER_HANDLE};
+use bevy_asset::Handle;
+use bevy_core_pipeline::{AlphaMask3d, Opaque3d, Transparent3d};
+use bevy_ecs::{
+    prelude::*,
+    system::{lifetimeless::*, SystemParamItem},
+};
+use bevy_render2::{
+    mesh::Mesh,
+    render_asset::RenderAssets,
+    render_phase::{
+        DrawFunctions, EntityRenderCommand, RenderCommandResult, RenderPhase, SetItemPipeline,
+        TrackedRenderPass,
+    },
+    render_resource::*,
+    renderer::RenderDevice,
+    view::{ExtractedView, Msaa, VisibleEntities},
+};
+use crevice::std140::AsStd140;
+
+// NOTE: These must match the bit flags in bevy_pbr2/src/render/pbr.wgsl!
+bitflags::bitflags! {
+    #[repr(transparent)]
+    pub struct StandardMaterialFlags: u32 {
+        const BASE_COLOR_TEXTURE         = (1 << 0);
+        const EMISSIVE_TEXTURE           = (1 << 1);
+        const METALLIC_ROUGHNESS_TEXTURE = (1 << 2);
+        const OCCLUSION_TEXTURE          = (1 << 3);
+        const DOUBLE_SIDED               = (1 << 4);
+        const UNLIT                      = (1 << 5);
+        const ALPHA_MODE_OPAQUE          = (1 << 6);
+        const ALPHA_MODE_MASK            = (1 << 7);
+        const ALPHA_MODE_BLEND           = (1 << 8);
+        const NONE                       = 0;
+        const UNINITIALIZED              = 0xFFFF;
+    }
+}
+
+#[derive(Clone)]
+pub struct PbrPipeline {
+    pub mesh_pipeline: MeshPipeline,
+    pub material_layout: BindGroupLayout,
+}
+
+impl FromWorld for PbrPipeline {
+    fn from_world(world: &mut World) -> Self {
+        let render_device = world.get_resource::<RenderDevice>().unwrap();
+
+        let material_layout = render_device.create_bind_group_layout(&BindGroupLayoutDescriptor {
+            entries: &[
+                BindGroupLayoutEntry {
+                    binding: 0,
+                    visibility: ShaderStages::FRAGMENT,
+                    ty: BindingType::Buffer {
+                        ty: BufferBindingType::Uniform,
+                        has_dynamic_offset: false,
+                        min_binding_size: BufferSize::new(
+                            StandardMaterialUniformData::std140_size_static() as u64,
+                        ),
+                    },
+                    count: None,
+                },
+                // Base Color Texture
+                BindGroupLayoutEntry {
+                    binding: 1,
+                    visibility: ShaderStages::FRAGMENT,
+                    ty: BindingType::Texture {
+                        multisampled: false,
+                        sample_type: TextureSampleType::Float { filterable: true },
+                        view_dimension: TextureViewDimension::D2,
+                    },
+                    count: None,
+                },
+                // Base Color Texture Sampler
+                BindGroupLayoutEntry {
+                    binding: 2,
+                    visibility: ShaderStages::FRAGMENT,
+                    ty: BindingType::Sampler {
+                        comparison: false,
+                        filtering: true,
+                    },
+                    count: None,
+                },
+                // Emissive Texture
+                BindGroupLayoutEntry {
+                    binding: 3,
+                    visibility: ShaderStages::FRAGMENT,
+                    ty: BindingType::Texture {
+                        multisampled: false,
+                        sample_type: TextureSampleType::Float { filterable: true },
+                        view_dimension: TextureViewDimension::D2,
+                    },
+                    count: None,
+                },
+                // Emissive Texture Sampler
+                BindGroupLayoutEntry {
+                    binding: 4,
+                    visibility: ShaderStages::FRAGMENT,
+                    ty: BindingType::Sampler {
+                        comparison: false,
+                        filtering: true,
+                    },
+                    count: None,
+                },
+                // Metallic Roughness Texture
+                BindGroupLayoutEntry {
+                    binding: 5,
+                    visibility: ShaderStages::FRAGMENT,
+                    ty: BindingType::Texture {
+                        multisampled: false,
+                        sample_type: TextureSampleType::Float { filterable: true },
+                        view_dimension: TextureViewDimension::D2,
+                    },
+                    count: None,
+                },
+                // Metallic Roughness Texture Sampler
+                BindGroupLayoutEntry {
+                    binding: 6,
+                    visibility: ShaderStages::FRAGMENT,
+                    ty: BindingType::Sampler {
+                        comparison: false,
+                        filtering: true,
+                    },
+                    count: None,
+                },
+                // Occlusion Texture
+                BindGroupLayoutEntry {
+                    binding: 7,
+                    visibility: ShaderStages::FRAGMENT,
+                    ty: BindingType::Texture {
+                        multisampled: false,
+                        sample_type: TextureSampleType::Float { filterable: true },
+                        view_dimension: TextureViewDimension::D2,
+                    },
+                    count: None,
+                },
+                // Occlusion Texture Sampler
+                BindGroupLayoutEntry {
+                    binding: 8,
+                    visibility: ShaderStages::FRAGMENT,
+                    ty: BindingType::Sampler {
+                        comparison: false,
+                        filtering: true,
+                    },
+                    count: None,
+                },
+                // Normal Map Texture
+                BindGroupLayoutEntry {
+                    binding: 9,
+                    visibility: ShaderStages::FRAGMENT,
+                    ty: BindingType::Texture {
+                        multisampled: false,
+                        sample_type: TextureSampleType::Float { filterable: true },
+                        view_dimension: TextureViewDimension::D2,
+                    },
+                    count: None,
+                },
+                // Normal Map Texture Sampler
+                BindGroupLayoutEntry {
+                    binding: 10,
+                    visibility: ShaderStages::FRAGMENT,
+                    ty: BindingType::Sampler {
+                        comparison: false,
+                        filtering: true,
+                    },
+                    count: None,
+                },
+            ],
+            label: Some("pbr_material_layout"),
+        });
+
+        PbrPipeline {
+            material_layout,
+            mesh_pipeline: world.get_resource::<MeshPipeline>().unwrap().clone(),
+        }
+    }
+}
+
+#[derive(Clone, Copy, Hash, PartialEq, Eq)]
+pub struct PbrPipelineKey {
+    pub mesh_key: MeshPipelineKey,
+    pub normal_map: bool,
+}
+
+impl SpecializedPipeline for PbrPipeline {
+    type Key = PbrPipelineKey;
+
+    fn specialize(&self, key: Self::Key) -> RenderPipelineDescriptor {
+        let mut descriptor = self.mesh_pipeline.specialize(key.mesh_key);
+        descriptor.fragment.as_mut().unwrap().shader = PBR_SHADER_HANDLE.typed::<Shader>();
+        descriptor.layout = Some(vec![
+            self.mesh_pipeline.view_layout.clone(),
+            self.material_layout.clone(),
+            self.mesh_pipeline.mesh_layout.clone(),
+        ]);
+        if let Some(label) = &mut descriptor.label {
+            *label = format!("pbr_{}", *label).into();
+        }
+        descriptor
+    }
+}
+
+pub struct PbrViewBindGroup {
+    pub value: BindGroup,
+}
+
+#[allow(clippy::too_many_arguments)]
+pub fn queue_meshes(
+    opaque_draw_functions: Res<DrawFunctions<Opaque3d>>,
+    alpha_mask_draw_functions: Res<DrawFunctions<AlphaMask3d>>,
+    transparent_draw_functions: Res<DrawFunctions<Transparent3d>>,
+    pbr_pipeline: Res<PbrPipeline>,
+    mut pipelines: ResMut<SpecializedPipelines<PbrPipeline>>,
+    mut pipeline_cache: ResMut<RenderPipelineCache>,
+    msaa: Res<Msaa>,
+    render_meshes: Res<RenderAssets<Mesh>>,
+    render_materials: Res<RenderAssets<StandardMaterial>>,
+    standard_material_meshes: Query<(&Handle<StandardMaterial>, &Handle<Mesh>, &MeshUniform)>,
+    mut views: Query<(
+        &ExtractedView,
+        &VisibleEntities,
+        &mut RenderPhase<Opaque3d>,
+        &mut RenderPhase<AlphaMask3d>,
+        &mut RenderPhase<Transparent3d>,
+    )>,
+) {
+    for (view, visible_entities, mut opaque_phase, mut alpha_mask_phase, mut transparent_phase) in
+        views.iter_mut()
+    {
+        let draw_opaque_pbr = opaque_draw_functions.read().get_id::<DrawPbr>().unwrap();
+        let draw_alpha_mask_pbr = alpha_mask_draw_functions
+            .read()
+            .get_id::<DrawPbr>()
+            .unwrap();
+        let draw_transparent_pbr = transparent_draw_functions
+            .read()
+            .get_id::<DrawPbr>()
+            .unwrap();
+
+        let inverse_view_matrix = view.transform.compute_matrix().inverse();
+        let inverse_view_row_2 = inverse_view_matrix.row(2);
+        let mesh_key = MeshPipelineKey::from_msaa_samples(msaa.samples);
+
+        for visible_entity in &visible_entities.entities {
+            if let Ok((material_handle, mesh_handle, mesh_uniform)) =
+                standard_material_meshes.get(visible_entity.entity)
+            {
+                if let Some(material) = render_materials.get(material_handle) {
+                    let mut pbr_key = PbrPipelineKey {
+                        mesh_key,
+                        normal_map: material.has_normal_map,
+                    };
+                    if let Some(mesh) = render_meshes.get(mesh_handle) {
+                        if mesh.has_tangents {
+                            pbr_key.mesh_key |= MeshPipelineKey::VERTEX_TANGENTS;
+                        }
+                    }
+
+                    if let AlphaMode::Blend = material.alpha_mode {
+                        pbr_key.mesh_key |= MeshPipelineKey::TRANSPARENT_MAIN_PASS
+                    }
+
+                    let pipeline_id =
+                        pipelines.specialize(&mut pipeline_cache, &pbr_pipeline, pbr_key);
+
+                    // NOTE: row 2 of the inverse view matrix dotted with column 3 of the model matrix
+                    // gives the z component of translation of the mesh in view space
+                    let mesh_z = inverse_view_row_2.dot(mesh_uniform.transform.col(3));
+                    match material.alpha_mode {
+                        AlphaMode::Opaque => {
+                            opaque_phase.add(Opaque3d {
+                                entity: visible_entity.entity,
+                                draw_function: draw_opaque_pbr,
+                                pipeline: pipeline_id,
+                                // NOTE: Front-to-back ordering for opaque with ascending sort means near should have the
+                                //       lowest sort key and getting further away should increase. As we have
+                                //       -z in front of the camera, values in view space decrease away from the
+                                //       camera. Flipping the sign of mesh_z results in the correct front-to-back ordering
+                                distance: -mesh_z,
+                            });
+                        }
+                        AlphaMode::Mask(_) => {
+                            alpha_mask_phase.add(AlphaMask3d {
+                                entity: visible_entity.entity,
+                                draw_function: draw_alpha_mask_pbr,
+                                pipeline: pipeline_id,
+                                // NOTE: Front-to-back ordering for alpha mask with ascending sort means near should have the
+                                //       lowest sort key and getting further away should increase. As we have
+                                //       -z in front of the camera, values in view space decrease away from the
+                                //       camera. Flipping the sign of mesh_z results in the correct front-to-back ordering
+                                distance: -mesh_z,
+                            });
+                        }
+                        AlphaMode::Blend => {
+                            transparent_phase.add(Transparent3d {
+                                entity: visible_entity.entity,
+                                draw_function: draw_transparent_pbr,
+                                pipeline: pipeline_id,
+                                // NOTE: Back-to-front ordering for transparent with ascending sort means far should have the
+                                //       lowest sort key and getting closer should increase. As we have
+                                //       -z in front of the camera, the largest distance is -far with values increasing toward the
+                                //       camera. As such we can just use mesh_z as the distance
+                                distance: mesh_z,
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+pub type DrawPbr = (
+    SetItemPipeline,
+    SetMeshViewBindGroup<0>,
+    SetStandardMaterialBindGroup<1>,
+    SetMeshBindGroup<2>,
+    DrawMesh,
+);
+
+pub struct SetStandardMaterialBindGroup<const I: usize>;
+impl<const I: usize> EntityRenderCommand for SetStandardMaterialBindGroup<I> {
+    type Param = (
+        SRes<RenderAssets<StandardMaterial>>,
+        SQuery<Read<Handle<StandardMaterial>>>,
+    );
+    #[inline]
+    fn render<'w>(
+        _view: Entity,
+        item: Entity,
+        (materials, handle_query): SystemParamItem<'w, '_, Self::Param>,
+        pass: &mut TrackedRenderPass<'w>,
+    ) -> RenderCommandResult {
+        let handle = handle_query.get(item).unwrap();
+        let materials = materials.into_inner();
+        let material = materials.get(handle).unwrap();
+
+        pass.set_bind_group(I, &material.bind_group, &[]);
+        RenderCommandResult::Success
+    }
+}
diff --git a/pipelined/bevy_pbr2/src/render/pbr.wgsl b/pipelined/bevy_pbr2/src/render/pbr.wgsl
new file mode 100644
index 0000000000..bb5515657a
--- /dev/null
+++ b/pipelined/bevy_pbr2/src/render/pbr.wgsl
@@ -0,0 +1,542 @@
+// From the Filament design doc
+// https://google.github.io/filament/Filament.html#table_symbols
+// Symbol Definition
+// v    View unit vector
+// l    Incident light unit vector
+// n    Surface normal unit vector
+// h    Half unit vector between l and v
+// f    BRDF
+// f_d    Diffuse component of a BRDF
+// f_r    Specular component of a BRDF
+// α    Roughness, remapped from using input perceptualRoughness
+// σ    Diffuse reflectance
+// Ω    Spherical domain
+// f0    Reflectance at normal incidence
+// f90    Reflectance at grazing angle
+// χ+(a)    Heaviside function (1 if a>0 and 0 otherwise)
+// nior    Index of refraction (IOR) of an interface
+// ⟨n⋅l⟩    Dot product clamped to [0..1]
+// ⟨a⟩    Saturated value (clamped to [0..1])
+
+// The Bidirectional Reflectance Distribution Function (BRDF) describes the surface response of a standard material
+// and consists of two components, the diffuse component (f_d) and the specular component (f_r):
+// f(v,l) = f_d(v,l) + f_r(v,l)
+//
+// The form of the microfacet model is the same for diffuse and specular
+// f_r(v,l) = f_d(v,l) = 1 / { |n⋅v||n⋅l| } ∫_Ω D(m,α) G(v,l,m) f_m(v,l,m) (v⋅m) (l⋅m) dm
+//
+// In which:
+// D, also called the Normal Distribution Function (NDF) models the distribution of the microfacets
+// G models the visibility (or occlusion or shadow-masking) of the microfacets
+// f_m is the microfacet BRDF and differs between specular and diffuse components
+//
+// The above integration needs to be approximated.
+
+#import bevy_pbr::mesh_view_bind_group
+#import bevy_pbr::mesh_struct
+
+[[group(2), binding(0)]]
+var<uniform> mesh: Mesh;
+
+[[block]]
+struct StandardMaterial {
+    base_color: vec4<f32>;
+    emissive: vec4<f32>;
+    perceptual_roughness: f32;
+    metallic: f32;
+    reflectance: f32;
+    // 'flags' is a bit field indicating various options. u32 is 32 bits so we have up to 32 options.
+    flags: u32;
+    alpha_cutoff: f32;
+};
+
+let STANDARD_MATERIAL_FLAGS_BASE_COLOR_TEXTURE_BIT: u32         = 1u;
+let STANDARD_MATERIAL_FLAGS_EMISSIVE_TEXTURE_BIT: u32           = 2u;
+let STANDARD_MATERIAL_FLAGS_METALLIC_ROUGHNESS_TEXTURE_BIT: u32 = 4u;
+let STANDARD_MATERIAL_FLAGS_OCCLUSION_TEXTURE_BIT: u32          = 8u;
+let STANDARD_MATERIAL_FLAGS_DOUBLE_SIDED_BIT: u32               = 16u;
+let STANDARD_MATERIAL_FLAGS_UNLIT_BIT: u32                      = 32u;
+let STANDARD_MATERIAL_FLAGS_ALPHA_MODE_OPAQUE: u32              = 64u;
+let STANDARD_MATERIAL_FLAGS_ALPHA_MODE_MASK: u32                = 128u;
+let STANDARD_MATERIAL_FLAGS_ALPHA_MODE_BLEND: u32               = 256u;
+
+[[group(1), binding(0)]]
+var<uniform> material: StandardMaterial;
+[[group(1), binding(1)]]
+var base_color_texture: texture_2d<f32>;
+[[group(1), binding(2)]]
+var base_color_sampler: sampler;
+[[group(1), binding(3)]]
+var emissive_texture: texture_2d<f32>;
+[[group(1), binding(4)]]
+var emissive_sampler: sampler;
+[[group(1), binding(5)]]
+var metallic_roughness_texture: texture_2d<f32>;
+[[group(1), binding(6)]]
+var metallic_roughness_sampler: sampler;
+[[group(1), binding(7)]]
+var occlusion_texture: texture_2d<f32>;
+[[group(1), binding(8)]]
+var occlusion_sampler: sampler;
+[[group(1), binding(9)]]
+var normal_map_texture: texture_2d<f32>;
+[[group(1), binding(10)]]
+var normal_map_sampler: sampler;
+
+let PI: f32 = 3.141592653589793;
+
+fn saturate(value: f32) -> f32 {
+    return clamp(value, 0.0, 1.0);
+}
+
+// distanceAttenuation is simply the square falloff of light intensity
+// combined with a smooth attenuation at the edge of the light radius
+//
+// light radius is a non-physical construct for efficiency purposes,
+// because otherwise every light affects every fragment in the scene
+fn getDistanceAttenuation(distanceSquare: f32, inverseRangeSquared: f32) -> f32 {
+    let factor = distanceSquare * inverseRangeSquared;
+    let smoothFactor = saturate(1.0 - factor * factor);
+    let attenuation = smoothFactor * smoothFactor;
+    return attenuation * 1.0 / max(distanceSquare, 0.0001);
+}
+
+// Normal distribution function (specular D)
+// Based on https://google.github.io/filament/Filament.html#citation-walter07
+
+// D_GGX(h,α) = α^2 / { π ((n⋅h)^2 (α2−1) + 1)^2 }
+
+// Simple implementation, has precision problems when using fp16 instead of fp32
+// see https://google.github.io/filament/Filament.html#listing_speculardfp16
+fn D_GGX(roughness: f32, NoH: f32, h: vec3<f32>) -> f32 {
+    let oneMinusNoHSquared = 1.0 - NoH * NoH;
+    let a = NoH * roughness;
+    let k = roughness / (oneMinusNoHSquared + a * a);
+    let d = k * k * (1.0 / PI);
+    return d;
+}
+
+// Visibility function (Specular G)
+// V(v,l,a) = G(v,l,α) / { 4 (n⋅v) (n⋅l) }
+// such that f_r becomes
+// f_r(v,l) = D(h,α) V(v,l,α) F(v,h,f0)
+// where
+// V(v,l,α) = 0.5 / { n⋅l sqrt((n⋅v)^2 (1−α2) + α2) + n⋅v sqrt((n⋅l)^2 (1−α2) + α2) }
+// Note the two sqrt's, that may be slow on mobile, see https://google.github.io/filament/Filament.html#listing_approximatedspecularv
+fn V_SmithGGXCorrelated(roughness: f32, NoV: f32, NoL: f32) -> f32 {
+    let a2 = roughness * roughness;
+    let lambdaV = NoL * sqrt((NoV - a2 * NoV) * NoV + a2);
+    let lambdaL = NoV * sqrt((NoL - a2 * NoL) * NoL + a2);
+    let v = 0.5 / (lambdaV + lambdaL);
+    return v;
+}
+
+// Fresnel function
+// see https://google.github.io/filament/Filament.html#citation-schlick94
+// F_Schlick(v,h,f_0,f_90) = f_0 + (f_90 − f_0) (1 − v⋅h)^5
+fn F_Schlick_vec(f0: vec3<f32>, f90: f32, VoH: f32) -> vec3<f32> {
+    // not using mix to keep the vec3 and float versions identical
+    return f0 + (f90 - f0) * pow(1.0 - VoH, 5.0);
+}
+
+fn F_Schlick(f0: f32, f90: f32, VoH: f32) -> f32 {
+    // not using mix to keep the vec3 and float versions identical
+    return f0 + (f90 - f0) * pow(1.0 - VoH, 5.0);
+}
+
+fn fresnel(f0: vec3<f32>, LoH: f32) -> vec3<f32> {
+    // f_90 suitable for ambient occlusion
+    // see https://google.github.io/filament/Filament.html#lighting/occlusion
+    let f90 = saturate(dot(f0, vec3<f32>(50.0 * 0.33)));
+    return F_Schlick_vec(f0, f90, LoH);
+}
+
+// Specular BRDF
+// https://google.github.io/filament/Filament.html#materialsystem/specularbrdf
+
+// Cook-Torrance approximation of the microfacet model integration using Fresnel law F to model f_m
+// f_r(v,l) = { D(h,α) G(v,l,α) F(v,h,f0) } / { 4 (n⋅v) (n⋅l) }
+fn specular(f0: vec3<f32>, roughness: f32, h: vec3<f32>, NoV: f32, NoL: f32,
+              NoH: f32, LoH: f32, specularIntensity: f32) -> vec3<f32> {
+    let D = D_GGX(roughness, NoH, h);
+    let V = V_SmithGGXCorrelated(roughness, NoV, NoL);
+    let F = fresnel(f0, LoH);
+
+    return (specularIntensity * D * V) * F;
+}
+
+// Diffuse BRDF
+// https://google.github.io/filament/Filament.html#materialsystem/diffusebrdf
+// fd(v,l) = σ/π * 1 / { |n⋅v||n⋅l| } ∫Ω D(m,α) G(v,l,m) (v⋅m) (l⋅m) dm
+//
+// simplest approximation
+// float Fd_Lambert() {
+//     return 1.0 / PI;
+// }
+//
+// vec3 Fd = diffuseColor * Fd_Lambert();
+//
+// Disney approximation
+// See https://google.github.io/filament/Filament.html#citation-burley12
+// minimal quality difference
+fn Fd_Burley(roughness: f32, NoV: f32, NoL: f32, LoH: f32) -> f32 {
+    let f90 = 0.5 + 2.0 * roughness * LoH * LoH;
+    let lightScatter = F_Schlick(1.0, f90, NoL);
+    let viewScatter = F_Schlick(1.0, f90, NoV);
+    return lightScatter * viewScatter * (1.0 / PI);
+}
+
+// From https://www.unrealengine.com/en-US/blog/physically-based-shading-on-mobile
+fn EnvBRDFApprox(f0: vec3<f32>, perceptual_roughness: f32, NoV: f32) -> vec3<f32> {
+    let c0 = vec4<f32>(-1.0, -0.0275, -0.572, 0.022);
+    let c1 = vec4<f32>(1.0, 0.0425, 1.04, -0.04);
+    let r = perceptual_roughness * c0 + c1;
+    let a004 = min(r.x * r.x, exp2(-9.28 * NoV)) * r.x + r.y;
+    let AB = vec2<f32>(-1.04, 1.04) * a004 + r.zw;
+    return f0 * AB.x + AB.y;
+}
+
+fn perceptualRoughnessToRoughness(perceptualRoughness: f32) -> f32 {
+    // clamp perceptual roughness to prevent precision problems
+    // According to Filament design 0.089 is recommended for mobile
+    // Filament uses 0.045 for non-mobile
+    let clampedPerceptualRoughness = clamp(perceptualRoughness, 0.089, 1.0);
+    return clampedPerceptualRoughness * clampedPerceptualRoughness;
+}
+
+// from https://64.github.io/tonemapping/
+// reinhard on RGB oversaturates colors
+fn reinhard(color: vec3<f32>) -> vec3<f32> {
+    return color / (1.0 + color);
+}
+
+fn reinhard_extended(color: vec3<f32>, max_white: f32) -> vec3<f32> {
+    let numerator = color * (1.0 + (color / vec3<f32>(max_white * max_white)));
+    return numerator / (1.0 + color);
+}
+
+// luminance coefficients from Rec. 709.
+// https://en.wikipedia.org/wiki/Rec._709
+fn luminance(v: vec3<f32>) -> f32 {
+    return dot(v, vec3<f32>(0.2126, 0.7152, 0.0722));
+}
+
+fn change_luminance(c_in: vec3<f32>, l_out: f32) -> vec3<f32> {
+    let l_in = luminance(c_in);
+    return c_in * (l_out / l_in);
+}
+
+fn reinhard_luminance(color: vec3<f32>) -> vec3<f32> {
+    let l_old = luminance(color);
+    let l_new = l_old / (1.0 + l_old);
+    return change_luminance(color, l_new);
+}
+
+fn reinhard_extended_luminance(color: vec3<f32>, max_white_l: f32) -> vec3<f32> {
+    let l_old = luminance(color);
+    let numerator = l_old * (1.0 + (l_old / (max_white_l * max_white_l)));
+    let l_new = numerator / (1.0 + l_old);
+    return change_luminance(color, l_new);
+}
+
+fn point_light(
+    world_position: vec3<f32>, light: PointLight, roughness: f32, NdotV: f32, N: vec3<f32>, V: vec3<f32>,
+    R: vec3<f32>, F0: vec3<f32>, diffuseColor: vec3<f32>
+) -> vec3<f32> {
+    let light_to_frag = light.position.xyz - world_position.xyz;
+    let distance_square = dot(light_to_frag, light_to_frag);
+    let rangeAttenuation =
+        getDistanceAttenuation(distance_square, light.inverse_square_range);
+
+    // Specular.
+    // Representative Point Area Lights.
+    // see http://blog.selfshadow.com/publications/s2013-shading-course/karis/s2013_pbs_epic_notes_v2.pdf p14-16
+    let a = roughness;
+    let centerToRay = dot(light_to_frag, R) * R - light_to_frag;
+    let closestPoint = light_to_frag + centerToRay * saturate(light.radius * inverseSqrt(dot(centerToRay, centerToRay)));
+    let LspecLengthInverse = inverseSqrt(dot(closestPoint, closestPoint));
+    let normalizationFactor = a / saturate(a + (light.radius * 0.5 * LspecLengthInverse));
+    let specularIntensity = normalizationFactor * normalizationFactor;
+
+    var L: vec3<f32> = closestPoint * LspecLengthInverse; // normalize() equivalent?
+    var H: vec3<f32> = normalize(L + V);
+    var NoL: f32 = saturate(dot(N, L));
+    var NoH: f32 = saturate(dot(N, H));
+    var LoH: f32 = saturate(dot(L, H));
+
+    let specular_light = specular(F0, roughness, H, NdotV, NoL, NoH, LoH, specularIntensity);
+
+    // Diffuse.
+    // Comes after specular since its NoL is used in the lighting equation.
+    L = normalize(light_to_frag);
+    H = normalize(L + V);
+    NoL = saturate(dot(N, L));
+    NoH = saturate(dot(N, H));
+    LoH = saturate(dot(L, H));
+
+    let diffuse = diffuseColor * Fd_Burley(roughness, NdotV, NoL, LoH);
+
+    // See https://google.github.io/filament/Filament.html#mjx-eqn-pointLightLuminanceEquation
+    // Lout = f(v,l) Φ / { 4 π d^2 }⟨n⋅l⟩
+    // where
+    // f(v,l) = (f_d(v,l) + f_r(v,l)) * light_color
+    // Φ is luminous power in lumens
+    // our rangeAttentuation = 1 / d^2 multiplied with an attenuation factor for smoothing at the edge of the non-physical maximum light radius
+
+    // For a point light, luminous intensity, I, in lumens per steradian is given by:
+    // I = Φ / 4 π
+    // The derivation of this can be seen here: https://google.github.io/filament/Filament.html#mjx-eqn-pointLightLuminousPower
+
+    // NOTE: light.color.rgb is premultiplied with light.intensity / 4 π (which would be the luminous intensity) on the CPU
+
+    // TODO compensate for energy loss https://google.github.io/filament/Filament.html#materialsystem/improvingthebrdfs/energylossinspecularreflectance
+
+    return ((diffuse + specular_light) * light.color.rgb) * (rangeAttenuation * NoL);
+}
+
+fn directional_light(light: DirectionalLight, roughness: f32, NdotV: f32, normal: vec3<f32>, view: vec3<f32>, R: vec3<f32>, F0: vec3<f32>, diffuseColor: vec3<f32>) -> vec3<f32> {
+    let incident_light = light.direction_to_light.xyz;
+
+    let half_vector = normalize(incident_light + view);
+    let NoL = saturate(dot(normal, incident_light));
+    let NoH = saturate(dot(normal, half_vector));
+    let LoH = saturate(dot(incident_light, half_vector));
+
+    let diffuse = diffuseColor * Fd_Burley(roughness, NdotV, NoL, LoH);
+    let specularIntensity = 1.0;
+    let specular_light = specular(F0, roughness, half_vector, NdotV, NoL, NoH, LoH, specularIntensity);
+
+    return (specular_light + diffuse) * light.color.rgb * NoL;
+}
+
+fn fetch_point_shadow(light_id: i32, frag_position: vec4<f32>, surface_normal: vec3<f32>) -> f32 {
+    let light = lights.point_lights[light_id];
+
+    // because the shadow maps align with the axes and the frustum planes are at 45 degrees
+    // we can get the worldspace depth by taking the largest absolute axis
+    let surface_to_light = light.position.xyz - frag_position.xyz;
+    let surface_to_light_abs = abs(surface_to_light);
+    let distance_to_light = max(surface_to_light_abs.x, max(surface_to_light_abs.y, surface_to_light_abs.z));
+
+    // The normal bias here is already scaled by the texel size at 1 world unit from the light.
+    // The texel size increases proportionally with distance from the light so multiplying by
+    // distance to light scales the normal bias to the texel size at the fragment distance.
+    let normal_offset = light.shadow_normal_bias * distance_to_light * surface_normal.xyz;
+    let depth_offset = light.shadow_depth_bias * normalize(surface_to_light.xyz);
+    let offset_position = frag_position.xyz + normal_offset + depth_offset;
+
+    // similar largest-absolute-axis trick as above, but now with the offset fragment position
+    let frag_ls = light.position.xyz - offset_position.xyz;
+    let abs_position_ls = abs(frag_ls);
+    let major_axis_magnitude = max(abs_position_ls.x, max(abs_position_ls.y, abs_position_ls.z));
+
+    // NOTE: These simplifications come from multiplying:
+    //       projection * vec4(0, 0, -major_axis_magnitude, 1.0)
+    //       and keeping only the terms that have any impact on the depth.
+    // Projection-agnostic approach:
+    let z = -major_axis_magnitude * light.projection[2][2] + light.projection[3][2];
+    let w = -major_axis_magnitude * light.projection[2][3] + light.projection[3][3];
+
+    // For perspective_rh:
+    // let proj_r = light.far / (light.near - light.far);
+    // let z = -major_axis_magnitude * proj_r + light.near * proj_r;
+    // let w = major_axis_magnitude;
+
+    // For perspective_infinite_reverse_rh:
+    // let z = light.near;
+    // let w = major_axis_magnitude;
+
+    let depth = z / w;
+
+    // do the lookup, using HW PCF and comparison
+    // NOTE: Due to the non-uniform control flow above, we must use the Level variant of
+    //       textureSampleCompare to avoid undefined behaviour due to some of the fragments in
+    //       a quad (2x2 fragments) being processed not being sampled, and this messing with
+    //       mip-mapping functionality. The shadow maps have no mipmaps so Level just samples
+    //       from LOD 0.
+    return textureSampleCompareLevel(point_shadow_textures, point_shadow_textures_sampler, frag_ls, i32(light_id), depth);
+}
+
+fn fetch_directional_shadow(light_id: i32, frag_position: vec4<f32>, surface_normal: vec3<f32>) -> f32 {
+    let light = lights.directional_lights[light_id];
+
+    // The normal bias is scaled to the texel size.
+    let normal_offset = light.shadow_normal_bias * surface_normal.xyz;
+    let depth_offset = light.shadow_depth_bias * light.direction_to_light.xyz;
+    let offset_position = vec4<f32>(frag_position.xyz + normal_offset + depth_offset, frag_position.w);
+
+    let offset_position_clip = light.view_projection * offset_position;
+    if (offset_position_clip.w <= 0.0) {
+        return 1.0;
+    }
+    let offset_position_ndc = offset_position_clip.xyz / offset_position_clip.w;
+    // No shadow outside the orthographic projection volume
+    if (any(offset_position_ndc.xy < vec2<f32>(-1.0)) || offset_position_ndc.z < 0.0
+            || any(offset_position_ndc > vec3<f32>(1.0))) {
+        return 1.0;
+    }
+
+    // compute texture coordinates for shadow lookup, compensating for the Y-flip difference
+    // between the NDC and texture coordinates
+    let flip_correction = vec2<f32>(0.5, -0.5);
+    let light_local = offset_position_ndc.xy * flip_correction + vec2<f32>(0.5, 0.5);
+
+    let depth = offset_position_ndc.z;
+    // do the lookup, using HW PCF and comparison
+    // NOTE: Due to non-uniform control flow above, we must use the level variant of the texture
+    //       sampler to avoid use of implicit derivatives causing possible undefined behavior.
+    return textureSampleCompareLevel(directional_shadow_textures, directional_shadow_textures_sampler, light_local, i32(light_id), depth);
+}
+
+struct FragmentInput {
+    [[builtin(front_facing)]] is_front: bool;
+    [[location(0)]] world_position: vec4<f32>;
+    [[location(1)]] world_normal: vec3<f32>;
+    [[location(2)]] uv: vec2<f32>;
+#ifdef VERTEX_TANGENTS
+    [[location(3)]] world_tangent: vec4<f32>;
+#endif
+};
+
+[[stage(fragment)]]
+fn fragment(in: FragmentInput) -> [[location(0)]] vec4<f32> {
+    var output_color: vec4<f32> = material.base_color;
+    if ((material.flags & STANDARD_MATERIAL_FLAGS_BASE_COLOR_TEXTURE_BIT) != 0u) {
+        output_color = output_color * textureSample(base_color_texture, base_color_sampler, in.uv);
+    }
+
+    // // NOTE: Unlit bit not set means == 0 is true, so the true case is if lit
+    if ((material.flags & STANDARD_MATERIAL_FLAGS_UNLIT_BIT) == 0u) {
+        // TODO use .a for exposure compensation in HDR
+        var emissive: vec4<f32> = material.emissive;
+        if ((material.flags & STANDARD_MATERIAL_FLAGS_EMISSIVE_TEXTURE_BIT) != 0u) {
+            emissive = vec4<f32>(emissive.rgb * textureSample(emissive_texture, emissive_sampler, in.uv).rgb, 1.0);
+        }
+
+        // calculate non-linear roughness from linear perceptualRoughness
+        var metallic: f32 = material.metallic;
+        var perceptual_roughness: f32 = material.perceptual_roughness;
+        if ((material.flags & STANDARD_MATERIAL_FLAGS_METALLIC_ROUGHNESS_TEXTURE_BIT) != 0u) {
+            let metallic_roughness = textureSample(metallic_roughness_texture, metallic_roughness_sampler, in.uv);
+            // Sampling from GLTF standard channels for now
+            metallic = metallic * metallic_roughness.b;
+            perceptual_roughness = perceptual_roughness * metallic_roughness.g;
+        }
+        let roughness = perceptualRoughnessToRoughness(perceptual_roughness);
+
+        var occlusion: f32 = 1.0;
+        if ((material.flags & STANDARD_MATERIAL_FLAGS_OCCLUSION_TEXTURE_BIT) != 0u) {
+            occlusion = textureSample(occlusion_texture, occlusion_sampler, in.uv).r;
+        }
+
+        var N: vec3<f32> = normalize(in.world_normal);
+
+#ifdef VERTEX_TANGENTS
+#ifdef STANDARDMATERIAL_NORMAL_MAP
+        var T: vec3<f32> = normalize(in.world_tangent.xyz - N * dot(in.world_tangent.xyz, N));
+        var B: vec3<f32> = cross(N, T) * in.world_tangent.w;
+#endif
+#endif
+
+        if ((material.flags & STANDARD_MATERIAL_FLAGS_DOUBLE_SIDED_BIT) != 0u) {
+            if (!in.is_front) {
+                N = -N;
+#ifdef VERTEX_TANGENTS
+#ifdef STANDARDMATERIAL_NORMAL_MAP
+                T = -T;
+                B = -B;
+#endif
+#endif
+            }
+        }
+
+#ifdef VERTEX_TANGENTS
+#ifdef STANDARDMATERIAL_NORMAL_MAP
+        let TBN = mat3x3<f32>(T, B, N);
+        N = TBN * normalize(textureSample(normal_map_texture, normal_map_sampler, in.uv).rgb * 2.0 - 1.0);
+#endif
+#endif
+
+        if ((material.flags & STANDARD_MATERIAL_FLAGS_ALPHA_MODE_OPAQUE) != 0u) {
+            // NOTE: If rendering as opaque, alpha should be ignored so set to 1.0
+            output_color.a = 1.0;
+        } elseif ((material.flags & STANDARD_MATERIAL_FLAGS_ALPHA_MODE_MASK) != 0u) {
+            if (output_color.a >= material.alpha_cutoff) {
+                // NOTE: If rendering as masked alpha and >= the cutoff, render as fully opaque
+                output_color.a = 1.0;
+            } else {
+                // NOTE: output_color.a < material.alpha_cutoff should not is not rendered
+                // NOTE: This and any other discards mean that early-z testing cannot be done!
+                discard;
+            }
+        }
+
+        var V: vec3<f32>;
+        if (view.projection[3].w != 1.0) { // If the projection is not orthographic
+            // Only valid for a perpective projection
+            V = normalize(view.world_position.xyz - in.world_position.xyz);
+        } else {
+            // Ortho view vec
+            V = normalize(vec3<f32>(view.view_proj[0].z, view.view_proj[1].z, view.view_proj[2].z));
+        }
+
+        // Neubelt and Pettineo 2013, "Crafting a Next-gen Material Pipeline for The Order: 1886"
+        let NdotV = max(dot(N, V), 0.0001);
+
+        // Remapping [0,1] reflectance to F0
+        // See https://google.github.io/filament/Filament.html#materialsystem/parameterization/remapping
+        let reflectance = material.reflectance;
+        let F0 = 0.16 * reflectance * reflectance * (1.0 - metallic) + output_color.rgb * metallic;
+
+        // Diffuse strength inversely related to metallicity
+        let diffuse_color = output_color.rgb * (1.0 - metallic);
+
+        let R = reflect(-V, N);
+
+        // accumulate color
+        var light_accum: vec3<f32> = vec3<f32>(0.0);
+        let n_point_lights = i32(lights.n_point_lights);
+        let n_directional_lights = i32(lights.n_directional_lights);
+        for (var i: i32 = 0; i < n_point_lights; i = i + 1) {
+            let light = lights.point_lights[i];
+            var shadow: f32;
+            if ((mesh.flags & MESH_FLAGS_SHADOW_RECEIVER_BIT) != 0u
+                    || (light.flags & POINT_LIGHT_FLAGS_SHADOWS_ENABLED_BIT) != 0u) {
+                shadow = fetch_point_shadow(i, in.world_position, in.world_normal);
+            } else {
+                shadow = 1.0;
+            }
+            let light_contrib = point_light(in.world_position.xyz, light, roughness, NdotV, N, V, R, F0, diffuse_color);
+            light_accum = light_accum + light_contrib * shadow;
+        }
+        for (var i: i32 = 0; i < n_directional_lights; i = i + 1) {
+            let light = lights.directional_lights[i];
+            var shadow: f32;
+            if ((mesh.flags & MESH_FLAGS_SHADOW_RECEIVER_BIT) != 0u
+                    || (light.flags & DIRECTIONAL_LIGHT_FLAGS_SHADOWS_ENABLED_BIT) != 0u) {
+                shadow = fetch_directional_shadow(i, in.world_position, in.world_normal);
+            } else {
+                shadow = 1.0;
+            }
+            let light_contrib = directional_light(light, roughness, NdotV, N, V, R, F0, diffuse_color);
+            light_accum = light_accum + light_contrib * shadow;
+        }
+
+        let diffuse_ambient = EnvBRDFApprox(diffuse_color, 1.0, NdotV);
+        let specular_ambient = EnvBRDFApprox(F0, perceptual_roughness, NdotV);
+
+        output_color = vec4<f32>(
+            light_accum +
+                (diffuse_ambient + specular_ambient) * lights.ambient_color.rgb * occlusion +
+                emissive.rgb * output_color.a,
+            output_color.a);
+
+        // tone_mapping
+        output_color = vec4<f32>(reinhard_luminance(output_color.rgb), output_color.a);
+        // Gamma correction.
+        // Not needed with sRGB buffer
+        // output_color.rgb = pow(output_color.rgb, vec3(1.0 / 2.2));
+    }
+
+    return output_color;
+}
diff --git a/pipelined/bevy_render2/Cargo.toml b/pipelined/bevy_render2/Cargo.toml
new file mode 100644
index 0000000000..87b00c16af
--- /dev/null
+++ b/pipelined/bevy_render2/Cargo.toml
@@ -0,0 +1,58 @@
+[package]
+name = "bevy_render2"
+version = "0.5.0"
+edition = "2021"
+authors = [
+    "Bevy Contributors <bevyengine@gmail.com>",
+    "Carter Anderson <mcanders1@gmail.com>",
+]
+description = "Provides rendering functionality for Bevy Engine"
+homepage = "https://bevyengine.org"
+repository = "https://github.com/bevyengine/bevy"
+license = "MIT"
+keywords = ["bevy"]
+
+[dependencies]
+# bevy
+bevy_app = { path = "../../crates/bevy_app", version = "0.5.0" }
+bevy_asset = { path = "../../crates/bevy_asset", version = "0.5.0" }
+bevy_core = { path = "../../crates/bevy_core", version = "0.5.0" }
+bevy_derive = { path = "../../crates/bevy_derive", version = "0.5.0" }
+bevy_ecs = { path = "../../crates/bevy_ecs", version = "0.5.0" }
+bevy_math = { path = "../../crates/bevy_math", version = "0.5.0" }
+bevy_reflect = { path = "../../crates/bevy_reflect", version = "0.5.0", features = ["bevy"] }
+bevy_transform = { path = "../../crates/bevy_transform", version = "0.5.0" }
+bevy_window = { path = "../../crates/bevy_window", version = "0.5.0" }
+bevy_utils = { path = "../../crates/bevy_utils", version = "0.5.0" }
+
+# rendering
+image = { version = "0.23.12", default-features = false }
+
+# misc
+wgpu = { version = "0.11.0", features = ["spirv"] }
+naga = { version = "0.7.0", features = ["glsl-in", "spv-in", "spv-out", "wgsl-in", "wgsl-out"] }
+serde = { version = "1", features = ["derive"] }
+bitflags = "1.2.1"
+smallvec = { version = "1.6", features = ["union", "const_generics"] }
+once_cell = "1.4.1" # TODO: replace once_cell with std equivalent if/when this lands: https://github.com/rust-lang/rfcs/pull/2788
+downcast-rs = "1.2.0"
+thiserror = "1.0"
+futures-lite = "1.4.0"
+anyhow = "1.0"
+hex = "0.4.2"
+hexasphere = "6.0.0"
+parking_lot = "0.11.0"
+regex = "1.5"
+crevice = { path = "../../crates/crevice", version = "0.8.0", features = ["glam"] }
+
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+wgpu = { version = "0.11.0", features = ["spirv", "webgl"] }
+
+[features]
+png = ["image/png"]
+hdr = ["image/hdr"]
+dds = ["image/dds"]
+tga = ["image/tga"]
+jpeg = ["image/jpeg"]
+bmp = ["image/bmp"]
+trace = []
diff --git a/pipelined/bevy_render2/src/camera/active_cameras.rs b/pipelined/bevy_render2/src/camera/active_cameras.rs
new file mode 100644
index 0000000000..8f7af81f12
--- /dev/null
+++ b/pipelined/bevy_render2/src/camera/active_cameras.rs
@@ -0,0 +1,73 @@
+use super::Camera;
+use bevy_ecs::{
+    entity::Entity,
+    system::{Query, ResMut},
+};
+use bevy_utils::HashMap;
+
+#[derive(Debug, Default)]
+pub struct ActiveCamera {
+    pub name: String,
+    pub entity: Option<Entity>,
+}
+
+#[derive(Debug, Default)]
+pub struct ActiveCameras {
+    cameras: HashMap<String, ActiveCamera>,
+}
+
+impl ActiveCameras {
+    pub fn add(&mut self, name: &str) {
+        self.cameras.insert(
+            name.to_string(),
+            ActiveCamera {
+                name: name.to_string(),
+                ..Default::default()
+            },
+        );
+    }
+
+    pub fn get(&self, name: &str) -> Option<&ActiveCamera> {
+        self.cameras.get(name)
+    }
+
+    pub fn get_mut(&mut self, name: &str) -> Option<&mut ActiveCamera> {
+        self.cameras.get_mut(name)
+    }
+
+    pub fn remove(&mut self, name: &str) -> Option<ActiveCamera> {
+        self.cameras.remove(name)
+    }
+
+    pub fn iter(&self) -> impl Iterator<Item = &ActiveCamera> {
+        self.cameras.values()
+    }
+
+    pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut ActiveCamera> {
+        self.cameras.values_mut()
+    }
+}
+
+pub fn active_cameras_system(
+    mut active_cameras: ResMut<ActiveCameras>,
+    query: Query<(Entity, &Camera)>,
+) {
+    for (name, active_camera) in active_cameras.cameras.iter_mut() {
+        if active_camera
+            .entity
+            .map_or(false, |entity| query.get(entity).is_err())
+        {
+            active_camera.entity = None;
+        }
+
+        if active_camera.entity.is_none() {
+            for (camera_entity, camera) in query.iter() {
+                if let Some(ref current_name) = camera.name {
+                    if current_name == name {
+                        active_camera.entity = Some(camera_entity);
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/pipelined/bevy_render2/src/camera/bundle.rs b/pipelined/bevy_render2/src/camera/bundle.rs
new file mode 100644
index 0000000000..31beff655b
--- /dev/null
+++ b/pipelined/bevy_render2/src/camera/bundle.rs
@@ -0,0 +1,154 @@
+use crate::{
+    camera::{
+        Camera, CameraPlugin, DepthCalculation, OrthographicProjection, PerspectiveProjection,
+        ScalingMode,
+    },
+    primitives::Frustum,
+    view::VisibleEntities,
+};
+use bevy_ecs::bundle::Bundle;
+use bevy_math::Vec3;
+use bevy_transform::components::{GlobalTransform, Transform};
+
+use super::CameraProjection;
+
+/// Component bundle for camera entities with perspective projection
+///
+/// Use this for 3D rendering.
+#[derive(Bundle)]
+pub struct PerspectiveCameraBundle {
+    pub camera: Camera,
+    pub perspective_projection: PerspectiveProjection,
+    pub visible_entities: VisibleEntities,
+    pub frustum: Frustum,
+    pub transform: Transform,
+    pub global_transform: GlobalTransform,
+}
+
+impl PerspectiveCameraBundle {
+    pub fn new_3d() -> Self {
+        Default::default()
+    }
+
+    pub fn with_name(name: &str) -> Self {
+        let perspective_projection = PerspectiveProjection::default();
+        let view_projection = perspective_projection.get_projection_matrix();
+        let frustum = Frustum::from_view_projection(
+            &view_projection,
+            &Vec3::ZERO,
+            &Vec3::Z,
+            perspective_projection.far(),
+        );
+        PerspectiveCameraBundle {
+            camera: Camera {
+                name: Some(name.to_string()),
+                ..Default::default()
+            },
+            perspective_projection,
+            visible_entities: VisibleEntities::default(),
+            frustum,
+            transform: Default::default(),
+            global_transform: Default::default(),
+        }
+    }
+}
+
+impl Default for PerspectiveCameraBundle {
+    fn default() -> Self {
+        PerspectiveCameraBundle::with_name(CameraPlugin::CAMERA_3D)
+    }
+}
+
+/// Component bundle for camera entities with orthographic projection
+///
+/// Use this for 2D games, isometric games, CAD-like 3D views.
+#[derive(Bundle)]
+pub struct OrthographicCameraBundle {
+    pub camera: Camera,
+    pub orthographic_projection: OrthographicProjection,
+    pub visible_entities: VisibleEntities,
+    pub frustum: Frustum,
+    pub transform: Transform,
+    pub global_transform: GlobalTransform,
+}
+
+impl OrthographicCameraBundle {
+    pub fn new_2d() -> Self {
+        // we want 0 to be "closest" and +far to be "farthest" in 2d, so we offset
+        // the camera's translation by far and use a right handed coordinate system
+        let far = 1000.0;
+        let orthographic_projection = OrthographicProjection {
+            far,
+            depth_calculation: DepthCalculation::ZDifference,
+            ..Default::default()
+        };
+        let transform = Transform::from_xyz(0.0, 0.0, far - 0.1);
+        let view_projection =
+            orthographic_projection.get_projection_matrix() * transform.compute_matrix().inverse();
+        let frustum = Frustum::from_view_projection(
+            &view_projection,
+            &transform.translation,
+            &transform.back(),
+            orthographic_projection.far(),
+        );
+        OrthographicCameraBundle {
+            camera: Camera {
+                name: Some(CameraPlugin::CAMERA_2D.to_string()),
+                ..Default::default()
+            },
+            orthographic_projection,
+            visible_entities: VisibleEntities::default(),
+            frustum,
+            transform,
+            global_transform: Default::default(),
+        }
+    }
+
+    pub fn new_3d() -> Self {
+        let orthographic_projection = OrthographicProjection {
+            scaling_mode: ScalingMode::FixedVertical,
+            depth_calculation: DepthCalculation::Distance,
+            ..Default::default()
+        };
+        let view_projection = orthographic_projection.get_projection_matrix();
+        let frustum = Frustum::from_view_projection(
+            &view_projection,
+            &Vec3::ZERO,
+            &Vec3::Z,
+            orthographic_projection.far(),
+        );
+        OrthographicCameraBundle {
+            camera: Camera {
+                name: Some(CameraPlugin::CAMERA_3D.to_string()),
+                ..Default::default()
+            },
+            orthographic_projection,
+            visible_entities: VisibleEntities::default(),
+            frustum,
+            transform: Default::default(),
+            global_transform: Default::default(),
+        }
+    }
+
+    pub fn with_name(name: &str) -> Self {
+        let orthographic_projection = OrthographicProjection::default();
+        let view_projection = orthographic_projection.get_projection_matrix();
+        let frustum = Frustum::from_view_projection(
+            &view_projection,
+            &Vec3::ZERO,
+            &Vec3::Z,
+            orthographic_projection.far(),
+        );
+        OrthographicCameraBundle {
+            camera: Camera {
+                name: Some(name.to_string()),
+                ..Default::default()
+            },
+            orthographic_projection,
+            visible_entities: VisibleEntities::default(),
+            frustum,
+            transform: Default::default(),
+            global_transform: Default::default(),
+        }
+    }
+}
diff --git a/pipelined/bevy_render2/src/camera/camera.rs b/pipelined/bevy_render2/src/camera/camera.rs
new file mode 100644
index 0000000000..7a05bbe9ff
--- /dev/null
+++ b/pipelined/bevy_render2/src/camera/camera.rs
@@ -0,0 +1,114 @@
+use crate::camera::CameraProjection;
+use bevy_ecs::{
+    component::Component,
+    entity::Entity,
+    event::EventReader,
+    prelude::{DetectChanges, QueryState},
+    query::Added,
+    reflect::ReflectComponent,
+    system::{QuerySet, Res},
+};
+use bevy_math::{Mat4, Vec2, Vec3};
+use bevy_reflect::{Reflect, ReflectDeserialize};
+use bevy_transform::components::GlobalTransform;
+use bevy_window::{WindowCreated, WindowId, WindowResized, Windows};
+use serde::{Deserialize, Serialize};
+
+#[derive(Component, Default, Debug, Reflect)]
+#[reflect(Component)]
+pub struct Camera {
+    pub projection_matrix: Mat4,
+    pub name: Option<String>,
+    #[reflect(ignore)]
+    pub window: WindowId,
+    #[reflect(ignore)]
+    pub depth_calculation: DepthCalculation,
+}
+
+#[derive(Debug, Clone, Copy, Reflect, Serialize, Deserialize)]
+#[reflect_value(Serialize, Deserialize)]
+pub enum DepthCalculation {
+    /// Pythagorean distance; works everywhere, more expensive to compute.
+    Distance,
+    /// Optimization for 2D; assuming the camera points towards -Z.
+    ZDifference,
+}
+
+impl Default for DepthCalculation {
+    fn default() -> Self {
+        DepthCalculation::Distance
+    }
+}
+
+impl Camera {
+    /// Given a position in world space, use the camera to compute the screen space coordinates.
+    pub fn world_to_screen(
+        &self,
+        windows: &Windows,
+        camera_transform: &GlobalTransform,
+        world_position: Vec3,
+    ) -> Option<Vec2> {
+        let window = windows.get(self.window)?;
+        let window_size = Vec2::new(window.width(), window.height());
+        // Build a transform to convert from world to NDC using camera data
+        let world_to_ndc: Mat4 =
+            self.projection_matrix * camera_transform.compute_matrix().inverse();
+        let ndc_space_coords: Vec3 = world_to_ndc.project_point3(world_position);
+        // NDC z-values outside of 0 < z < 1 are behind the camera and are thus not in screen space
+        if ndc_space_coords.z < 0.0 || ndc_space_coords.z > 1.0 {
+            return None;
+        }
+        // Once in NDC space, we can discard the z element and rescale x/y to fit the screen
+        let screen_space_coords = (ndc_space_coords.truncate() + Vec2::ONE) / 2.0 * window_size;
+        Some(screen_space_coords)
+    }
+}
+
+#[allow(clippy::type_complexity)]
+pub fn camera_system<T: CameraProjection + Component>(
+    mut window_resized_events: EventReader<WindowResized>,
+    mut window_created_events: EventReader<WindowCreated>,
+    windows: Res<Windows>,
+    mut queries: QuerySet<(
+        QueryState<(Entity, &mut Camera, &mut T)>,
+        QueryState<Entity, Added<Camera>>,
+    )>,
+) {
+    let mut changed_window_ids = Vec::new();
+    // handle resize events. latest events are handled first because we only want to resize each
+    // window once
+    for event in window_resized_events.iter().rev() {
+        if changed_window_ids.contains(&event.id) {
+            continue;
+        }
+
+        changed_window_ids.push(event.id);
+    }
+
+    // handle resize events. latest events are handled first because we only want to resize each
+    // window once
+    for event in window_created_events.iter().rev() {
+        if changed_window_ids.contains(&event.id) {
+            continue;
+        }
+
+        changed_window_ids.push(event.id);
+    }
+
+    let mut added_cameras = vec![];
+    for entity in &mut queries.q1().iter() {
+        added_cameras.push(entity);
+    }
+    for (entity, mut camera, mut camera_projection) in queries.q0().iter_mut() {
+        if let Some(window) = windows.get(camera.window) {
+            if changed_window_ids.contains(&window.id())
+                || added_cameras.contains(&entity)
+                || camera_projection.is_changed()
+            {
+                camera_projection.update(window.width(), window.height());
+                camera.projection_matrix = camera_projection.get_projection_matrix();
+                camera.depth_calculation = camera_projection.depth_calculation();
+            }
+        }
+    }
+}
diff --git a/pipelined/bevy_render2/src/camera/mod.rs b/pipelined/bevy_render2/src/camera/mod.rs
new file mode 100644
index 0000000000..4e2c146ea7
--- /dev/null
+++ b/pipelined/bevy_render2/src/camera/mod.rs
@@ -0,0 +1,99 @@
+mod active_cameras;
+mod bundle;
+#[allow(clippy::module_inception)]
+mod camera;
+mod projection;
+
+pub use active_cameras::*;
+use bevy_transform::components::GlobalTransform;
+use bevy_utils::HashMap;
+use bevy_window::{WindowId, Windows};
+pub use bundle::*;
+pub use camera::*;
+pub use projection::*;
+
+use crate::{
+    primitives::Aabb,
+    view::{ComputedVisibility, ExtractedView, Visibility, VisibleEntities},
+    RenderApp, RenderStage,
+};
+use bevy_app::{App, CoreStage, Plugin};
+use bevy_ecs::prelude::*;
+
+#[derive(Default)]
+pub struct CameraPlugin;
+
+impl CameraPlugin {
+    pub const CAMERA_2D: &'static str = "camera_2d";
+    pub const CAMERA_3D: &'static str = "camera_3d";
+}
+
+impl Plugin for CameraPlugin {
+    fn build(&self, app: &mut App) {
+        let mut active_cameras = ActiveCameras::default();
+        active_cameras.add(Self::CAMERA_2D);
+        active_cameras.add(Self::CAMERA_3D);
+        app.register_type::<Camera>()
+            .register_type::<Visibility>()
+            .register_type::<ComputedVisibility>()
+            .register_type::<Aabb>()
+            .insert_resource(active_cameras)
+            .add_system_to_stage(CoreStage::PostUpdate, crate::camera::active_cameras_system)
+            .add_system_to_stage(
+                CoreStage::PostUpdate,
+                crate::camera::camera_system::<OrthographicProjection>,
+            )
+            .add_system_to_stage(
+                CoreStage::PostUpdate,
+                crate::camera::camera_system::<PerspectiveProjection>,
+            );
+        app.sub_app(RenderApp)
+            .init_resource::<ExtractedCameraNames>()
+            .add_system_to_stage(RenderStage::Extract, extract_cameras);
+    }
+}
+
+#[derive(Default)]
+pub struct ExtractedCameraNames {
+    pub entities: HashMap<String, Entity>,
+}
+
+#[derive(Component, Debug)]
+pub struct ExtractedCamera {
+    pub window_id: WindowId,
+    pub name: Option<String>,
+}
+
+fn extract_cameras(
+    mut commands: Commands,
+    active_cameras: Res<ActiveCameras>,
+    windows: Res<Windows>,
+    query: Query<(Entity, &Camera, &GlobalTransform, &VisibleEntities)>,
+) {
+    let mut entities = HashMap::default();
+    for camera in active_cameras.iter() {
+        let name = &camera.name;
+        if let Some((entity, camera, transform, visible_entities)) =
+            camera.entity.and_then(|e| query.get(e).ok())
+        {
+            entities.insert(name.clone(), entity);
+            if let Some(window) = windows.get(camera.window) {
+                commands.get_or_spawn(entity).insert_bundle((
+                    ExtractedCamera {
+                        window_id: camera.window,
+                        name: camera.name.clone(),
+                    },
+                    ExtractedView {
+                        projection: camera.projection_matrix,
+                        transform: *transform,
+                        width: window.physical_width().max(1),
+                        height: window.physical_height().max(1),
+                    },
+                    visible_entities.clone(),
+                ));
+            }
+        }
+    }
+
+    commands.insert_resource(ExtractedCameraNames { entities })
+}
diff --git a/pipelined/bevy_render2/src/camera/projection.rs b/pipelined/bevy_render2/src/camera/projection.rs
new file mode 100644
index 0000000000..b0ea170c75
--- /dev/null
+++ b/pipelined/bevy_render2/src/camera/projection.rs
@@ -0,0 +1,175 @@
+use super::DepthCalculation;
+use bevy_ecs::{component::Component, reflect::ReflectComponent};
+use bevy_math::Mat4;
+use bevy_reflect::{Reflect, ReflectDeserialize};
+use serde::{Deserialize, Serialize};
+
+pub trait CameraProjection {
+    fn get_projection_matrix(&self) -> Mat4;
+    fn update(&mut self, width: f32, height: f32);
+    fn depth_calculation(&self) -> DepthCalculation;
+    fn far(&self) -> f32;
+}
+
+#[derive(Component, Debug, Clone, Reflect)]
+#[reflect(Component)]
+pub struct PerspectiveProjection {
+    pub fov: f32,
+    pub aspect_ratio: f32,
+    pub near: f32,
+    pub far: f32,
+}
+
+impl CameraProjection for PerspectiveProjection {
+    fn get_projection_matrix(&self) -> Mat4 {
+        Mat4::perspective_infinite_reverse_rh(self.fov, self.aspect_ratio, self.near)
+    }
+
+    fn update(&mut self, width: f32, height: f32) {
+        self.aspect_ratio = width / height;
+    }
+
+    fn depth_calculation(&self) -> DepthCalculation {
+        DepthCalculation::Distance
+    }
+
+    fn far(&self) -> f32 {
+        self.far
+    }
+}
+
+impl Default for PerspectiveProjection {
+    fn default() -> Self {
+        PerspectiveProjection {
+            fov: std::f32::consts::PI / 4.0,
+            near: 0.1,
+            far: 1000.0,
+            aspect_ratio: 1.0,
+        }
+    }
+}
+
+// TODO: make this a component instead of a property
+#[derive(Debug, Clone, Reflect, Serialize, Deserialize)]
+#[reflect_value(Serialize, Deserialize)]
+pub enum WindowOrigin {
+    Center,
+    BottomLeft,
+}
+
+#[derive(Debug, Clone, Reflect, Serialize, Deserialize)]
+#[reflect_value(Serialize, Deserialize)]
+pub enum ScalingMode {
+    /// Manually specify left/right/top/bottom values.
+    /// Ignore window resizing; the image will stretch.
+    None,
+    /// Match the window size. 1 world unit = 1 pixel.
+    WindowSize,
+    /// Keep vertical axis constant; resize horizontal with aspect ratio.
+    FixedVertical,
+    /// Keep horizontal axis constant; resize vertical with aspect ratio.
+    FixedHorizontal,
+}
+
+#[derive(Component, Debug, Clone, Reflect)]
+#[reflect(Component)]
+pub struct OrthographicProjection {
+    pub left: f32,
+    pub right: f32,
+    pub bottom: f32,
+    pub top: f32,
+    pub near: f32,
+    pub far: f32,
+    pub window_origin: WindowOrigin,
+    pub scaling_mode: ScalingMode,
+    pub scale: f32,
+    pub depth_calculation: DepthCalculation,
+}
+
+impl CameraProjection for OrthographicProjection {
+    fn get_projection_matrix(&self) -> Mat4 {
+        Mat4::orthographic_rh(
+            self.left * self.scale,
+            self.right * self.scale,
+            self.bottom * self.scale,
+            self.top * self.scale,
+            // NOTE: near and far are swapped to invert the depth range from [0,1] to [1,0]
+            // This is for interoperability with pipelines using infinite reverse perspective projections.
+            self.far,
+            self.near,
+        )
+    }
+
+    fn update(&mut self, width: f32, height: f32) {
+        match (&self.scaling_mode, &self.window_origin) {
+            (ScalingMode::WindowSize, WindowOrigin::Center) => {
+                let half_width = width / 2.0;
+                let half_height = height / 2.0;
+                self.left = -half_width;
+                self.right = half_width;
+                self.top = half_height;
+                self.bottom = -half_height;
+            }
+            (ScalingMode::WindowSize, WindowOrigin::BottomLeft) => {
+                self.left = 0.0;
+                self.right = width;
+                self.top = height;
+                self.bottom = 0.0;
+            }
+            (ScalingMode::FixedVertical, WindowOrigin::Center) => {
+                let aspect_ratio = width / height;
+                self.left = -aspect_ratio;
+                self.right = aspect_ratio;
+                self.top = 1.0;
+                self.bottom = -1.0;
+            }
+            (ScalingMode::FixedVertical, WindowOrigin::BottomLeft) => {
+                let aspect_ratio = width / height;
+                self.left = 0.0;
+                self.right = aspect_ratio;
+                self.top = 1.0;
+                self.bottom = 0.0;
+            }
+            (ScalingMode::FixedHorizontal, WindowOrigin::Center) => {
+                let aspect_ratio = height / width;
+                self.left = -1.0;
+                self.right = 1.0;
+                self.top = aspect_ratio;
+                self.bottom = -aspect_ratio;
+            }
+            (ScalingMode::FixedHorizontal, WindowOrigin::BottomLeft) => {
+                let aspect_ratio = height / width;
+                self.left = 0.0;
+                self.right = 1.0;
+                self.top = aspect_ratio;
+                self.bottom = 0.0;
+            }
+            (ScalingMode::None, _) => {}
+        }
+    }
+
+    fn depth_calculation(&self) -> DepthCalculation {
+        self.depth_calculation
+    }
+
+    fn far(&self) -> f32 {
+        self.far
+    }
+}
+
+impl Default for OrthographicProjection {
+    fn default() -> Self {
+        OrthographicProjection {
+            left: -1.0,
+            right: 1.0,
+            bottom: -1.0,
+            top: 1.0,
+            near: 0.0,
+            far: 1000.0,
+            window_origin: WindowOrigin::Center,
+            scaling_mode: ScalingMode::WindowSize,
+            scale: 1.0,
+            depth_calculation: DepthCalculation::Distance,
+        }
+    }
+}
diff --git a/pipelined/bevy_render2/src/color/colorspace.rs b/pipelined/bevy_render2/src/color/colorspace.rs
new file mode 100644
index 0000000000..43d3f7986f
--- /dev/null
+++ b/pipelined/bevy_render2/src/color/colorspace.rs
@@ -0,0 +1,205 @@
+pub trait SrgbColorSpace {
+    fn linear_to_nonlinear_srgb(self) -> Self;
+    fn nonlinear_to_linear_srgb(self) -> Self;
+}
+
+// source: https://entropymine.com/imageworsener/srgbformula/
+impl SrgbColorSpace for f32 {
+    #[inline]
+    fn linear_to_nonlinear_srgb(self) -> f32 {
+        if self <= 0.0 {
+            return self;
+        }
+
+        if self <= 0.0031308 {
+            self * 12.92 // linear falloff in dark values
+        } else {
+            (1.055 * self.powf(1.0 / 2.4)) - 0.055 // gamma curve in other area
+        }
+    }
+
+    #[inline]
+    fn nonlinear_to_linear_srgb(self) -> f32 {
+        if self <= 0.0 {
+            return self;
+        }
+        if self <= 0.04045 {
+            self / 12.92 // linear falloff in dark values
+        } else {
+            ((self + 0.055) / 1.055).powf(2.4) // gamma curve in other area
+        }
+    }
+}
+
+pub struct HslRepresentation;
+impl HslRepresentation {
+    /// converts a color in HLS space to sRGB space
+    #[inline]
+    pub fn hsl_to_nonlinear_srgb(hue: f32, saturation: f32, lightness: f32) -> [f32; 3] {
+        // https://en.wikipedia.org/wiki/HSL_and_HSV#HSL_to_RGB
+        let chroma = (1.0 - (2.0 * lightness - 1.0).abs()) * saturation;
+        let hue_prime = hue / 60.0;
+        let largest_component = chroma * (1.0 - (hue_prime % 2.0 - 1.0).abs());
+        let (r_temp, g_temp, b_temp) = if hue_prime < 1.0 {
+            (chroma, largest_component, 0.0)
+        } else if hue_prime < 2.0 {
+            (largest_component, chroma, 0.0)
+        } else if hue_prime < 3.0 {
+            (0.0, chroma, largest_component)
+        } else if hue_prime < 4.0 {
+            (0.0, largest_component, chroma)
+        } else if hue_prime < 5.0 {
+            (largest_component, 0.0, chroma)
+        } else {
+            (chroma, 0.0, largest_component)
+        };
+        let lightness_match = lightness - chroma / 2.0;
+
+        [
+            r_temp + lightness_match,
+            g_temp + lightness_match,
+            b_temp + lightness_match,
+        ]
+    }
+
+    /// converts a color in sRGB space to HLS space
+    #[inline]
+    pub fn nonlinear_srgb_to_hsl([red, green, blue]: [f32; 3]) -> (f32, f32, f32) {
+        // https://en.wikipedia.org/wiki/HSL_and_HSV#From_RGB
+        let x_max = red.max(green.max(blue));
+        let x_min = red.min(green.min(blue));
+        let chroma = x_max - x_min;
+        let lightness = (x_max + x_min) / 2.0;
+        let hue = if chroma == 0.0 {
+            0.0
+        } else if red > green && red > blue {
+            60.0 * (green - blue) / chroma
+        } else if green > red && green > blue {
+            60.0 * (2.0 + (blue - red) / chroma)
+        } else {
+            60.0 * (4.0 + (red - green) / chroma)
+        };
+        let hue = if hue < 0.0 { 360.0 + hue } else { hue };
+        let saturation = if lightness <= 0.0 || lightness >= 1.0 {
+            0.0
+        } else {
+            (x_max - lightness) / lightness.min(1.0 - lightness)
+        };
+
+        (hue, saturation, lightness)
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn srgb_linear_full_roundtrip() {
+        let u8max: f32 = u8::max_value() as f32;
+        for color in 0..u8::max_value() {
+            let color01 = color as f32 / u8max;
+            let color_roundtrip = color01
+                .linear_to_nonlinear_srgb()
+                .nonlinear_to_linear_srgb();
+            // roundtrip is not perfect due to numeric precision, even with f64
+            // so ensure the error is at least ready for u8 (where sRGB is used)
+            assert_eq!(
+                (color01 * u8max).round() as u8,
+                (color_roundtrip * u8max).round() as u8
+            );
+        }
+    }
+
+    #[test]
+    fn hsl_to_srgb() {
+        // "truth" from https://en.wikipedia.org/wiki/HSL_and_HSV#Examples
+
+        // black
+        let (hue, saturation, lightness) = (0.0, 0.0, 0.0);
+        let [r, g, b] = HslRepresentation::hsl_to_nonlinear_srgb(hue, saturation, lightness);
+        assert_eq!((r * 100.0).round() as u32, 0);
+        assert_eq!((g * 100.0).round() as u32, 0);
+        assert_eq!((b * 100.0).round() as u32, 0);
+
+        // white
+        let (hue, saturation, lightness) = (0.0, 0.0, 1.0);
+        let [r, g, b] = HslRepresentation::hsl_to_nonlinear_srgb(hue, saturation, lightness);
+        assert_eq!((r * 100.0).round() as u32, 100);
+        assert_eq!((g * 100.0).round() as u32, 100);
+        assert_eq!((b * 100.0).round() as u32, 100);
+
+        let (hue, saturation, lightness) = (300.0, 0.5, 0.5);
+        let [r, g, b] = HslRepresentation::hsl_to_nonlinear_srgb(hue, saturation, lightness);
+        assert_eq!((r * 100.0).round() as u32, 75);
+        assert_eq!((g * 100.0).round() as u32, 25);
+        assert_eq!((b * 100.0).round() as u32, 75);
+
+        // a red
+        let (hue, saturation, lightness) = (283.7, 0.775, 0.543);
+        let [r, g, b] = HslRepresentation::hsl_to_nonlinear_srgb(hue, saturation, lightness);
+        assert_eq!((r * 100.0).round() as u32, 70);
+        assert_eq!((g * 100.0).round() as u32, 19);
+        assert_eq!((b * 100.0).round() as u32, 90);
+
+        // a green
+        let (hue, saturation, lightness) = (162.4, 0.779, 0.447);
+        let [r, g, b] = HslRepresentation::hsl_to_nonlinear_srgb(hue, saturation, lightness);
+        assert_eq!((r * 100.0).round() as u32, 10);
+        assert_eq!((g * 100.0).round() as u32, 80);
+        assert_eq!((b * 100.0).round() as u32, 59);
+
+        // a blue
+        let (hue, saturation, lightness) = (251.1, 0.832, 0.511);
+        let [r, g, b] = HslRepresentation::hsl_to_nonlinear_srgb(hue, saturation, lightness);
+        assert_eq!((r * 100.0).round() as u32, 25);
+        assert_eq!((g * 100.0).round() as u32, 10);
+        assert_eq!((b * 100.0).round() as u32, 92);
+    }
+
+    #[test]
+    fn srgb_to_hsl() {
+        // "truth" from https://en.wikipedia.org/wiki/HSL_and_HSV#Examples
+
+        // black
+        let (hue, saturation, lightness) =
+            HslRepresentation::nonlinear_srgb_to_hsl([0.0, 0.0, 0.0]);
+        assert_eq!(hue.round() as u32, 0);
+        assert_eq!((saturation * 100.0).round() as u32, 0);
+        assert_eq!((lightness * 100.0).round() as u32, 0);
+
+        // white
+        let (hue, saturation, lightness) =
+            HslRepresentation::nonlinear_srgb_to_hsl([1.0, 1.0, 1.0]);
+        assert_eq!(hue.round() as u32, 0);
+        assert_eq!((saturation * 100.0).round() as u32, 0);
+        assert_eq!((lightness * 100.0).round() as u32, 100);
+
+        let (hue, saturation, lightness) =
+            HslRepresentation::nonlinear_srgb_to_hsl([0.75, 0.25, 0.75]);
+        assert_eq!(hue.round() as u32, 300);
+        assert_eq!((saturation * 100.0).round() as u32, 50);
+        assert_eq!((lightness * 100.0).round() as u32, 50);
+
+        // a red
+        let (hue, saturation, lightness) =
+            HslRepresentation::nonlinear_srgb_to_hsl([0.704, 0.187, 0.897]);
+        assert_eq!(hue.round() as u32, 284);
+        assert_eq!((saturation * 100.0).round() as u32, 78);
+        assert_eq!((lightness * 100.0).round() as u32, 54);
+
+        // a green
+        let (hue, saturation, lightness) =
+            HslRepresentation::nonlinear_srgb_to_hsl([0.099, 0.795, 0.591]);
+        assert_eq!(hue.round() as u32, 162);
+        assert_eq!((saturation * 100.0).round() as u32, 78);
+        assert_eq!((lightness * 100.0).round() as u32, 45);
+
+        // a blue
+        let (hue, saturation, lightness) =
+            HslRepresentation::nonlinear_srgb_to_hsl([0.255, 0.104, 0.918]);
+        assert_eq!(hue.round() as u32, 251);
+        assert_eq!((saturation * 100.0).round() as u32, 83);
+        assert_eq!((lightness * 100.0).round() as u32, 51);
+    }
+}
diff --git a/pipelined/bevy_render2/src/color/mod.rs b/pipelined/bevy_render2/src/color/mod.rs
new file mode 100644
index 0000000000..8f4e666352
--- /dev/null
+++ b/pipelined/bevy_render2/src/color/mod.rs
@@ -0,0 +1,1239 @@
+mod colorspace;
+
+pub use colorspace::*;
+
+use crate::color::{HslRepresentation, SrgbColorSpace};
+use bevy_core::Bytes;
+use bevy_math::{Vec3, Vec4};
+use bevy_reflect::{Reflect, ReflectDeserialize};
+use serde::{Deserialize, Serialize};
+use std::ops::{Add, AddAssign, Mul, MulAssign};
+
+#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize, Reflect)]
+#[reflect(PartialEq, Serialize, Deserialize)]
+pub enum Color {
+    /// sRGBA color
+    Rgba {
+        /// Red component. [0.0, 1.0]
+        red: f32,
+        /// Green component. [0.0, 1.0]
+        green: f32,
+        /// Blue component. [0.0, 1.0]
+        blue: f32,
+        /// Alpha component. [0.0, 1.0]
+        alpha: f32,
+    },
+    /// RGBA color in the Linear sRGB colorspace (often colloquially referred to as "linear", "RGB", or "linear RGB").
+    RgbaLinear {
+        /// Red component. [0.0, 1.0]
+        red: f32,
+        /// Green component. [0.0, 1.0]
+        green: f32,
+        /// Blue component. [0.0, 1.0]
+        blue: f32,
+        /// Alpha component. [0.0, 1.0]
+        alpha: f32,
+    },
+    /// HSL (hue, saturation, lightness) color with an alpha channel
+    Hsla {
+        /// Hue component. [0.0, 360.0]
+        hue: f32,
+        /// Saturation component. [0.0, 1.0]
+        saturation: f32,
+        /// Lightness component. [0.0, 1.0]
+        lightness: f32,
+        /// Alpha component. [0.0, 1.0]
+        alpha: f32,
+    },
+}
+
+impl Color {
+    pub const ALICE_BLUE: Color = Color::rgb(0.94, 0.97, 1.0);
+    pub const ANTIQUE_WHITE: Color = Color::rgb(0.98, 0.92, 0.84);
+    pub const AQUAMARINE: Color = Color::rgb(0.49, 1.0, 0.83);
+    pub const AZURE: Color = Color::rgb(0.94, 1.0, 1.0);
+    pub const BEIGE: Color = Color::rgb(0.96, 0.96, 0.86);
+    pub const BISQUE: Color = Color::rgb(1.0, 0.89, 0.77);
+    pub const BLACK: Color = Color::rgb(0.0, 0.0, 0.0);
+    pub const BLUE: Color = Color::rgb(0.0, 0.0, 1.0);
+    pub const CRIMSON: Color = Color::rgb(0.86, 0.08, 0.24);
+    pub const CYAN: Color = Color::rgb(0.0, 1.0, 1.0);
+    pub const DARK_GRAY: Color = Color::rgb(0.25, 0.25, 0.25);
+    pub const DARK_GREEN: Color = Color::rgb(0.0, 0.5, 0.0);
+    pub const FUCHSIA: Color = Color::rgb(1.0, 0.0, 1.0);
+    pub const GOLD: Color = Color::rgb(1.0, 0.84, 0.0);
+    pub const GRAY: Color = Color::rgb(0.5, 0.5, 0.5);
+    pub const GREEN: Color = Color::rgb(0.0, 1.0, 0.0);
+    pub const INDIGO: Color = Color::rgb(0.29, 0.0, 0.51);
+    pub const LIME_GREEN: Color = Color::rgb(0.2, 0.8, 0.2);
+    pub const MAROON: Color = Color::rgb(0.5, 0.0, 0.0);
+    pub const MIDNIGHT_BLUE: Color = Color::rgb(0.1, 0.1, 0.44);
+    pub const NAVY: Color = Color::rgb(0.0, 0.0, 0.5);
+    pub const NONE: Color = Color::rgba(0.0, 0.0, 0.0, 0.0);
+    pub const OLIVE: Color = Color::rgb(0.5, 0.5, 0.0);
+    pub const ORANGE: Color = Color::rgb(1.0, 0.65, 0.0);
+    pub const ORANGE_RED: Color = Color::rgb(1.0, 0.27, 0.0);
+    pub const PINK: Color = Color::rgb(1.0, 0.08, 0.58);
+    pub const PURPLE: Color = Color::rgb(0.5, 0.0, 0.5);
+    pub const RED: Color = Color::rgb(1.0, 0.0, 0.0);
+    pub const SALMON: Color = Color::rgb(0.98, 0.5, 0.45);
+    pub const SEA_GREEN: Color = Color::rgb(0.18, 0.55, 0.34);
+    pub const SILVER: Color = Color::rgb(0.75, 0.75, 0.75);
+    pub const TEAL: Color = Color::rgb(0.0, 0.5, 0.5);
+    pub const TOMATO: Color = Color::rgb(1.0, 0.39, 0.28);
+    pub const TURQUOISE: Color = Color::rgb(0.25, 0.88, 0.82);
+    pub const VIOLET: Color = Color::rgb(0.93, 0.51, 0.93);
+    pub const WHITE: Color = Color::rgb(1.0, 1.0, 1.0);
+    pub const YELLOW: Color = Color::rgb(1.0, 1.0, 0.0);
+    pub const YELLOW_GREEN: Color = Color::rgb(0.6, 0.8, 0.2);
+
+    /// New `Color` from sRGB colorspace.
+    pub const fn rgb(r: f32, g: f32, b: f32) -> Color {
+        Color::Rgba {
+            red: r,
+            green: g,
+            blue: b,
+            alpha: 1.0,
+        }
+    }
+
+    /// New `Color` from sRGB colorspace.
+    pub const fn rgba(r: f32, g: f32, b: f32, a: f32) -> Color {
+        Color::Rgba {
+            red: r,
+            green: g,
+            blue: b,
+            alpha: a,
+        }
+    }
+
+    /// New `Color` from linear RGB colorspace.
+    pub const fn rgb_linear(r: f32, g: f32, b: f32) -> Color {
+        Color::RgbaLinear {
+            red: r,
+            green: g,
+            blue: b,
+            alpha: 1.0,
+        }
+    }
+
+    /// New `Color` from linear RGB colorspace.
+    pub const fn rgba_linear(r: f32, g: f32, b: f32, a: f32) -> Color {
+        Color::RgbaLinear {
+            red: r,
+            green: g,
+            blue: b,
+            alpha: a,
+        }
+    }
+
+    /// New `Color` with HSL representation in sRGB colorspace.
+    pub const fn hsl(hue: f32, saturation: f32, lightness: f32) -> Color {
+        Color::Hsla {
+            hue,
+            saturation,
+            lightness,
+            alpha: 1.0,
+        }
+    }
+
+    /// New `Color` with HSL representation in sRGB colorspace.
+    pub const fn hsla(hue: f32, saturation: f32, lightness: f32, alpha: f32) -> Color {
+        Color::Hsla {
+            hue,
+            saturation,
+            lightness,
+            alpha,
+        }
+    }
+
+    /// New `Color` from sRGB colorspace.
+    pub fn hex<T: AsRef<str>>(hex: T) -> Result<Color, HexColorError> {
+        let hex = hex.as_ref();
+
+        // RGB
+        if hex.len() == 3 {
+            let mut data = [0; 6];
+            for (i, ch) in hex.chars().enumerate() {
+                data[i * 2] = ch as u8;
+                data[i * 2 + 1] = ch as u8;
+            }
+            return decode_rgb(&data);
+        }
+
+        // RGBA
+        if hex.len() == 4 {
+            let mut data = [0; 8];
+            for (i, ch) in hex.chars().enumerate() {
+                data[i * 2] = ch as u8;
+                data[i * 2 + 1] = ch as u8;
+            }
+            return decode_rgba(&data);
+        }
+
+        // RRGGBB
+        if hex.len() == 6 {
+            return decode_rgb(hex.as_bytes());
+        }
+
+        // RRGGBBAA
+        if hex.len() == 8 {
+            return decode_rgba(hex.as_bytes());
+        }
+
+        Err(HexColorError::Length)
+    }
+
+    /// New `Color` from sRGB colorspace.
+    pub fn rgb_u8(r: u8, g: u8, b: u8) -> Color {
+        Color::rgba_u8(r, g, b, u8::MAX)
+    }
+
+    // Float operations in const fn are not stable yet
+    // see https://github.com/rust-lang/rust/issues/57241
+    /// New `Color` from sRGB colorspace.
+    pub fn rgba_u8(r: u8, g: u8, b: u8, a: u8) -> Color {
+        Color::rgba(
+            r as f32 / u8::MAX as f32,
+            g as f32 / u8::MAX as f32,
+            b as f32 / u8::MAX as f32,
+            a as f32 / u8::MAX as f32,
+        )
+    }
+
+    /// Get red in sRGB colorspace.
+    pub fn r(&self) -> f32 {
+        match self.as_rgba() {
+            Color::Rgba { red, .. } => red,
+            _ => unreachable!(),
+        }
+    }
+
+    /// Get green in sRGB colorspace.
+    pub fn g(&self) -> f32 {
+        match self.as_rgba() {
+            Color::Rgba { green, .. } => green,
+            _ => unreachable!(),
+        }
+    }
+
+    /// Get blue in sRGB colorspace.
+    pub fn b(&self) -> f32 {
+        match self.as_rgba() {
+            Color::Rgba { blue, .. } => blue,
+            _ => unreachable!(),
+        }
+    }
+
+    /// Set red in sRGB colorspace.
+    pub fn set_r(&mut self, r: f32) -> &mut Self {
+        *self = self.as_rgba();
+        match self {
+            Color::Rgba { red, .. } => *red = r,
+            _ => unreachable!(),
+        }
+        self
+    }
+
+    /// Set green in sRGB colorspace.
+    pub fn set_g(&mut self, g: f32) -> &mut Self {
+        *self = self.as_rgba();
+        match self {
+            Color::Rgba { green, .. } => *green = g,
+            _ => unreachable!(),
+        }
+        self
+    }
+
+    /// Set blue in sRGB colorspace.
+    pub fn set_b(&mut self, b: f32) -> &mut Self {
+        *self = self.as_rgba();
+        match self {
+            Color::Rgba { blue, .. } => *blue = b,
+            _ => unreachable!(),
+        }
+        self
+    }
+
+    /// Get alpha.
+    pub fn a(&self) -> f32 {
+        match self {
+            Color::Rgba { alpha, .. }
+            | Color::RgbaLinear { alpha, .. }
+            | Color::Hsla { alpha, .. } => *alpha,
+        }
+    }
+
+    /// Set alpha.
+    pub fn set_a(&mut self, a: f32) -> &mut Self {
+        match self {
+            Color::Rgba { alpha, .. }
+            | Color::RgbaLinear { alpha, .. }
+            | Color::Hsla { alpha, .. } => {
+                *alpha = a;
+            }
+        }
+        self
+    }
+
+    /// Converts a `Color` to variant `Color::Rgba`
+    pub fn as_rgba(self: &Color) -> Color {
+        match self {
+            Color::Rgba { .. } => *self,
+            Color::RgbaLinear {
+                red,
+                green,
+                blue,
+                alpha,
+            } => Color::Rgba {
+                red: red.linear_to_nonlinear_srgb(),
+                green: green.linear_to_nonlinear_srgb(),
+                blue: blue.linear_to_nonlinear_srgb(),
+                alpha: *alpha,
+            },
+            Color::Hsla {
+                hue,
+                saturation,
+                lightness,
+                alpha,
+            } => {
+                let [red, green, blue] =
+                    HslRepresentation::hsl_to_nonlinear_srgb(*hue, *saturation, *lightness);
+                Color::Rgba {
+                    red,
+                    green,
+                    blue,
+                    alpha: *alpha,
+                }
+            }
+        }
+    }
+
+    /// Converts a `Color` to variant `Color::RgbaLinear`
+    pub fn as_rgba_linear(self: &Color) -> Color {
+        match self {
+            Color::Rgba {
+                red,
+                green,
+                blue,
+                alpha,
+            } => Color::Rgba {
+                red: red.nonlinear_to_linear_srgb(),
+                green: green.nonlinear_to_linear_srgb(),
+                blue: blue.nonlinear_to_linear_srgb(),
+                alpha: *alpha,
+            },
+            Color::RgbaLinear { .. } => *self,
+            Color::Hsla {
+                hue,
+                saturation,
+                lightness,
+                alpha,
+            } => {
+                let [red, green, blue] =
+                    HslRepresentation::hsl_to_nonlinear_srgb(*hue, *saturation, *lightness);
+                Color::RgbaLinear {
+                    red: red.nonlinear_to_linear_srgb(),
+                    green: green.nonlinear_to_linear_srgb(),
+                    blue: blue.nonlinear_to_linear_srgb(),
+                    alpha: *alpha,
+                }
+            }
+        }
+    }
+
+    /// Converts a `Color` to variant `Color::Hsla`
+    pub fn as_hsla(self: &Color) -> Color {
+        match self {
+            Color::Rgba {
+                red,
+                green,
+                blue,
+                alpha,
+            } => {
+                let (hue, saturation, lightness) =
+                    HslRepresentation::nonlinear_srgb_to_hsl([*red, *green, *blue]);
+                Color::Hsla {
+                    hue,
+                    saturation,
+                    lightness,
+                    alpha: *alpha,
+                }
+            }
+            Color::RgbaLinear {
+                red,
+                green,
+                blue,
+                alpha,
+            } => {
+                let (hue, saturation, lightness) = HslRepresentation::nonlinear_srgb_to_hsl([
+                    red.linear_to_nonlinear_srgb(),
+                    green.linear_to_nonlinear_srgb(),
+                    blue.linear_to_nonlinear_srgb(),
+                ]);
+                Color::Hsla {
+                    hue,
+                    saturation,
+                    lightness,
+                    alpha: *alpha,
+                }
+            }
+            Color::Hsla { .. } => *self,
+        }
+    }
+
+    /// Converts a `Color` to a `[f32; 4]` from sRBG colorspace
+    pub fn as_rgba_f32(self: Color) -> [f32; 4] {
+        match self {
+            Color::Rgba {
+                red,
+                green,
+                blue,
+                alpha,
+            } => [red, green, blue, alpha],
+            Color::RgbaLinear {
+                red,
+                green,
+                blue,
+                alpha,
+            } => [
+                red.linear_to_nonlinear_srgb(),
+                green.linear_to_nonlinear_srgb(),
+                blue.linear_to_nonlinear_srgb(),
+                alpha,
+            ],
+            Color::Hsla {
+                hue,
+                saturation,
+                lightness,
+                alpha,
+            } => {
+                let [red, green, blue] =
+                    HslRepresentation::hsl_to_nonlinear_srgb(hue, saturation, lightness);
+                [red, green, blue, alpha]
+            }
+        }
+    }
+
+    /// Converts a `Color` to a `[f32; 4]` from linear RBG colorspace
+    #[inline]
+    pub fn as_linear_rgba_f32(self: Color) -> [f32; 4] {
+        match self {
+            Color::Rgba {
+                red,
+                green,
+                blue,
+                alpha,
+            } => [
+                red.nonlinear_to_linear_srgb(),
+                green.nonlinear_to_linear_srgb(),
+                blue.nonlinear_to_linear_srgb(),
+                alpha,
+            ],
+            Color::RgbaLinear {
+                red,
+                green,
+                blue,
+                alpha,
+            } => [red, green, blue, alpha],
+            Color::Hsla {
+                hue,
+                saturation,
+                lightness,
+                alpha,
+            } => {
+                let [red, green, blue] =
+                    HslRepresentation::hsl_to_nonlinear_srgb(hue, saturation, lightness);
+                [
+                    red.nonlinear_to_linear_srgb(),
+                    green.nonlinear_to_linear_srgb(),
+                    blue.nonlinear_to_linear_srgb(),
+                    alpha,
+                ]
+            }
+        }
+    }
+
+    /// Converts a `Color` to a `[f32; 4]` from HLS colorspace
+    pub fn as_hlsa_f32(self: Color) -> [f32; 4] {
+        match self {
+            Color::Rgba {
+                red,
+                green,
+                blue,
+                alpha,
+            } => {
+                let (hue, saturation, lightness) =
+                    HslRepresentation::nonlinear_srgb_to_hsl([red, green, blue]);
+                [hue, saturation, lightness, alpha]
+            }
+            Color::RgbaLinear {
+                red,
+                green,
+                blue,
+                alpha,
+            } => {
+                let (hue, saturation, lightness) = HslRepresentation::nonlinear_srgb_to_hsl([
+                    red.linear_to_nonlinear_srgb(),
+                    green.linear_to_nonlinear_srgb(),
+                    blue.linear_to_nonlinear_srgb(),
+                ]);
+                [hue, saturation, lightness, alpha]
+            }
+            Color::Hsla {
+                hue,
+                saturation,
+                lightness,
+                alpha,
+            } => [hue, saturation, lightness, alpha],
+        }
+    }
+}
+
+impl Default for Color {
+    fn default() -> Self {
+        Color::WHITE
+    }
+}
+
+impl AddAssign<Color> for Color {
+    fn add_assign(&mut self, rhs: Color) {
+        match self {
+            Color::Rgba {
+                red,
+                green,
+                blue,
+                alpha,
+            } => {
+                let rhs = rhs.as_rgba_f32();
+                *red += rhs[0];
+                *green += rhs[1];
+                *blue += rhs[2];
+                *alpha += rhs[3];
+            }
+            Color::RgbaLinear {
+                red,
+                green,
+                blue,
+                alpha,
+            } => {
+                let rhs = rhs.as_linear_rgba_f32();
+                *red += rhs[0];
+                *green += rhs[1];
+                *blue += rhs[2];
+                *alpha += rhs[3];
+            }
+            Color::Hsla {
+                hue,
+                saturation,
+                lightness,
+                alpha,
+            } => {
+                let rhs = rhs.as_linear_rgba_f32();
+                *hue += rhs[0];
+                *saturation += rhs[1];
+                *lightness += rhs[2];
+                *alpha += rhs[3];
+            }
+        }
+    }
+}
+
+impl Add<Color> for Color {
+    type Output = Color;
+
+    fn add(self, rhs: Color) -> Self::Output {
+        match self {
+            Color::Rgba {
+                red,
+                green,
+                blue,
+                alpha,
+            } => {
+                let rhs = rhs.as_rgba_f32();
+                Color::Rgba {
+                    red: red + rhs[0],
+                    green: green + rhs[1],
+                    blue: blue + rhs[2],
+                    alpha: alpha + rhs[3],
+                }
+            }
+            Color::RgbaLinear {
+                red,
+                green,
+                blue,
+                alpha,
+            } => {
+                let rhs = rhs.as_linear_rgba_f32();
+                Color::RgbaLinear {
+                    red: red + rhs[0],
+                    green: green + rhs[1],
+                    blue: blue + rhs[2],
+                    alpha: alpha + rhs[3],
+                }
+            }
+            Color::Hsla {
+                hue,
+                saturation,
+                lightness,
+                alpha,
+            } => {
+                let rhs = rhs.as_linear_rgba_f32();
+                Color::Hsla {
+                    hue: hue + rhs[0],
+                    saturation: saturation + rhs[1],
+                    lightness: lightness + rhs[2],
+                    alpha: alpha + rhs[3],
+                }
+            }
+        }
+    }
+}
+
+impl AddAssign<Vec4> for Color {
+    fn add_assign(&mut self, rhs: Vec4) {
+        let rhs: Color = rhs.into();
+        *self += rhs
+    }
+}
+
+impl Add<Vec4> for Color {
+    type Output = Color;
+
+    fn add(self, rhs: Vec4) -> Self::Output {
+        let rhs: Color = rhs.into();
+        self + rhs
+    }
+}
+
+impl From<Color> for [f32; 4] {
+    fn from(color: Color) -> Self {
+        color.as_rgba_f32()
+    }
+}
+
+impl From<[f32; 4]> for Color {
+    fn from([r, g, b, a]: [f32; 4]) -> Self {
+        Color::rgba(r, g, b, a)
+    }
+}
+
+impl From<Color> for Vec4 {
+    fn from(color: Color) -> Self {
+        let color: [f32; 4] = color.into();
+        Vec4::new(color[0], color[1], color[2], color[3])
+    }
+}
+
+impl From<Vec4> for Color {
+    fn from(vec4: Vec4) -> Self {
+        Color::rgba(vec4.x, vec4.y, vec4.z, vec4.w)
+    }
+}
+
+impl From<Color> for wgpu::Color {
+    fn from(color: Color) -> Self {
+        let color = color.as_rgba_linear();
+        wgpu::Color {
+            r: color.r() as f64,
+            g: color.g() as f64,
+            b: color.b() as f64,
+            a: color.a() as f64,
+        }
+    }
+}
+
+impl Mul<f32> for Color {
+    type Output = Color;
+
+    fn mul(self, rhs: f32) -> Self::Output {
+        match self {
+            Color::Rgba {
+                red,
+                green,
+                blue,
+                alpha,
+            } => Color::Rgba {
+                red: red * rhs,
+                green: green * rhs,
+                blue: blue * rhs,
+                alpha,
+            },
+            Color::RgbaLinear {
+                red,
+                green,
+                blue,
+                alpha,
+            } => Color::RgbaLinear {
+                red: red * rhs,
+                green: green * rhs,
+                blue: blue * rhs,
+                alpha,
+            },
+            Color::Hsla {
+                hue,
+                saturation,
+                lightness,
+                alpha,
+            } => Color::Hsla {
+                hue: hue * rhs,
+                saturation: saturation * rhs,
+                lightness: lightness * rhs,
+                alpha,
+            },
+        }
+    }
+}
+
+impl MulAssign<f32> for Color {
+    fn mul_assign(&mut self, rhs: f32) {
+        match self {
+            Color::Rgba {
+                red, green, blue, ..
+            } => {
+                *red *= rhs;
+                *green *= rhs;
+                *blue *= rhs;
+            }
+            Color::RgbaLinear {
+                red, green, blue, ..
+            } => {
+                *red *= rhs;
+                *green *= rhs;
+                *blue *= rhs;
+            }
+            Color::Hsla {
+                hue,
+                saturation,
+                lightness,
+                ..
+            } => {
+                *hue *= rhs;
+                *saturation *= rhs;
+                *lightness *= rhs;
+            }
+        }
+    }
+}
+
+impl Mul<Vec4> for Color {
+    type Output = Color;
+
+    fn mul(self, rhs: Vec4) -> Self::Output {
+        match self {
+            Color::Rgba {
+                red,
+                green,
+                blue,
+                alpha,
+            } => Color::Rgba {
+                red: red * rhs.x,
+                green: green * rhs.y,
+                blue: blue * rhs.z,
+                alpha: alpha * rhs.w,
+            },
+            Color::RgbaLinear {
+                red,
+                green,
+                blue,
+                alpha,
+            } => Color::RgbaLinear {
+                red: red * rhs.x,
+                green: green * rhs.y,
+                blue: blue * rhs.z,
+                alpha: alpha * rhs.w,
+            },
+            Color::Hsla {
+                hue,
+                saturation,
+                lightness,
+                alpha,
+            } => Color::Hsla {
+                hue: hue * rhs.x,
+                saturation: saturation * rhs.y,
+                lightness: lightness * rhs.z,
+                alpha: alpha * rhs.w,
+            },
+        }
+    }
+}
+
+impl MulAssign<Vec4> for Color {
+    fn mul_assign(&mut self, rhs: Vec4) {
+        match self {
+            Color::Rgba {
+                red,
+                green,
+                blue,
+                alpha,
+            } => {
+                *red *= rhs.x;
+                *green *= rhs.y;
+                *blue *= rhs.z;
+                *alpha *= rhs.w;
+            }
+            Color::RgbaLinear {
+                red,
+                green,
+                blue,
+                alpha,
+            } => {
+                *red *= rhs.x;
+                *green *= rhs.y;
+                *blue *= rhs.z;
+                *alpha *= rhs.w;
+            }
+            Color::Hsla {
+                hue,
+                saturation,
+                lightness,
+                alpha,
+            } => {
+                *hue *= rhs.x;
+                *saturation *= rhs.y;
+                *lightness *= rhs.z;
+                *alpha *= rhs.w;
+            }
+        }
+    }
+}
+
+impl Mul<Vec3> for Color {
+    type Output = Color;
+
+    fn mul(self, rhs: Vec3) -> Self::Output {
+        match self {
+            Color::Rgba {
+                red,
+                green,
+                blue,
+                alpha,
+            } => Color::Rgba {
+                red: red * rhs.x,
+                green: green * rhs.y,
+                blue: blue * rhs.z,
+                alpha,
+            },
+            Color::RgbaLinear {
+                red,
+                green,
+                blue,
+                alpha,
+            } => Color::RgbaLinear {
+                red: red * rhs.x,
+                green: green * rhs.y,
+                blue: blue * rhs.z,
+                alpha,
+            },
+            Color::Hsla {
+                hue,
+                saturation,
+                lightness,
+                alpha,
+            } => Color::Hsla {
+                hue: hue * rhs.x,
+                saturation: saturation * rhs.y,
+                lightness: lightness * rhs.z,
+                alpha,
+            },
+        }
+    }
+}
+
+impl MulAssign<Vec3> for Color {
+    fn mul_assign(&mut self, rhs: Vec3) {
+        match self {
+            Color::Rgba {
+                red, green, blue, ..
+            } => {
+                *red *= rhs.x;
+                *green *= rhs.y;
+                *blue *= rhs.z;
+            }
+            Color::RgbaLinear {
+                red, green, blue, ..
+            } => {
+                *red *= rhs.x;
+                *green *= rhs.y;
+                *blue *= rhs.z;
+            }
+            Color::Hsla {
+                hue,
+                saturation,
+                lightness,
+                ..
+            } => {
+                *hue *= rhs.x;
+                *saturation *= rhs.y;
+                *lightness *= rhs.z;
+            }
+        }
+    }
+}
+
+impl Mul<[f32; 4]> for Color {
+    type Output = Color;
+
+    fn mul(self, rhs: [f32; 4]) -> Self::Output {
+        match self {
+            Color::Rgba {
+                red,
+                green,
+                blue,
+                alpha,
+            } => Color::Rgba {
+                red: red * rhs[0],
+                green: green * rhs[1],
+                blue: blue * rhs[2],
+                alpha: alpha * rhs[3],
+            },
+            Color::RgbaLinear {
+                red,
+                green,
+                blue,
+                alpha,
+            } => Color::RgbaLinear {
+                red: red * rhs[0],
+                green: green * rhs[1],
+                blue: blue * rhs[2],
+                alpha: alpha * rhs[3],
+            },
+            Color::Hsla {
+                hue,
+                saturation,
+                lightness,
+                alpha,
+            } => Color::Hsla {
+                hue: hue * rhs[0],
+                saturation: saturation * rhs[1],
+                lightness: lightness * rhs[2],
+                alpha: alpha * rhs[3],
+            },
+        }
+    }
+}
+
+impl MulAssign<[f32; 4]> for Color {
+    fn mul_assign(&mut self, rhs: [f32; 4]) {
+        match self {
+            Color::Rgba {
+                red,
+                green,
+                blue,
+                alpha,
+            } => {
+                *red *= rhs[0];
+                *green *= rhs[1];
+                *blue *= rhs[2];
+                *alpha *= rhs[3];
+            }
+            Color::RgbaLinear {
+                red,
+                green,
+                blue,
+                alpha,
+            } => {
+                *red *= rhs[0];
+                *green *= rhs[1];
+                *blue *= rhs[2];
+                *alpha *= rhs[3];
+            }
+            Color::Hsla {
+                hue,
+                saturation,
+                lightness,
+                alpha,
+            } => {
+                *hue *= rhs[0];
+                *saturation *= rhs[1];
+                *lightness *= rhs[2];
+                *alpha *= rhs[3];
+            }
+        }
+    }
+}
+
+impl Mul<[f32; 3]> for Color {
+    type Output = Color;
+
+    fn mul(self, rhs: [f32; 3]) -> Self::Output {
+        match self {
+            Color::Rgba {
+                red,
+                green,
+                blue,
+                alpha,
+            } => Color::Rgba {
+                red: red * rhs[0],
+                green: green * rhs[1],
+                blue: blue * rhs[2],
+                alpha,
+            },
+            Color::RgbaLinear {
+                red,
+                green,
+                blue,
+                alpha,
+            } => Color::RgbaLinear {
+                red: red * rhs[0],
+                green: green * rhs[1],
+                blue: blue * rhs[2],
+                alpha,
+            },
+            Color::Hsla {
+                hue,
+                saturation,
+                lightness,
+                alpha,
+            } => Color::Hsla {
+                hue: hue * rhs[0],
+                saturation: saturation * rhs[1],
+                lightness: lightness * rhs[2],
+                alpha,
+            },
+        }
+    }
+}
+
+impl MulAssign<[f32; 3]> for Color {
+    fn mul_assign(&mut self, rhs: [f32; 3]) {
+        match self {
+            Color::Rgba {
+                red, green, blue, ..
+            } => {
+                *red *= rhs[0];
+                *green *= rhs[1];
+                *blue *= rhs[2];
+            }
+            Color::RgbaLinear {
+                red, green, blue, ..
+            } => {
+                *red *= rhs[0];
+                *green *= rhs[1];
+                *blue *= rhs[2];
+            }
+            Color::Hsla {
+                hue,
+                saturation,
+                lightness,
+                ..
+            } => {
+                *hue *= rhs[0];
+                *saturation *= rhs[1];
+                *lightness *= rhs[2];
+            }
+        }
+    }
+}
+
+impl Bytes for Color {
+    fn write_bytes(&self, buffer: &mut [u8]) {
+        match *self {
+            Color::Rgba {
+                red,
+                green,
+                blue,
+                alpha,
+            } => {
+                red.nonlinear_to_linear_srgb().write_bytes(buffer);
+                green
+                    .nonlinear_to_linear_srgb()
+                    .write_bytes(&mut buffer[std::mem::size_of::<f32>()..]);
+                blue.nonlinear_to_linear_srgb()
+                    .write_bytes(&mut buffer[2 * std::mem::size_of::<f32>()..]);
+                alpha.write_bytes(&mut buffer[3 * std::mem::size_of::<f32>()..]);
+            }
+            Color::RgbaLinear {
+                red,
+                green,
+                blue,
+                alpha,
+            } => {
+                red.write_bytes(buffer);
+                green.write_bytes(&mut buffer[std::mem::size_of::<f32>()..]);
+                blue.write_bytes(&mut buffer[2 * std::mem::size_of::<f32>()..]);
+                alpha.write_bytes(&mut buffer[3 * std::mem::size_of::<f32>()..]);
+            }
+            Color::Hsla {
+                hue,
+                saturation,
+                lightness,
+                alpha,
+            } => {
+                let [red, green, blue] =
+                    HslRepresentation::hsl_to_nonlinear_srgb(hue, saturation, lightness);
+                red.nonlinear_to_linear_srgb().write_bytes(buffer);
+                green
+                    .nonlinear_to_linear_srgb()
+                    .write_bytes(&mut buffer[std::mem::size_of::<f32>()..]);
+                blue.nonlinear_to_linear_srgb()
+                    .write_bytes(&mut buffer[std::mem::size_of::<f32>() * 2..]);
+                alpha.write_bytes(&mut buffer[std::mem::size_of::<f32>() * 3..]);
+            }
+        }
+    }
+
+    fn byte_len(&self) -> usize {
+        std::mem::size_of::<f32>() * 4
+    }
+}
+
+#[derive(Debug)]
+pub enum HexColorError {
+    Length,
+    Hex(hex::FromHexError),
+}
+
+fn decode_rgb(data: &[u8]) -> Result<Color, HexColorError> {
+    let mut buf = [0; 3];
+    match hex::decode_to_slice(data, &mut buf) {
+        Ok(_) => {
+            let r = buf[0] as f32 / 255.0;
+            let g = buf[1] as f32 / 255.0;
+            let b = buf[2] as f32 / 255.0;
+            Ok(Color::rgb(r, g, b))
+        }
+        Err(err) => Err(HexColorError::Hex(err)),
+    }
+}
+
+fn decode_rgba(data: &[u8]) -> Result<Color, HexColorError> {
+    let mut buf = [0; 4];
+    match hex::decode_to_slice(data, &mut buf) {
+        Ok(_) => {
+            let r = buf[0] as f32 / 255.0;
+            let g = buf[1] as f32 / 255.0;
+            let b = buf[2] as f32 / 255.0;
+            let a = buf[3] as f32 / 255.0;
+            Ok(Color::rgba(r, g, b, a))
+        }
+        Err(err) => Err(HexColorError::Hex(err)),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn hex_color() {
+        assert_eq!(Color::hex("FFF").unwrap(), Color::rgb(1.0, 1.0, 1.0));
+        assert_eq!(Color::hex("000").unwrap(), Color::rgb(0.0, 0.0, 0.0));
+        assert!(Color::hex("---").is_err());
+
+        assert_eq!(Color::hex("FFFF").unwrap(), Color::rgba(1.0, 1.0, 1.0, 1.0));
+        assert_eq!(Color::hex("0000").unwrap(), Color::rgba(0.0, 0.0, 0.0, 0.0));
+        assert!(Color::hex("----").is_err());
+
+        assert_eq!(Color::hex("FFFFFF").unwrap(), Color::rgb(1.0, 1.0, 1.0));
+        assert_eq!(Color::hex("000000").unwrap(), Color::rgb(0.0, 0.0, 0.0));
+        assert!(Color::hex("------").is_err());
+
+        assert_eq!(
+            Color::hex("FFFFFFFF").unwrap(),
+            Color::rgba(1.0, 1.0, 1.0, 1.0)
+        );
+        assert_eq!(
+            Color::hex("00000000").unwrap(),
+            Color::rgba(0.0, 0.0, 0.0, 0.0)
+        );
+        assert!(Color::hex("--------").is_err());
+
+        assert!(Color::hex("1234567890").is_err());
+    }
+
+    #[test]
+    fn conversions_vec4() {
+        let starting_vec4 = Vec4::new(0.4, 0.5, 0.6, 1.0);
+        let starting_color = Color::from(starting_vec4);
+
+        assert_eq!(starting_vec4, Vec4::from(starting_color),);
+
+        let transformation = Vec4::new(0.5, 0.5, 0.5, 1.0);
+
+        assert_eq!(
+            starting_color * transformation,
+            Color::from(starting_vec4 * transformation),
+        );
+    }
+
+    #[test]
+    fn mul_and_mulassign_f32() {
+        let transformation = 0.5;
+        let starting_color = Color::rgba(0.4, 0.5, 0.6, 1.0);
+
+        assert_eq!(
+            starting_color * transformation,
+            Color::rgba(0.4 * 0.5, 0.5 * 0.5, 0.6 * 0.5, 1.0),
+        );
+
+        let mut mutated_color = starting_color;
+        mutated_color *= transformation;
+
+        assert_eq!(starting_color * transformation, mutated_color,);
+    }
+
+    #[test]
+    fn mul_and_mulassign_f32by3() {
+        let transformation = [0.4, 0.5, 0.6];
+        let starting_color = Color::rgba(0.4, 0.5, 0.6, 1.0);
+
+        assert_eq!(
+            starting_color * transformation,
+            Color::rgba(0.4 * 0.4, 0.5 * 0.5, 0.6 * 0.6, 1.0),
+        );
+
+        let mut mutated_color = starting_color;
+        mutated_color *= transformation;
+
+        assert_eq!(starting_color * transformation, mutated_color,);
+    }
+
+    #[test]
+    fn mul_and_mulassign_f32by4() {
+        let transformation = [0.4, 0.5, 0.6, 0.9];
+        let starting_color = Color::rgba(0.4, 0.5, 0.6, 1.0);
+
+        assert_eq!(
+            starting_color * transformation,
+            Color::rgba(0.4 * 0.4, 0.5 * 0.5, 0.6 * 0.6, 1.0 * 0.9),
+        );
+
+        let mut mutated_color = starting_color;
+        mutated_color *= transformation;
+
+        assert_eq!(starting_color * transformation, mutated_color,);
+    }
+
+    #[test]
+    fn mul_and_mulassign_vec3() {
+        let transformation = Vec3::new(0.2, 0.3, 0.4);
+        let starting_color = Color::rgba(0.4, 0.5, 0.6, 1.0);
+
+        assert_eq!(
+            starting_color * transformation,
+            Color::rgba(0.4 * 0.2, 0.5 * 0.3, 0.6 * 0.4, 1.0),
+        );
+
+        let mut mutated_color = starting_color;
+        mutated_color *= transformation;
+
+        assert_eq!(starting_color * transformation, mutated_color,);
+    }
+
+    #[test]
+    fn mul_and_mulassign_vec4() {
+        let transformation = Vec4::new(0.2, 0.3, 0.4, 0.5);
+        let starting_color = Color::rgba(0.4, 0.5, 0.6, 1.0);
+
+        assert_eq!(
+            starting_color * transformation,
+            Color::rgba(0.4 * 0.2, 0.5 * 0.3, 0.6 * 0.4, 1.0 * 0.5),
+        );
+
+        let mut mutated_color = starting_color;
+        mutated_color *= transformation;
+
+        assert_eq!(starting_color * transformation, mutated_color,);
+    }
+}
diff --git a/pipelined/bevy_render2/src/lib.rs b/pipelined/bevy_render2/src/lib.rs
new file mode 100644
index 0000000000..062812f4a7
--- /dev/null
+++ b/pipelined/bevy_render2/src/lib.rs
@@ -0,0 +1,298 @@
+pub mod camera;
+pub mod color;
+pub mod mesh;
+pub mod primitives;
+pub mod render_asset;
+pub mod render_component;
+pub mod render_graph;
+pub mod render_phase;
+pub mod render_resource;
+pub mod renderer;
+pub mod texture;
+pub mod view;
+
+pub use once_cell;
+
+use crate::{
+    camera::CameraPlugin,
+    mesh::MeshPlugin,
+    render_graph::RenderGraph,
+    render_resource::{RenderPipelineCache, Shader, ShaderLoader},
+    renderer::render_system,
+    texture::ImagePlugin,
+    view::{ViewPlugin, WindowRenderPlugin},
+};
+use bevy_app::{App, AppLabel, Plugin};
+use bevy_asset::{AddAsset, AssetServer};
+use bevy_ecs::prelude::*;
+use std::ops::{Deref, DerefMut};
+use wgpu::Backends;
+
+/// Contains the default Bevy rendering backend based on wgpu.
+#[derive(Default)]
+pub struct RenderPlugin;
+
+/// The labels of the default App rendering stages.
+#[derive(Debug, Hash, PartialEq, Eq, Clone, StageLabel)]
+pub enum RenderStage {
+    /// Extract data from the "app world" and insert it into the "render world".
+    /// This step should be kept as short as possible to increase the "pipelining potential" for
+    /// running the next frame while rendering the current frame.
+    Extract,
+
+    /// Prepare render resources from the extracted data for the GPU.
+    Prepare,
+
+    /// Create [`BindGroups`](crate::render_resource::BindGroup) that depend on
+    /// [`Prepare`](RenderStage::Prepare) data and queue up draw calls to run during the
+    /// [`Render`](RenderStage::Render) stage.
+    Queue,
+
+    // TODO: This could probably be moved in favor of a system ordering abstraction in Render or Queue
+    /// Sort the [`RenderPhases`](crate::render_phase::RenderPhase) here.
+    PhaseSort,
+
+    /// Actual rendering happens here.
+    /// In most cases, only the render backend should insert resources here.
+    Render,
+
+    /// Cleanup render resources here.
+    Cleanup,
+}
+
+/// The Render App World. This is only available as a resource during the Extract step.
+#[derive(Default)]
+pub struct RenderWorld(World);
+
+impl Deref for RenderWorld {
+    type Target = World;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for RenderWorld {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+/// A Label for the rendering sub-app.
+#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, AppLabel)]
+pub struct RenderApp;
+
+/// A "scratch" world used to avoid allocating new worlds every frame when
+/// swapping out the [`RenderWorld`].
+#[derive(Default)]
+struct ScratchRenderWorld(World);
+
+impl Plugin for RenderPlugin {
+    /// Initializes the renderer, sets up the [`RenderStage`](RenderStage) and creates the rendering sub-app.
+    fn build(&self, app: &mut App) {
+        let default_backend = if cfg!(not(target_arch = "wasm32")) {
+            Backends::PRIMARY
+        } else {
+            Backends::GL
+        };
+        let backends = wgpu::util::backend_bits_from_env().unwrap_or(default_backend);
+        let instance = wgpu::Instance::new(backends);
+        let surface = {
+            let world = app.world.cell();
+            let windows = world.get_resource_mut::<bevy_window::Windows>().unwrap();
+            let raw_handle = windows.get_primary().map(|window| unsafe {
+                let handle = window.raw_window_handle().get_handle();
+                instance.create_surface(&handle)
+            });
+            raw_handle
+        };
+        let (device, queue) = futures_lite::future::block_on(renderer::initialize_renderer(
+            &instance,
+            &wgpu::RequestAdapterOptions {
+                power_preference: wgpu::PowerPreference::HighPerformance,
+                compatible_surface: surface.as_ref(),
+                ..Default::default()
+            },
+            &wgpu::DeviceDescriptor {
+                features: wgpu::Features::TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES,
+                #[cfg(not(target_arch = "wasm32"))]
+                limits: wgpu::Limits::default(),
+                #[cfg(target_arch = "wasm32")]
+                limits: wgpu::Limits {
+                    ..wgpu::Limits::downlevel_webgl2_defaults()
+                },
+                ..Default::default()
+            },
+        ));
+        app.insert_resource(device.clone())
+            .insert_resource(queue.clone())
+            .add_asset::<Shader>()
+            .init_asset_loader::<ShaderLoader>()
+            .init_resource::<ScratchRenderWorld>();
+        let render_pipeline_cache = RenderPipelineCache::new(device.clone());
+        let asset_server = app.world.get_resource::<AssetServer>().unwrap().clone();
+
+        let mut render_app = App::empty();
+        let mut extract_stage =
+            SystemStage::parallel().with_system(RenderPipelineCache::extract_shaders);
+        // don't apply buffers when the stage finishes running
+        // extract stage runs on the app world, but the buffers are applied to the render world
+        extract_stage.set_apply_buffers(false);
+        render_app
+            .add_stage(RenderStage::Extract, extract_stage)
+            .add_stage(RenderStage::Prepare, SystemStage::parallel())
+            .add_stage(RenderStage::Queue, SystemStage::parallel())
+            .add_stage(RenderStage::PhaseSort, SystemStage::parallel())
+            .add_stage(
+                RenderStage::Render,
+                SystemStage::parallel()
+                    .with_system(RenderPipelineCache::process_pipeline_queue_system)
+                    .with_system(render_system.exclusive_system().at_end()),
+            )
+            .add_stage(RenderStage::Cleanup, SystemStage::parallel())
+            .insert_resource(instance)
+            .insert_resource(device)
+            .insert_resource(queue)
+            .insert_resource(render_pipeline_cache)
+            .insert_resource(asset_server)
+            .init_resource::<RenderGraph>();
+
+        app.add_sub_app(RenderApp, render_app, move |app_world, render_app| {
+            #[cfg(feature = "trace")]
+            let render_span = bevy_utils::tracing::info_span!("renderer subapp");
+            #[cfg(feature = "trace")]
+            let _render_guard = render_span.enter();
+            {
+                #[cfg(feature = "trace")]
+                let stage_span =
+                    bevy_utils::tracing::info_span!("stage", name = "reserve_and_flush");
+                #[cfg(feature = "trace")]
+                let _stage_guard = stage_span.enter();
+
+                // reserve all existing app entities for use in render_app
+                // they can only be spawned using `get_or_spawn()`
+                let meta_len = app_world.entities().meta.len();
+                render_app
+                    .world
+                    .entities()
+                    .reserve_entities(meta_len as u32);
+
+                // flushing as "invalid" ensures that app world entities aren't added as "empty archetype" entities by default
+                // these entities cannot be accessed without spawning directly onto them
+                // this _only_ works as expected because clear_entities() is called at the end of every frame.
+                render_app.world.entities_mut().flush_as_invalid();
+            }
+
+            {
+                #[cfg(feature = "trace")]
+                let stage_span = bevy_utils::tracing::info_span!("stage", name = "extract");
+                #[cfg(feature = "trace")]
+                let _stage_guard = stage_span.enter();
+
+                // extract
+                extract(app_world, render_app);
+            }
+
+            {
+                #[cfg(feature = "trace")]
+                let stage_span = bevy_utils::tracing::info_span!("stage", name = "prepare");
+                #[cfg(feature = "trace")]
+                let _stage_guard = stage_span.enter();
+
+                // prepare
+                let prepare = render_app
+                    .schedule
+                    .get_stage_mut::<SystemStage>(&RenderStage::Prepare)
+                    .unwrap();
+                prepare.run(&mut render_app.world);
+            }
+
+            {
+                #[cfg(feature = "trace")]
+                let stage_span = bevy_utils::tracing::info_span!("stage", name = "queue");
+                #[cfg(feature = "trace")]
+                let _stage_guard = stage_span.enter();
+
+                // queue
+                let queue = render_app
+                    .schedule
+                    .get_stage_mut::<SystemStage>(&RenderStage::Queue)
+                    .unwrap();
+                queue.run(&mut render_app.world);
+            }
+
+            {
+                #[cfg(feature = "trace")]
+                let stage_span = bevy_utils::tracing::info_span!("stage", name = "sort");
+                #[cfg(feature = "trace")]
+                let _stage_guard = stage_span.enter();
+
+                // phase sort
+                let phase_sort = render_app
+                    .schedule
+                    .get_stage_mut::<SystemStage>(&RenderStage::PhaseSort)
+                    .unwrap();
+                phase_sort.run(&mut render_app.world);
+            }
+
+            {
+                #[cfg(feature = "trace")]
+                let stage_span = bevy_utils::tracing::info_span!("stage", name = "render");
+                #[cfg(feature = "trace")]
+                let _stage_guard = stage_span.enter();
+
+                // render
+                let render = render_app
+                    .schedule
+                    .get_stage_mut::<SystemStage>(&RenderStage::Render)
+                    .unwrap();
+                render.run(&mut render_app.world);
+            }
+
+            {
+                #[cfg(feature = "trace")]
+                let stage_span = bevy_utils::tracing::info_span!("stage", name = "cleanup");
+                #[cfg(feature = "trace")]
+                let _stage_guard = stage_span.enter();
+
+                // cleanup
+                let cleanup = render_app
+                    .schedule
+                    .get_stage_mut::<SystemStage>(&RenderStage::Cleanup)
+                    .unwrap();
+                cleanup.run(&mut render_app.world);
+
+                render_app.world.clear_entities();
+            }
+        });
+
+        app.add_plugin(WindowRenderPlugin)
+            .add_plugin(CameraPlugin)
+            .add_plugin(ViewPlugin)
+            .add_plugin(MeshPlugin)
+            .add_plugin(ImagePlugin);
+    }
+}
+
+/// Executes the [`Extract`](RenderStage::Extract) stage of the renderer.
+/// This updates the render world with the extracted ECS data of the current frame.
+fn extract(app_world: &mut World, render_app: &mut App) {
+    let extract = render_app
+        .schedule
+        .get_stage_mut::<SystemStage>(&RenderStage::Extract)
+        .unwrap();
+
+    // temporarily add the render world to the app world as a resource
+    let scratch_world = app_world.remove_resource::<ScratchRenderWorld>().unwrap();
+    let render_world = std::mem::replace(&mut render_app.world, scratch_world.0);
+    app_world.insert_resource(RenderWorld(render_world));
+
+    extract.run(app_world);
+
+    // add the render world back to the render app
+    let render_world = app_world.remove_resource::<RenderWorld>().unwrap();
+    let scratch_world = std::mem::replace(&mut render_app.world, render_world.0);
+    app_world.insert_resource(ScratchRenderWorld(scratch_world));
+
+    extract.apply_buffers(&mut render_app.world);
+}
diff --git a/pipelined/bevy_render2/src/mesh/mesh/conversions.rs b/pipelined/bevy_render2/src/mesh/mesh/conversions.rs
new file mode 100644
index 0000000000..b9c9d99dec
--- /dev/null
+++ b/pipelined/bevy_render2/src/mesh/mesh/conversions.rs
@@ -0,0 +1,518 @@
+//! These implementations allow you to
+//! convert std::vec::Vec<T> to VertexAttributeValues::T and back.
+//!
+//! # Examples
+//!
+//! ```rust
+//! use bevy_render2::mesh::VertexAttributeValues;
+//!
+//! // creating std::vec::Vec
+//! let buffer = vec![[0_u32; 4]; 10];
+//!
+//! // converting std::vec::Vec to bevy_render2::mesh::VertexAttributeValues
+//! let values = VertexAttributeValues::from(buffer.clone());
+//!
+//! // converting bevy_render2::mesh::VertexAttributeValues to std::vec::Vec with two ways
+//! let result_into: Vec<[u32; 4]> = values.clone().try_into().unwrap();
+//! let result_from: Vec<[u32; 4]> = Vec::try_from(values.clone()).unwrap();
+//!
+//! // getting an error when trying to convert incorrectly
+//! let error: Result<Vec<u32>, _> = values.try_into();
+//!
+//! assert_eq!(buffer, result_into);
+//! assert_eq!(buffer, result_from);
+//! assert!(error.is_err());
+//! ```
+
+use crate::mesh::VertexAttributeValues;
+use bevy_utils::EnumVariantMeta;
+use thiserror::Error;
+
+#[derive(Debug, Clone, Error)]
+#[error("cannot convert VertexAttributeValues::{variant} to {into}")]
+pub struct FromVertexAttributeError {
+    from: VertexAttributeValues,
+    variant: &'static str,
+    into: &'static str,
+}
+
+impl FromVertexAttributeError {
+    fn new<T: 'static>(from: VertexAttributeValues) -> Self {
+        Self {
+            variant: from.enum_variant_name(),
+            into: std::any::type_name::<T>(),
+            from,
+        }
+    }
+}
+
+impl From<Vec<f32>> for VertexAttributeValues {
+    fn from(vec: Vec<f32>) -> Self {
+        VertexAttributeValues::Float32(vec)
+    }
+}
+
+impl From<Vec<i32>> for VertexAttributeValues {
+    fn from(vec: Vec<i32>) -> Self {
+        VertexAttributeValues::Sint32(vec)
+    }
+}
+
+impl From<Vec<u32>> for VertexAttributeValues {
+    fn from(vec: Vec<u32>) -> Self {
+        VertexAttributeValues::Uint32(vec)
+    }
+}
+
+impl From<Vec<[f32; 2]>> for VertexAttributeValues {
+    fn from(vec: Vec<[f32; 2]>) -> Self {
+        VertexAttributeValues::Float32x2(vec)
+    }
+}
+
+impl From<Vec<[i32; 2]>> for VertexAttributeValues {
+    fn from(vec: Vec<[i32; 2]>) -> Self {
+        VertexAttributeValues::Sint32x2(vec)
+    }
+}
+
+impl From<Vec<[u32; 2]>> for VertexAttributeValues {
+    fn from(vec: Vec<[u32; 2]>) -> Self {
+        VertexAttributeValues::Uint32x2(vec)
+    }
+}
+
+impl From<Vec<[f32; 3]>> for VertexAttributeValues {
+    fn from(vec: Vec<[f32; 3]>) -> Self {
+        VertexAttributeValues::Float32x3(vec)
+    }
+}
+
+impl From<Vec<[i32; 3]>> for VertexAttributeValues {
+    fn from(vec: Vec<[i32; 3]>) -> Self {
+        VertexAttributeValues::Sint32x3(vec)
+    }
+}
+
+impl From<Vec<[u32; 3]>> for VertexAttributeValues {
+    fn from(vec: Vec<[u32; 3]>) -> Self {
+        VertexAttributeValues::Uint32x3(vec)
+    }
+}
+
+impl From<Vec<[f32; 4]>> for VertexAttributeValues {
+    fn from(vec: Vec<[f32; 4]>) -> Self {
+        VertexAttributeValues::Float32x4(vec)
+    }
+}
+
+impl From<Vec<[i32; 4]>> for VertexAttributeValues {
+    fn from(vec: Vec<[i32; 4]>) -> Self {
+        VertexAttributeValues::Sint32x4(vec)
+    }
+}
+
+impl From<Vec<[u32; 4]>> for VertexAttributeValues {
+    fn from(vec: Vec<[u32; 4]>) -> Self {
+        VertexAttributeValues::Uint32x4(vec)
+    }
+}
+
+impl From<Vec<[u8; 4]>> for VertexAttributeValues {
+    fn from(vec: Vec<[u8; 4]>) -> Self {
+        VertexAttributeValues::Unorm8x4(vec)
+    }
+}
+
+impl TryFrom<VertexAttributeValues> for Vec<[u8; 4]> {
+    type Error = FromVertexAttributeError;
+
+    fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> {
+        match value {
+            VertexAttributeValues::Uint8x4(value) => Ok(value),
+            VertexAttributeValues::Unorm8x4(value) => Ok(value),
+            _ => Err(FromVertexAttributeError::new::<Self>(value)),
+        }
+    }
+}
+
+impl TryFrom<VertexAttributeValues> for Vec<[i8; 4]> {
+    type Error = FromVertexAttributeError;
+
+    fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> {
+        match value {
+            VertexAttributeValues::Sint8x4(value) => Ok(value),
+            VertexAttributeValues::Snorm8x4(value) => Ok(value),
+            _ => Err(FromVertexAttributeError::new::<Self>(value)),
+        }
+    }
+}
+
+impl TryFrom<VertexAttributeValues> for Vec<[u8; 2]> {
+    type Error = FromVertexAttributeError;
+
+    fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> {
+        match value {
+            VertexAttributeValues::Uint8x2(value) => Ok(value),
+            VertexAttributeValues::Unorm8x2(value) => Ok(value),
+            _ => Err(FromVertexAttributeError::new::<Self>(value)),
+        }
+    }
+}
+
+impl TryFrom<VertexAttributeValues> for Vec<[i8; 2]> {
+    type Error = FromVertexAttributeError;
+
+    fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> {
+        match value {
+            VertexAttributeValues::Sint8x2(value) => Ok(value),
+            VertexAttributeValues::Snorm8x2(value) => Ok(value),
+            _ => Err(FromVertexAttributeError::new::<Self>(value)),
+        }
+    }
+}
+
+impl TryFrom<VertexAttributeValues> for Vec<[i16; 4]> {
+    type Error = FromVertexAttributeError;
+
+    fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> {
+        match value {
+            VertexAttributeValues::Sint16x4(value) => Ok(value),
+            VertexAttributeValues::Snorm16x4(value) => Ok(value),
+            _ => Err(FromVertexAttributeError::new::<Self>(value)),
+        }
+    }
+}
+
+impl TryFrom<VertexAttributeValues> for Vec<[u16; 4]> {
+    type Error = FromVertexAttributeError;
+
+    fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> {
+        match value {
+            VertexAttributeValues::Uint16x4(value) => Ok(value),
+            VertexAttributeValues::Unorm16x4(value) => Ok(value),
+            _ => Err(FromVertexAttributeError::new::<Self>(value)),
+        }
+    }
+}
+
+impl TryFrom<VertexAttributeValues> for Vec<[u16; 2]> {
+    type Error = FromVertexAttributeError;
+
+    fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> {
+        match value {
+            VertexAttributeValues::Uint16x2(value) => Ok(value),
+            VertexAttributeValues::Unorm16x2(value) => Ok(value),
+            _ => Err(FromVertexAttributeError::new::<Self>(value)),
+        }
+    }
+}
+
+impl TryFrom<VertexAttributeValues> for Vec<[i16; 2]> {
+    type Error = FromVertexAttributeError;
+
+    fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> {
+        match value {
+            VertexAttributeValues::Sint16x2(value) => Ok(value),
+            VertexAttributeValues::Snorm16x2(value) => Ok(value),
+            _ => Err(FromVertexAttributeError::new::<Self>(value)),
+        }
+    }
+}
+
+impl TryFrom<VertexAttributeValues> for Vec<[u32; 4]> {
+    type Error = FromVertexAttributeError;
+
+    fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> {
+        match value {
+            VertexAttributeValues::Uint32x4(value) => Ok(value),
+            _ => Err(FromVertexAttributeError::new::<Self>(value)),
+        }
+    }
+}
+
+impl TryFrom<VertexAttributeValues> for Vec<[i32; 4]> {
+    type Error = FromVertexAttributeError;
+
+    fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> {
+        match value {
+            VertexAttributeValues::Sint32x4(value) => Ok(value),
+            _ => Err(FromVertexAttributeError::new::<Self>(value)),
+        }
+    }
+}
+
+impl TryFrom<VertexAttributeValues> for Vec<[f32; 4]> {
+    type Error = FromVertexAttributeError;
+
+    fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> {
+        match value {
+            VertexAttributeValues::Float32x4(value) => Ok(value),
+            _ => Err(FromVertexAttributeError::new::<Self>(value)),
+        }
+    }
+}
+
+impl TryFrom<VertexAttributeValues> for Vec<[u32; 3]> {
+    type Error = FromVertexAttributeError;
+
+    fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> {
+        match value {
+            VertexAttributeValues::Uint32x3(value) => Ok(value),
+            _ => Err(FromVertexAttributeError::new::<Self>(value)),
+        }
+    }
+}
+
+impl TryFrom<VertexAttributeValues> for Vec<[i32; 3]> {
+    type Error = FromVertexAttributeError;
+
+    fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> {
+        match value {
+            VertexAttributeValues::Sint32x3(value) => Ok(value),
+            _ => Err(FromVertexAttributeError::new::<Self>(value)),
+        }
+    }
+}
+
+impl TryFrom<VertexAttributeValues> for Vec<[f32; 3]> {
+    type Error = FromVertexAttributeError;
+
+    fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> {
+        match value {
+            VertexAttributeValues::Float32x3(value) => Ok(value),
+            _ => Err(FromVertexAttributeError::new::<Self>(value)),
+        }
+    }
+}
+
+impl TryFrom<VertexAttributeValues> for Vec<[u32; 2]> {
+    type Error = FromVertexAttributeError;
+
+    fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> {
+        match value {
+            VertexAttributeValues::Uint32x2(value) => Ok(value),
+            _ => Err(FromVertexAttributeError::new::<Self>(value)),
+        }
+    }
+}
+
+impl TryFrom<VertexAttributeValues> for Vec<[i32; 2]> {
+    type Error = FromVertexAttributeError;
+
+    fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> {
+        match value {
+            VertexAttributeValues::Sint32x2(value) => Ok(value),
+            _ => Err(FromVertexAttributeError::new::<Self>(value)),
+        }
+    }
+}
+
+impl TryFrom<VertexAttributeValues> for Vec<[f32; 2]> {
+    type Error = FromVertexAttributeError;
+
+    fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> {
+        match value {
+            VertexAttributeValues::Float32x2(value) => Ok(value),
+            _ => Err(FromVertexAttributeError::new::<Self>(value)),
+        }
+    }
+}
+
+impl TryFrom<VertexAttributeValues> for Vec<u32> {
+    type Error = FromVertexAttributeError;
+
+    fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> {
+        match value {
+            VertexAttributeValues::Uint32(value) => Ok(value),
+            _ => Err(FromVertexAttributeError::new::<Self>(value)),
+        }
+    }
+}
+
+impl TryFrom<VertexAttributeValues> for Vec<i32> {
+    type Error = FromVertexAttributeError;
+
+    fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> {
+        match value {
+            VertexAttributeValues::Sint32(value) => Ok(value),
+            _ => Err(FromVertexAttributeError::new::<Self>(value)),
+        }
+    }
+}
+
+impl TryFrom<VertexAttributeValues> for Vec<f32> {
+    type Error = FromVertexAttributeError;
+
+    fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> {
+        match value {
+            VertexAttributeValues::Float32(value) => Ok(value),
+            _ => Err(FromVertexAttributeError::new::<Self>(value)),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::VertexAttributeValues;
+    #[test]
+    fn f32() {
+        let buffer = vec![0.0; 10];
+        let values = VertexAttributeValues::from(buffer.clone());
+        let result_into: Vec<f32> = values.clone().try_into().unwrap();
+        let result_from: Vec<f32> = Vec::try_from(values.clone()).unwrap();
+        let error: Result<Vec<u32>, _> = values.try_into();
+        assert_eq!(buffer, result_into);
+        assert_eq!(buffer, result_from);
+        assert!(error.is_err());
+    }
+
+    #[test]
+    fn i32() {
+        let buffer = vec![0; 10];
+        let values = VertexAttributeValues::from(buffer.clone());
+        let result_into: Vec<i32> = values.clone().try_into().unwrap();
+        let result_from: Vec<i32> = Vec::try_from(values.clone()).unwrap();
+        let error: Result<Vec<u32>, _> = values.try_into();
+        assert_eq!(buffer, result_into);
+        assert_eq!(buffer, result_from);
+        assert!(error.is_err());
+    }
+
+    #[test]
+    fn u32() {
+        let buffer = vec![0_u32; 10];
+        let values = VertexAttributeValues::from(buffer.clone());
+        let result_into: Vec<u32> = values.clone().try_into().unwrap();
+        let result_from: Vec<u32> = Vec::try_from(values.clone()).unwrap();
+        let error: Result<Vec<f32>, _> = values.try_into();
+        assert_eq!(buffer, result_into);
+        assert_eq!(buffer, result_from);
+        assert!(error.is_err());
+    }
+
+    #[test]
+    fn f32_2() {
+        let buffer = vec![[0.0; 2]; 10];
+        let values = VertexAttributeValues::from(buffer.clone());
+        let result_into: Vec<[f32; 2]> = values.clone().try_into().unwrap();
+        let result_from: Vec<[f32; 2]> = Vec::try_from(values.clone()).unwrap();
+        let error: Result<Vec<u32>, _> = values.try_into();
+        assert_eq!(buffer, result_into);
+        assert_eq!(buffer, result_from);
+        assert!(error.is_err());
+    }
+
+    #[test]
+    fn i32_2() {
+        let buffer = vec![[0; 2]; 10];
+        let values = VertexAttributeValues::from(buffer.clone());
+        let result_into: Vec<[i32; 2]> = values.clone().try_into().unwrap();
+        let result_from: Vec<[i32; 2]> = Vec::try_from(values.clone()).unwrap();
+        let error: Result<Vec<u32>, _> = values.try_into();
+        assert_eq!(buffer, result_into);
+        assert_eq!(buffer, result_from);
+        assert!(error.is_err());
+    }
+
+    #[test]
+    fn u32_2() {
+        let buffer = vec![[0_u32; 2]; 10];
+        let values = VertexAttributeValues::from(buffer.clone());
+        let result_into: Vec<[u32; 2]> = values.clone().try_into().unwrap();
+        let result_from: Vec<[u32; 2]> = Vec::try_from(values.clone()).unwrap();
+        let error: Result<Vec<u32>, _> = values.try_into();
+        assert_eq!(buffer, result_into);
+        assert_eq!(buffer, result_from);
+        assert!(error.is_err());
+    }
+
+    #[test]
+    fn f32_3() {
+        let buffer = vec![[0.0; 3]; 10];
+        let values = VertexAttributeValues::from(buffer.clone());
+        let result_into: Vec<[f32; 3]> = values.clone().try_into().unwrap();
+        let result_from: Vec<[f32; 3]> = Vec::try_from(values.clone()).unwrap();
+        let error: Result<Vec<u32>, _> = values.try_into();
+        assert_eq!(buffer, result_into);
+        assert_eq!(buffer, result_from);
+        assert!(error.is_err());
+    }
+
+    #[test]
+    fn i32_3() {
+        let buffer = vec![[0; 3]; 10];
+        let values = VertexAttributeValues::from(buffer.clone());
+        let result_into: Vec<[i32; 3]> = values.clone().try_into().unwrap();
+        let result_from: Vec<[i32; 3]> = Vec::try_from(values.clone()).unwrap();
+        let error: Result<Vec<u32>, _> = values.try_into();
+        assert_eq!(buffer, result_into);
+        assert_eq!(buffer, result_from);
+        assert!(error.is_err());
+    }
+
+    #[test]
+    fn u32_3() {
+        let buffer = vec![[0_u32; 3]; 10];
+        let values = VertexAttributeValues::from(buffer.clone());
+        let result_into: Vec<[u32; 3]> = values.clone().try_into().unwrap();
+        let result_from: Vec<[u32; 3]> = Vec::try_from(values.clone()).unwrap();
+        let error: Result<Vec<u32>, _> = values.try_into();
+        assert_eq!(buffer, result_into);
+        assert_eq!(buffer, result_from);
+        assert!(error.is_err());
+    }
+
+    #[test]
+    fn f32_4() {
+        let buffer = vec![[0.0; 4]; 10];
+        let values = VertexAttributeValues::from(buffer.clone());
+        let result_into: Vec<[f32; 4]> = values.clone().try_into().unwrap();
+        let result_from: Vec<[f32; 4]> = Vec::try_from(values.clone()).unwrap();
+        let error: Result<Vec<u32>, _> = values.try_into();
+        assert_eq!(buffer, result_into);
+        assert_eq!(buffer, result_from);
+        assert!(error.is_err());
+    }
+
+    #[test]
+    fn i32_4() {
+        let buffer = vec![[0; 4]; 10];
+        let values = VertexAttributeValues::from(buffer.clone());
+        let result_into: Vec<[i32; 4]> = values.clone().try_into().unwrap();
+        let result_from: Vec<[i32; 4]> = Vec::try_from(values.clone()).unwrap();
+        let error: Result<Vec<u32>, _> = values.try_into();
+        assert_eq!(buffer, result_into);
+        assert_eq!(buffer, result_from);
+        assert!(error.is_err());
+    }
+
+    #[test]
+    fn u32_4() {
+        let buffer = vec![[0_u32; 4]; 10];
+        let values = VertexAttributeValues::from(buffer.clone());
+        let result_into: Vec<[u32; 4]> = values.clone().try_into().unwrap();
+        let result_from: Vec<[u32; 4]> = Vec::try_from(values.clone()).unwrap();
+        let error: Result<Vec<u32>, _> = values.try_into();
+        assert_eq!(buffer, result_into);
+        assert_eq!(buffer, result_from);
+        assert!(error.is_err());
+    }
+
+    #[test]
+    fn correct_message() {
+        let buffer = vec![[0_u32; 4]; 3];
+        let values = VertexAttributeValues::from(buffer);
+        let error_result: Result<Vec<u32>, _> = values.try_into();
+        let error = match error_result {
+            Ok(..) => unreachable!(),
+            Err(error) => error,
+        };
+        assert_eq!(
+            format!("{}", error),
+            "cannot convert VertexAttributeValues::Uint32x4 to alloc::vec::Vec<u32>"
+        );
+        assert_eq!(format!("{:?}", error),
+               "FromVertexAttributeError { from: Uint32x4([[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]), variant: \"Uint32x4\", into: \"alloc::vec::Vec<u32>\" }");
+    }
+}
diff --git a/pipelined/bevy_render2/src/mesh/mesh/mod.rs b/pipelined/bevy_render2/src/mesh/mesh/mod.rs
new file mode 100644
index 0000000000..57614f378e
--- /dev/null
+++ b/pipelined/bevy_render2/src/mesh/mesh/mod.rs
@@ -0,0 +1,645 @@
+mod conversions;
+
+use crate::{
+    primitives::Aabb,
+    render_asset::{PrepareAssetError, RenderAsset},
+    render_resource::Buffer,
+    renderer::RenderDevice,
+};
+use bevy_core::cast_slice;
+use bevy_ecs::system::{lifetimeless::SRes, SystemParamItem};
+use bevy_math::*;
+use bevy_reflect::TypeUuid;
+use bevy_utils::EnumVariantMeta;
+use std::{borrow::Cow, collections::BTreeMap};
+use wgpu::{
+    util::BufferInitDescriptor, BufferUsages, IndexFormat, PrimitiveTopology, VertexFormat,
+};
+
+pub const INDEX_BUFFER_ASSET_INDEX: u64 = 0;
+pub const VERTEX_ATTRIBUTE_BUFFER_ID: u64 = 10;
+
+// TODO: allow values to be unloaded after been submitting to the GPU to conserve memory
+#[derive(Debug, TypeUuid, Clone)]
+#[uuid = "8ecbac0f-f545-4473-ad43-e1f4243af51e"]
+pub struct Mesh {
+    primitive_topology: PrimitiveTopology,
+    /// `std::collections::BTreeMap` with all defined vertex attributes (Positions, Normals, ...)
+    /// for this mesh. Attribute name maps to attribute values.
+    /// Uses a BTreeMap because, unlike HashMap, it has a defined iteration order,
+    /// which allows easy stable VertexBuffers (i.e. same buffer order)
+    attributes: BTreeMap<Cow<'static, str>, VertexAttributeValues>,
+    indices: Option<Indices>,
+}
+
+/// Contains geometry in the form of a mesh.
+///
+/// Often meshes are automatically generated by bevy's asset loaders or primitives, such as
+/// [`crate::shape::Cube`] or [`crate::shape::Box`], but you can also construct
+/// one yourself.
+///
+/// Example of constructing a mesh:
+/// ```
+/// # use bevy_render2::mesh::{Mesh, Indices};
+/// # use bevy_render2::render_resource::PrimitiveTopology;
+/// fn create_triangle() -> Mesh {
+///     let mut mesh = Mesh::new(PrimitiveTopology::TriangleList);
+///     mesh.set_attribute(Mesh::ATTRIBUTE_POSITION, vec![[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [1.0, 1.0, 0.0]]);
+///     mesh.set_indices(Some(Indices::U32(vec![0,1,2])));
+///     mesh
+/// }
+/// ```
+impl Mesh {
+    /// Per vertex coloring. Use in conjunction with [`Mesh::set_attribute`]
+    pub const ATTRIBUTE_COLOR: &'static str = "Vertex_Color";
+    /// The direction the vertex normal is facing in.
+    /// Use in conjunction with [`Mesh::set_attribute`]
+    pub const ATTRIBUTE_NORMAL: &'static str = "Vertex_Normal";
+    /// The direction of the vertex tangent. Used for normal mapping
+    pub const ATTRIBUTE_TANGENT: &'static str = "Vertex_Tangent";
+
+    /// Where the vertex is located in space. Use in conjunction with [`Mesh::set_attribute`]
+    pub const ATTRIBUTE_POSITION: &'static str = "Vertex_Position";
+    /// Texture coordinates for the vertex. Use in conjunction with [`Mesh::set_attribute`]
+    pub const ATTRIBUTE_UV_0: &'static str = "Vertex_Uv";
+
+    /// Per vertex joint transform matrix weight. Use in conjunction with [`Mesh::set_attribute`]
+    pub const ATTRIBUTE_JOINT_WEIGHT: &'static str = "Vertex_JointWeight";
+    /// Per vertex joint transform matrix index. Use in conjunction with [`Mesh::set_attribute`]
+    pub const ATTRIBUTE_JOINT_INDEX: &'static str = "Vertex_JointIndex";
+
+    /// Construct a new mesh. You need to provide a PrimitiveTopology so that the
+    /// renderer knows how to treat the vertex data. Most of the time this will be
+    /// `PrimitiveTopology::TriangleList`.
+    pub fn new(primitive_topology: PrimitiveTopology) -> Self {
+        Mesh {
+            primitive_topology,
+            attributes: Default::default(),
+            indices: None,
+        }
+    }
+
+    /// Returns the topology of the mesh.
+    pub fn primitive_topology(&self) -> PrimitiveTopology {
+        self.primitive_topology
+    }
+
+    /// Sets the data for a vertex attribute (position, normal etc.). The name will
+    /// often be one of the associated constants such as [`Mesh::ATTRIBUTE_POSITION`].
+    pub fn set_attribute(
+        &mut self,
+        name: impl Into<Cow<'static, str>>,
+        values: impl Into<VertexAttributeValues>,
+    ) {
+        let values: VertexAttributeValues = values.into();
+        self.attributes.insert(name.into(), values);
+    }
+
+    /// Retrieves the data currently set to the vertex attribute with the specified `name`.
+    pub fn attribute(&self, name: impl Into<Cow<'static, str>>) -> Option<&VertexAttributeValues> {
+        self.attributes.get(&name.into())
+    }
+
+    /// Retrieves the data currently set to the vertex attribute with the specified `name` mutably.
+    pub fn attribute_mut(
+        &mut self,
+        name: impl Into<Cow<'static, str>>,
+    ) -> Option<&mut VertexAttributeValues> {
+        self.attributes.get_mut(&name.into())
+    }
+
+    /// Sets the vertex indices of the mesh. They describe how triangles are constructed out of the
+    /// vertex attributes and are therefore only useful for the [`PrimitiveTopology`] variants
+    /// that use triangles.
+    pub fn set_indices(&mut self, indices: Option<Indices>) {
+        self.indices = indices;
+    }
+
+    /// Retrieves the vertex `indices` of the mesh.
+    pub fn indices(&self) -> Option<&Indices> {
+        self.indices.as_ref()
+    }
+
+    /// Retrieves the vertex `indices` of the mesh mutably.
+    pub fn indices_mut(&mut self) -> Option<&mut Indices> {
+        self.indices.as_mut()
+    }
+
+    /// Computes and returns the index data of the mesh as bytes.
+    /// This is used to transform the index data into a GPU friendly format.
+    pub fn get_index_buffer_bytes(&self) -> Option<&[u8]> {
+        self.indices.as_ref().map(|indices| match &indices {
+            Indices::U16(indices) => cast_slice(&indices[..]),
+            Indices::U32(indices) => cast_slice(&indices[..]),
+        })
+    }
+
+    // pub fn get_vertex_buffer_layout(&self) -> VertexBufferLayout {
+    //     let mut attributes = Vec::new();
+    //     let mut accumulated_offset = 0;
+    //     for (attribute_name, attribute_values) in self.attributes.iter() {
+    //         let vertex_format = VertexFormat::from(attribute_values);
+    //         attributes.push(VertexAttribute {
+    //             name: attribute_name.clone(),
+    //             offset: accumulated_offset,
+    //             format: vertex_format,
+    //             shader_location: 0,
+    //         });
+    //         accumulated_offset += vertex_format.get_size();
+    //     }
+
+    //     VertexBufferLayout {
+    //         name: Default::default(),
+    //         stride: accumulated_offset,
+    //         step_mode: InputStepMode::Vertex,
+    //         attributes,
+    //     }
+    // }
+
+    /// Counts all vertices of the mesh.
+    ///
+    /// # Panics
+    /// Panics if the attributes have different vertex counts.
+    pub fn count_vertices(&self) -> usize {
+        let mut vertex_count: Option<usize> = None;
+        for (attribute_name, attribute_data) in self.attributes.iter() {
+            let attribute_len = attribute_data.len();
+            if let Some(previous_vertex_count) = vertex_count {
+                assert_eq!(previous_vertex_count, attribute_len,
+                        "Attribute {} has a different vertex count ({}) than other attributes ({}) in this mesh.", attribute_name, attribute_len, previous_vertex_count);
+            }
+            vertex_count = Some(attribute_len);
+        }
+
+        vertex_count.unwrap_or(0)
+    }
+
+    /// Computes and returns the vertex data of the mesh as bytes.
+    /// Therefore the attributes are located in alphabetical order.
+    /// This is used to transform the vertex data into a GPU friendly format.
+    ///
+    /// # Panics
+    /// Panics if the attributes have different vertex counts.
+    pub fn get_vertex_buffer_data(&self) -> Vec<u8> {
+        let mut vertex_size = 0;
+        for attribute_values in self.attributes.values() {
+            let vertex_format = VertexFormat::from(attribute_values);
+            vertex_size += vertex_format.get_size() as usize;
+        }
+
+        let vertex_count = self.count_vertices();
+        let mut attributes_interleaved_buffer = vec![0; vertex_count * vertex_size];
+        // bundle into interleaved buffers
+        let mut attribute_offset = 0;
+        for attribute_values in self.attributes.values() {
+            let vertex_format = VertexFormat::from(attribute_values);
+            let attribute_size = vertex_format.get_size() as usize;
+            let attributes_bytes = attribute_values.get_bytes();
+            for (vertex_index, attribute_bytes) in
+                attributes_bytes.chunks_exact(attribute_size).enumerate()
+            {
+                let offset = vertex_index * vertex_size + attribute_offset;
+                attributes_interleaved_buffer[offset..offset + attribute_size]
+                    .copy_from_slice(attribute_bytes);
+            }
+
+            attribute_offset += attribute_size;
+        }
+
+        attributes_interleaved_buffer
+    }
+
+    /// Duplicates the vertex attributes so that no vertices are shared.
+    ///
+    /// This can dramatically increase the vertex count, so make sure this is what you want.
+    /// Does nothing if no [Indices] are set.
+    ///
+    /// # Panics
+    /// If the mesh has any other topology than [`PrimitiveTopology::TriangleList`].
+    pub fn duplicate_vertices(&mut self) {
+        fn duplicate<T: Copy>(values: &[T], indices: impl Iterator<Item = usize>) -> Vec<T> {
+            indices.map(|i| values[i]).collect()
+        }
+
+        assert!(
+            matches!(self.primitive_topology, PrimitiveTopology::TriangleList),
+            "can only duplicate vertices for `TriangleList`s"
+        );
+
+        let indices = match self.indices.take() {
+            Some(indices) => indices,
+            None => return,
+        };
+        for (_, attributes) in self.attributes.iter_mut() {
+            let indices = indices.iter();
+            match attributes {
+                VertexAttributeValues::Float32(vec) => *vec = duplicate(vec, indices),
+                VertexAttributeValues::Sint32(vec) => *vec = duplicate(vec, indices),
+                VertexAttributeValues::Uint32(vec) => *vec = duplicate(vec, indices),
+                VertexAttributeValues::Float32x2(vec) => *vec = duplicate(vec, indices),
+                VertexAttributeValues::Sint32x2(vec) => *vec = duplicate(vec, indices),
+                VertexAttributeValues::Uint32x2(vec) => *vec = duplicate(vec, indices),
+                VertexAttributeValues::Float32x3(vec) => *vec = duplicate(vec, indices),
+                VertexAttributeValues::Sint32x3(vec) => *vec = duplicate(vec, indices),
+                VertexAttributeValues::Uint32x3(vec) => *vec = duplicate(vec, indices),
+                VertexAttributeValues::Sint32x4(vec) => *vec = duplicate(vec, indices),
+                VertexAttributeValues::Uint32x4(vec) => *vec = duplicate(vec, indices),
+                VertexAttributeValues::Float32x4(vec) => *vec = duplicate(vec, indices),
+                VertexAttributeValues::Sint16x2(vec) => *vec = duplicate(vec, indices),
+                VertexAttributeValues::Snorm16x2(vec) => *vec = duplicate(vec, indices),
+                VertexAttributeValues::Uint16x2(vec) => *vec = duplicate(vec, indices),
+                VertexAttributeValues::Unorm16x2(vec) => *vec = duplicate(vec, indices),
+                VertexAttributeValues::Sint16x4(vec) => *vec = duplicate(vec, indices),
+                VertexAttributeValues::Snorm16x4(vec) => *vec = duplicate(vec, indices),
+                VertexAttributeValues::Uint16x4(vec) => *vec = duplicate(vec, indices),
+                VertexAttributeValues::Unorm16x4(vec) => *vec = duplicate(vec, indices),
+                VertexAttributeValues::Sint8x2(vec) => *vec = duplicate(vec, indices),
+                VertexAttributeValues::Snorm8x2(vec) => *vec = duplicate(vec, indices),
+                VertexAttributeValues::Uint8x2(vec) => *vec = duplicate(vec, indices),
+                VertexAttributeValues::Unorm8x2(vec) => *vec = duplicate(vec, indices),
+                VertexAttributeValues::Sint8x4(vec) => *vec = duplicate(vec, indices),
+                VertexAttributeValues::Snorm8x4(vec) => *vec = duplicate(vec, indices),
+                VertexAttributeValues::Uint8x4(vec) => *vec = duplicate(vec, indices),
+                VertexAttributeValues::Unorm8x4(vec) => *vec = duplicate(vec, indices),
+            }
+        }
+    }
+
+    /// Calculates the [`Mesh::ATTRIBUTE_NORMAL`] of a mesh.
+    ///
+    /// # Panics
+    /// Panics if [`Indices`] are set or [`Mesh::ATTRIBUTE_POSITION`] is not of type `float3`.
+    /// Consider calling [Mesh::duplicate_vertices] or export your mesh with normal attributes.
+    pub fn compute_flat_normals(&mut self) {
+        if self.indices().is_some() {
+            panic!("`compute_flat_normals` can't work on indexed geometry. Consider calling `Mesh::duplicate_vertices`.");
+        }
+
+        let positions = self
+            .attribute(Mesh::ATTRIBUTE_POSITION)
+            .unwrap()
+            .as_float3()
+            .expect("`Mesh::ATTRIBUTE_POSITION` vertex attributes should be of type `float3`");
+
+        let normals: Vec<_> = positions
+            .chunks_exact(3)
+            .map(|p| face_normal(p[0], p[1], p[2]))
+            .flat_map(|normal| std::array::IntoIter::new([normal, normal, normal]))
+            .collect();
+
+        self.set_attribute(Mesh::ATTRIBUTE_NORMAL, normals);
+    }
+
+    /// Compute the Axis-Aligned Bounding Box of the mesh vertices in model space
+    pub fn compute_aabb(&self) -> Option<Aabb> {
+        if let Some(VertexAttributeValues::Float32x3(values)) =
+            self.attribute(Mesh::ATTRIBUTE_POSITION)
+        {
+            let mut minimum = VEC3_MAX;
+            let mut maximum = VEC3_MIN;
+            for p in values {
+                minimum = minimum.min(Vec3::from_slice(p));
+                maximum = maximum.max(Vec3::from_slice(p));
+            }
+            if minimum.x != std::f32::MAX
+                && minimum.y != std::f32::MAX
+                && minimum.z != std::f32::MAX
+                && maximum.x != std::f32::MIN
+                && maximum.y != std::f32::MIN
+                && maximum.z != std::f32::MIN
+            {
+                return Some(Aabb::from_min_max(minimum, maximum));
+            }
+        }
+
+        None
+    }
+}
+
+const VEC3_MIN: Vec3 = const_vec3!([std::f32::MIN, std::f32::MIN, std::f32::MIN]);
+const VEC3_MAX: Vec3 = const_vec3!([std::f32::MAX, std::f32::MAX, std::f32::MAX]);
+
+fn face_normal(a: [f32; 3], b: [f32; 3], c: [f32; 3]) -> [f32; 3] {
+    let (a, b, c) = (Vec3::from(a), Vec3::from(b), Vec3::from(c));
+    (b - a).cross(c - a).normalize().into()
+}
+
+pub trait VertexFormatSize {
+    fn get_size(self) -> u64;
+}
+
+impl VertexFormatSize for wgpu::VertexFormat {
+    fn get_size(self) -> u64 {
+        match self {
+            VertexFormat::Uint8x2 => 2,
+            VertexFormat::Uint8x4 => 4,
+            VertexFormat::Sint8x2 => 2,
+            VertexFormat::Sint8x4 => 4,
+            VertexFormat::Unorm8x2 => 2,
+            VertexFormat::Unorm8x4 => 4,
+            VertexFormat::Snorm8x2 => 2,
+            VertexFormat::Snorm8x4 => 4,
+            VertexFormat::Uint16x2 => 2 * 2,
+            VertexFormat::Uint16x4 => 2 * 4,
+            VertexFormat::Sint16x2 => 2 * 2,
+            VertexFormat::Sint16x4 => 2 * 4,
+            VertexFormat::Unorm16x2 => 2 * 2,
+            VertexFormat::Unorm16x4 => 2 * 4,
+            VertexFormat::Snorm16x2 => 2 * 2,
+            VertexFormat::Snorm16x4 => 2 * 4,
+            VertexFormat::Float16x2 => 2 * 2,
+            VertexFormat::Float16x4 => 2 * 4,
+            VertexFormat::Float32 => 4,
+            VertexFormat::Float32x2 => 4 * 2,
+            VertexFormat::Float32x3 => 4 * 3,
+            VertexFormat::Float32x4 => 4 * 4,
+            VertexFormat::Uint32 => 4,
+            VertexFormat::Uint32x2 => 4 * 2,
+            VertexFormat::Uint32x3 => 4 * 3,
+            VertexFormat::Uint32x4 => 4 * 4,
+            VertexFormat::Sint32 => 4,
+            VertexFormat::Sint32x2 => 4 * 2,
+            VertexFormat::Sint32x3 => 4 * 3,
+            VertexFormat::Sint32x4 => 4 * 4,
+            VertexFormat::Float64 => 8,
+            VertexFormat::Float64x2 => 8 * 2,
+            VertexFormat::Float64x3 => 8 * 3,
+            VertexFormat::Float64x4 => 8 * 4,
+        }
+    }
+}
+
+/// Contains an array where each entry describes a property of a single vertex.
+/// Matches the [`VertexFormats`](VertexFormat).
+#[derive(Clone, Debug, EnumVariantMeta)]
+pub enum VertexAttributeValues {
+    Float32(Vec<f32>),
+    Sint32(Vec<i32>),
+    Uint32(Vec<u32>),
+    Float32x2(Vec<[f32; 2]>),
+    Sint32x2(Vec<[i32; 2]>),
+    Uint32x2(Vec<[u32; 2]>),
+    Float32x3(Vec<[f32; 3]>),
+    Sint32x3(Vec<[i32; 3]>),
+    Uint32x3(Vec<[u32; 3]>),
+    Float32x4(Vec<[f32; 4]>),
+    Sint32x4(Vec<[i32; 4]>),
+    Uint32x4(Vec<[u32; 4]>),
+    Sint16x2(Vec<[i16; 2]>),
+    Snorm16x2(Vec<[i16; 2]>),
+    Uint16x2(Vec<[u16; 2]>),
+    Unorm16x2(Vec<[u16; 2]>),
+    Sint16x4(Vec<[i16; 4]>),
+    Snorm16x4(Vec<[i16; 4]>),
+    Uint16x4(Vec<[u16; 4]>),
+    Unorm16x4(Vec<[u16; 4]>),
+    Sint8x2(Vec<[i8; 2]>),
+    Snorm8x2(Vec<[i8; 2]>),
+    Uint8x2(Vec<[u8; 2]>),
+    Unorm8x2(Vec<[u8; 2]>),
+    Sint8x4(Vec<[i8; 4]>),
+    Snorm8x4(Vec<[i8; 4]>),
+    Uint8x4(Vec<[u8; 4]>),
+    Unorm8x4(Vec<[u8; 4]>),
+}
+
+impl VertexAttributeValues {
+    /// Returns the number of vertices in this VertexAttribute. For a single
+    /// mesh, all of the VertexAttributeValues must have the same length.
+    pub fn len(&self) -> usize {
+        match *self {
+            VertexAttributeValues::Float32(ref values) => values.len(),
+            VertexAttributeValues::Sint32(ref values) => values.len(),
+            VertexAttributeValues::Uint32(ref values) => values.len(),
+            VertexAttributeValues::Float32x2(ref values) => values.len(),
+            VertexAttributeValues::Sint32x2(ref values) => values.len(),
+            VertexAttributeValues::Uint32x2(ref values) => values.len(),
+            VertexAttributeValues::Float32x3(ref values) => values.len(),
+            VertexAttributeValues::Sint32x3(ref values) => values.len(),
+            VertexAttributeValues::Uint32x3(ref values) => values.len(),
+            VertexAttributeValues::Float32x4(ref values) => values.len(),
+            VertexAttributeValues::Sint32x4(ref values) => values.len(),
+            VertexAttributeValues::Uint32x4(ref values) => values.len(),
+            VertexAttributeValues::Sint16x2(ref values) => values.len(),
+            VertexAttributeValues::Snorm16x2(ref values) => values.len(),
+            VertexAttributeValues::Uint16x2(ref values) => values.len(),
+            VertexAttributeValues::Unorm16x2(ref values) => values.len(),
+            VertexAttributeValues::Sint16x4(ref values) => values.len(),
+            VertexAttributeValues::Snorm16x4(ref values) => values.len(),
+            VertexAttributeValues::Uint16x4(ref values) => values.len(),
+            VertexAttributeValues::Unorm16x4(ref values) => values.len(),
+            VertexAttributeValues::Sint8x2(ref values) => values.len(),
+            VertexAttributeValues::Snorm8x2(ref values) => values.len(),
+            VertexAttributeValues::Uint8x2(ref values) => values.len(),
+            VertexAttributeValues::Unorm8x2(ref values) => values.len(),
+            VertexAttributeValues::Sint8x4(ref values) => values.len(),
+            VertexAttributeValues::Snorm8x4(ref values) => values.len(),
+            VertexAttributeValues::Uint8x4(ref values) => values.len(),
+            VertexAttributeValues::Unorm8x4(ref values) => values.len(),
+        }
+    }
+
+    /// Returns `true` if there are no vertices in this VertexAttributeValue.
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    /// Returns the values as float triples if possible.
+    fn as_float3(&self) -> Option<&[[f32; 3]]> {
+        match self {
+            VertexAttributeValues::Float32x3(values) => Some(values),
+            _ => None,
+        }
+    }
+
+    // TODO: add vertex format as parameter here and perform type conversions
+    /// Flattens the VertexAttributeArray into a sequence of bytes. This is
+    /// useful for serialization and sending to the GPU.
+    pub fn get_bytes(&self) -> &[u8] {
+        match self {
+            VertexAttributeValues::Float32(values) => cast_slice(&values[..]),
+            VertexAttributeValues::Sint32(values) => cast_slice(&values[..]),
+            VertexAttributeValues::Uint32(values) => cast_slice(&values[..]),
+            VertexAttributeValues::Float32x2(values) => cast_slice(&values[..]),
+            VertexAttributeValues::Sint32x2(values) => cast_slice(&values[..]),
+            VertexAttributeValues::Uint32x2(values) => cast_slice(&values[..]),
+            VertexAttributeValues::Float32x3(values) => cast_slice(&values[..]),
+            VertexAttributeValues::Sint32x3(values) => cast_slice(&values[..]),
+            VertexAttributeValues::Uint32x3(values) => cast_slice(&values[..]),
+            VertexAttributeValues::Float32x4(values) => cast_slice(&values[..]),
+            VertexAttributeValues::Sint32x4(values) => cast_slice(&values[..]),
+            VertexAttributeValues::Uint32x4(values) => cast_slice(&values[..]),
+            VertexAttributeValues::Sint16x2(values) => cast_slice(&values[..]),
+            VertexAttributeValues::Snorm16x2(values) => cast_slice(&values[..]),
+            VertexAttributeValues::Uint16x2(values) => cast_slice(&values[..]),
+            VertexAttributeValues::Unorm16x2(values) => cast_slice(&values[..]),
+            VertexAttributeValues::Sint16x4(values) => cast_slice(&values[..]),
+            VertexAttributeValues::Snorm16x4(values) => cast_slice(&values[..]),
+            VertexAttributeValues::Uint16x4(values) => cast_slice(&values[..]),
+            VertexAttributeValues::Unorm16x4(values) => cast_slice(&values[..]),
+            VertexAttributeValues::Sint8x2(values) => cast_slice(&values[..]),
+            VertexAttributeValues::Snorm8x2(values) => cast_slice(&values[..]),
+            VertexAttributeValues::Uint8x2(values) => cast_slice(&values[..]),
+            VertexAttributeValues::Unorm8x2(values) => cast_slice(&values[..]),
+            VertexAttributeValues::Sint8x4(values) => cast_slice(&values[..]),
+            VertexAttributeValues::Snorm8x4(values) => cast_slice(&values[..]),
+            VertexAttributeValues::Uint8x4(values) => cast_slice(&values[..]),
+            VertexAttributeValues::Unorm8x4(values) => cast_slice(&values[..]),
+        }
+    }
+}
+
+impl From<&VertexAttributeValues> for VertexFormat {
+    fn from(values: &VertexAttributeValues) -> Self {
+        match values {
+            VertexAttributeValues::Float32(_) => VertexFormat::Float32,
+            VertexAttributeValues::Sint32(_) => VertexFormat::Sint32,
+            VertexAttributeValues::Uint32(_) => VertexFormat::Uint32,
+            VertexAttributeValues::Float32x2(_) => VertexFormat::Float32x2,
+            VertexAttributeValues::Sint32x2(_) => VertexFormat::Sint32x2,
+            VertexAttributeValues::Uint32x2(_) => VertexFormat::Uint32x2,
+            VertexAttributeValues::Float32x3(_) => VertexFormat::Float32x3,
+            VertexAttributeValues::Sint32x3(_) => VertexFormat::Sint32x3,
+            VertexAttributeValues::Uint32x3(_) => VertexFormat::Uint32x3,
+            VertexAttributeValues::Float32x4(_) => VertexFormat::Float32x4,
+            VertexAttributeValues::Sint32x4(_) => VertexFormat::Sint32x4,
+            VertexAttributeValues::Uint32x4(_) => VertexFormat::Uint32x4,
+            VertexAttributeValues::Sint16x2(_) => VertexFormat::Sint16x2,
+            VertexAttributeValues::Snorm16x2(_) => VertexFormat::Snorm16x2,
+            VertexAttributeValues::Uint16x2(_) => VertexFormat::Uint16x2,
+            VertexAttributeValues::Unorm16x2(_) => VertexFormat::Unorm16x2,
+            VertexAttributeValues::Sint16x4(_) => VertexFormat::Sint16x4,
+            VertexAttributeValues::Snorm16x4(_) => VertexFormat::Snorm16x4,
+            VertexAttributeValues::Uint16x4(_) => VertexFormat::Uint16x4,
+            VertexAttributeValues::Unorm16x4(_) => VertexFormat::Unorm16x4,
+            VertexAttributeValues::Sint8x2(_) => VertexFormat::Sint8x2,
+            VertexAttributeValues::Snorm8x2(_) => VertexFormat::Snorm8x2,
+            VertexAttributeValues::Uint8x2(_) => VertexFormat::Uint8x2,
+            VertexAttributeValues::Unorm8x2(_) => VertexFormat::Unorm8x2,
+            VertexAttributeValues::Sint8x4(_) => VertexFormat::Sint8x4,
+            VertexAttributeValues::Snorm8x4(_) => VertexFormat::Snorm8x4,
+            VertexAttributeValues::Uint8x4(_) => VertexFormat::Uint8x4,
+            VertexAttributeValues::Unorm8x4(_) => VertexFormat::Unorm8x4,
+        }
+    }
+}
+
+/// An array of indices into the [`VertexAttributeValues`] for a mesh.
+///
+/// It describes the order in which the vertex attributes should be joined into faces.
+#[derive(Debug, Clone)]
+pub enum Indices {
+    U16(Vec<u16>),
+    U32(Vec<u32>),
+}
+
+impl Indices {
+    /// Returns an iterator over the indices.
+    fn iter(&self) -> impl Iterator<Item = usize> + '_ {
+        match self {
+            Indices::U16(vec) => IndicesIter::U16(vec.iter()),
+            Indices::U32(vec) => IndicesIter::U32(vec.iter()),
+        }
+    }
+
+    /// Returns the number of indices.
+    pub fn len(&self) -> usize {
+        match self {
+            Indices::U16(vec) => vec.len(),
+            Indices::U32(vec) => vec.len(),
+        }
+    }
+
+    /// Returns `true` if there are no indices.
+    pub fn is_empty(&self) -> bool {
+        match self {
+            Indices::U16(vec) => vec.is_empty(),
+            Indices::U32(vec) => vec.is_empty(),
+        }
+    }
+}
+
+/// An Iterator for the [`Indices`].
+enum IndicesIter<'a> {
+    U16(std::slice::Iter<'a, u16>),
+    U32(std::slice::Iter<'a, u32>),
+}
+
+impl Iterator for IndicesIter<'_> {
+    type Item = usize;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        match self {
+            IndicesIter::U16(iter) => iter.next().map(|val| *val as usize),
+            IndicesIter::U32(iter) => iter.next().map(|val| *val as usize),
+        }
+    }
+}
+
+impl From<&Indices> for IndexFormat {
+    fn from(indices: &Indices) -> Self {
+        match indices {
+            Indices::U16(_) => IndexFormat::Uint16,
+            Indices::U32(_) => IndexFormat::Uint32,
+        }
+    }
+}
+
+/// The GPU-representation of a [`Mesh`].
+/// Consists of a vertex data buffer and an optional index data buffer.
+#[derive(Debug, Clone)]
+pub struct GpuMesh {
+    /// Contains all attribute data for each vertex.
+    pub vertex_buffer: Buffer,
+    pub index_info: Option<GpuIndexInfo>,
+    pub has_tangents: bool,
+}
+
+/// The index info of a [`GpuMesh`].
+#[derive(Debug, Clone)]
+pub struct GpuIndexInfo {
+    /// Contains all index data of a mesh.
+    pub buffer: Buffer,
+    pub count: u32,
+    pub index_format: IndexFormat,
+}
+
+impl RenderAsset for Mesh {
+    type ExtractedAsset = Mesh;
+    type PreparedAsset = GpuMesh;
+    type Param = SRes<RenderDevice>;
+
+    /// Clones the mesh.
+    fn extract_asset(&self) -> Self::ExtractedAsset {
+        self.clone()
+    }
+
+    /// Converts the extracted mesh a into [`GpuMesh`].
+    fn prepare_asset(
+        mesh: Self::ExtractedAsset,
+        render_device: &mut SystemParamItem<Self::Param>,
+    ) -> Result<Self::PreparedAsset, PrepareAssetError<Self::ExtractedAsset>> {
+        let vertex_buffer_data = mesh.get_vertex_buffer_data();
+        let vertex_buffer = render_device.create_buffer_with_data(&BufferInitDescriptor {
+            usage: BufferUsages::VERTEX,
+            label: None,
+            contents: &vertex_buffer_data,
+        });
+
+        let index_info = mesh.get_index_buffer_bytes().map(|data| GpuIndexInfo {
+            buffer: render_device.create_buffer_with_data(&BufferInitDescriptor {
+                usage: BufferUsages::INDEX,
+                contents: data,
+                label: None,
+            }),
+            count: mesh.indices().unwrap().len() as u32,
+            index_format: mesh.indices().unwrap().into(),
+        });
+
+        Ok(GpuMesh {
+            vertex_buffer,
+            index_info,
+            has_tangents: mesh.attributes.contains_key(Mesh::ATTRIBUTE_TANGENT),
+        })
+    }
+}
diff --git a/pipelined/bevy_render2/src/mesh/mod.rs b/pipelined/bevy_render2/src/mesh/mod.rs
new file mode 100644
index 0000000000..6740bd02ef
--- /dev/null
+++ b/pipelined/bevy_render2/src/mesh/mod.rs
@@ -0,0 +1,20 @@
+#[allow(clippy::module_inception)]
+mod mesh;
+/// Generation for some primitive shape meshes.
+pub mod shape;
+
+pub use mesh::*;
+
+use crate::render_asset::RenderAssetPlugin;
+use bevy_app::{App, Plugin};
+use bevy_asset::AddAsset;
+
+/// Adds the [`Mesh`] as an asset and makes sure that they are extracted and prepared for the GPU.
+pub struct MeshPlugin;
+
+impl Plugin for MeshPlugin {
+    fn build(&self, app: &mut App) {
+        app.add_asset::<Mesh>()
+            .add_plugin(RenderAssetPlugin::<Mesh>::default());
+    }
+}
diff --git a/pipelined/bevy_render2/src/mesh/shape/capsule.rs b/pipelined/bevy_render2/src/mesh/shape/capsule.rs
new file mode 100644
index 0000000000..7b6d268a9a
--- /dev/null
+++ b/pipelined/bevy_render2/src/mesh/shape/capsule.rs
@@ -0,0 +1,379 @@
+use crate::mesh::{Indices, Mesh};
+use bevy_math::{Vec2, Vec3};
+use wgpu::PrimitiveTopology;
+
+/// A cylinder with hemispheres at the top and bottom
+#[derive(Debug, Copy, Clone)]
+pub struct Capsule {
+    /// Radius on the xz plane.
+    pub radius: f32,
+    /// Number of sections in cylinder between hemispheres.
+    pub rings: usize,
+    /// Height of the middle cylinder on the y axis, excluding the hemispheres.
+    pub depth: f32,
+    /// Number of latitudes, distributed by inclination. Must be even.
+    pub latitudes: usize,
+    /// Number of longitudes, or meridians, distributed by azimuth.
+    pub longitudes: usize,
+    /// Manner in which UV coordinates are distributed vertically.
+    pub uv_profile: CapsuleUvProfile,
+}
+impl Default for Capsule {
+    fn default() -> Self {
+        Capsule {
+            radius: 0.5,
+            rings: 0,
+            depth: 1.0,
+            latitudes: 16,
+            longitudes: 32,
+            uv_profile: CapsuleUvProfile::Aspect,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+/// Manner in which UV coordinates are distributed vertically.
+pub enum CapsuleUvProfile {
+    /// UV space is distributed by how much of the capsule consists of the hemispheres.
+    Aspect,
+    /// Hemispheres get UV space according to the ratio of latitudes to rings.
+    Uniform,
+    /// Upper third of the texture goes to the northern hemisphere, middle third to the cylinder
+    /// and lower third to the southern one.
+    Fixed,
+}
+
+impl Default for CapsuleUvProfile {
+    fn default() -> Self {
+        CapsuleUvProfile::Aspect
+    }
+}
+
+impl From<Capsule> for Mesh {
+    #[allow(clippy::needless_range_loop)]
+    fn from(capsule: Capsule) -> Self {
+        // code adapted from https://behreajj.medium.com/making-a-capsule-mesh-via-script-in-five-3d-environments-c2214abf02db
+
+        let Capsule {
+            radius,
+            rings,
+            depth,
+            latitudes,
+            longitudes,
+            uv_profile,
+        } = capsule;
+
+        let calc_middle = rings > 0;
+        let half_lats = latitudes / 2;
+        let half_latsn1 = half_lats - 1;
+        let half_latsn2 = half_lats - 2;
+        let ringsp1 = rings + 1;
+        let lonsp1 = longitudes + 1;
+        let half_depth = depth * 0.5;
+        let summit = half_depth + radius;
+
+        // Vertex index offsets.
+        let vert_offset_north_hemi = longitudes;
+        let vert_offset_north_equator = vert_offset_north_hemi + lonsp1 * half_latsn1;
+        let vert_offset_cylinder = vert_offset_north_equator + lonsp1;
+        let vert_offset_south_equator = if calc_middle {
+            vert_offset_cylinder + lonsp1 * rings
+        } else {
+            vert_offset_cylinder
+        };
+        let vert_offset_south_hemi = vert_offset_south_equator + lonsp1;
+        let vert_offset_south_polar = vert_offset_south_hemi + lonsp1 * half_latsn2;
+        let vert_offset_south_cap = vert_offset_south_polar + lonsp1;
+
+        // Initialize arrays.
+        let vert_len = vert_offset_south_cap + longitudes;
+
+        let mut vs: Vec<Vec3> = vec![Vec3::ZERO; vert_len];
+        let mut vts: Vec<Vec2> = vec![Vec2::ZERO; vert_len];
+        let mut vns: Vec<Vec3> = vec![Vec3::ZERO; vert_len];
+
+        let to_theta = 2.0 * std::f32::consts::PI / longitudes as f32;
+        let to_phi = std::f32::consts::PI / latitudes as f32;
+        let to_tex_horizontal = 1.0 / longitudes as f32;
+        let to_tex_vertical = 1.0 / half_lats as f32;
+
+        let vt_aspect_ratio = match uv_profile {
+            CapsuleUvProfile::Aspect => radius / (depth + radius + radius),
+            CapsuleUvProfile::Uniform => half_lats as f32 / (ringsp1 + latitudes) as f32,
+            CapsuleUvProfile::Fixed => 1.0 / 3.0,
+        };
+        let vt_aspect_north = 1.0 - vt_aspect_ratio;
+        let vt_aspect_south = vt_aspect_ratio;
+
+        let mut theta_cartesian: Vec<Vec2> = vec![Vec2::ZERO; longitudes];
+        let mut rho_theta_cartesian: Vec<Vec2> = vec![Vec2::ZERO; longitudes];
+        let mut s_texture_cache: Vec<f32> = vec![0.0; lonsp1];
+
+        for j in 0..longitudes {
+            let jf = j as f32;
+            let s_texture_polar = 1.0 - ((jf + 0.5) * to_tex_horizontal);
+            let theta = jf * to_theta;
+
+            let cos_theta = theta.cos();
+            let sin_theta = theta.sin();
+
+            theta_cartesian[j] = Vec2::new(cos_theta, sin_theta);
+            rho_theta_cartesian[j] = Vec2::new(radius * cos_theta, radius * sin_theta);
+
+            // North.
+            vs[j] = Vec3::new(0.0, summit, 0.0);
+            vts[j] = Vec2::new(s_texture_polar, 1.0);
+            vns[j] = Vec3::new(0.0, 1.0, 0.0);
+
+            // South.
+            let idx = vert_offset_south_cap + j;
+            vs[idx] = Vec3::new(0.0, -summit, 0.0);
+            vts[idx] = Vec2::new(s_texture_polar, 0.0);
+            vns[idx] = Vec3::new(0.0, -1.0, 0.0);
+        }
+
+        // Equatorial vertices.
+        for j in 0..lonsp1 {
+            let s_texture = 1.0 - j as f32 * to_tex_horizontal;
+            s_texture_cache[j] = s_texture;
+
+            // Wrap to first element upon reaching last.
+            let j_mod = j % longitudes;
+            let tc = theta_cartesian[j_mod];
+            let rtc = rho_theta_cartesian[j_mod];
+
+            // North equator.
+            let idxn = vert_offset_north_equator + j;
+            vs[idxn] = Vec3::new(rtc.x, half_depth, -rtc.y);
+            vts[idxn] = Vec2::new(s_texture, vt_aspect_north);
+            vns[idxn] = Vec3::new(tc.x, 0.0, -tc.y);
+
+            // South equator.
+            let idxs = vert_offset_south_equator + j;
+            vs[idxs] = Vec3::new(rtc.x, -half_depth, -rtc.y);
+            vts[idxs] = Vec2::new(s_texture, vt_aspect_south);
+            vns[idxs] = Vec3::new(tc.x, 0.0, -tc.y);
+        }
+
+        // Hemisphere vertices.
+        for i in 0..half_latsn1 {
+            let ip1f = i as f32 + 1.0;
+            let phi = ip1f * to_phi;
+
+            // For coordinates.
+            let cos_phi_south = phi.cos();
+            let sin_phi_south = phi.sin();
+
+            // Symmetrical hemispheres mean cosine and sine only needs
+            // to be calculated once.
+            let cos_phi_north = sin_phi_south;
+            let sin_phi_north = -cos_phi_south;
+
+            let rho_cos_phi_north = radius * cos_phi_north;
+            let rho_sin_phi_north = radius * sin_phi_north;
+            let z_offset_north = half_depth - rho_sin_phi_north;
+
+            let rho_cos_phi_south = radius * cos_phi_south;
+            let rho_sin_phi_south = radius * sin_phi_south;
+            let z_offset_sout = -half_depth - rho_sin_phi_south;
+
+            // For texture coordinates.
+            let t_tex_fac = ip1f * to_tex_vertical;
+            let cmpl_tex_fac = 1.0 - t_tex_fac;
+            let t_tex_north = cmpl_tex_fac + vt_aspect_north * t_tex_fac;
+            let t_tex_south = cmpl_tex_fac * vt_aspect_south;
+
+            let i_lonsp1 = i * lonsp1;
+            let vert_curr_lat_north = vert_offset_north_hemi + i_lonsp1;
+            let vert_curr_lat_south = vert_offset_south_hemi + i_lonsp1;
+
+            for j in 0..lonsp1 {
+                let j_mod = j % longitudes;
+
+                let s_texture = s_texture_cache[j];
+                let tc = theta_cartesian[j_mod];
+
+                // North hemisphere.
+                let idxn = vert_curr_lat_north + j;
+                vs[idxn] = Vec3::new(
+                    rho_cos_phi_north * tc.x,
+                    z_offset_north,
+                    -rho_cos_phi_north * tc.y,
+                );
+                vts[idxn] = Vec2::new(s_texture, t_tex_north);
+                vns[idxn] = Vec3::new(cos_phi_north * tc.x, -sin_phi_north, -cos_phi_north * tc.y);
+
+                // South hemisphere.
+                let idxs = vert_curr_lat_south + j;
+                vs[idxs] = Vec3::new(
+                    rho_cos_phi_south * tc.x,
+                    z_offset_sout,
+                    -rho_cos_phi_south * tc.y,
+                );
+                vts[idxs] = Vec2::new(s_texture, t_tex_south);
+                vns[idxs] = Vec3::new(cos_phi_south * tc.x, -sin_phi_south, -cos_phi_south * tc.y);
+            }
+        }
+
+        // Cylinder vertices.
+        if calc_middle {
+            // Exclude both origin and destination edges
+            // (North and South equators) from the interpolation.
+            let to_fac = 1.0 / ringsp1 as f32;
+            let mut idx_cyl_lat = vert_offset_cylinder;
+
+            for h in 1..ringsp1 {
+                let fac = h as f32 * to_fac;
+                let cmpl_fac = 1.0 - fac;
+                let t_texture = cmpl_fac * vt_aspect_north + fac * vt_aspect_south;
+                let z = half_depth - depth * fac;
+
+                for j in 0..lonsp1 {
+                    let j_mod = j % longitudes;
+                    let tc = theta_cartesian[j_mod];
+                    let rtc = rho_theta_cartesian[j_mod];
+                    let s_texture = s_texture_cache[j];
+
+                    vs[idx_cyl_lat] = Vec3::new(rtc.x, z, -rtc.y);
+                    vts[idx_cyl_lat] = Vec2::new(s_texture, t_texture);
+                    vns[idx_cyl_lat] = Vec3::new(tc.x, 0.0, -tc.y);
+
+                    idx_cyl_lat += 1;
+                }
+            }
+        }
+
+        // Triangle indices.
+
+        // Stride is 3 for polar triangles;
+        // stride is 6 for two triangles forming a quad.
+        let lons3 = longitudes * 3;
+        let lons6 = longitudes * 6;
+        let hemi_lons = half_latsn1 * lons6;
+
+        let tri_offset_north_hemi = lons3;
+        let tri_offset_cylinder = tri_offset_north_hemi + hemi_lons;
+        let tri_offset_south_hemi = tri_offset_cylinder + ringsp1 * lons6;
+        let tri_offset_south_cap = tri_offset_south_hemi + hemi_lons;
+
+        let fs_len = tri_offset_south_cap + lons3;
+        let mut tris: Vec<u32> = vec![0; fs_len];
+
+        // Polar caps.
+        let mut i = 0;
+        let mut k = 0;
+        let mut m = tri_offset_south_cap;
+        while i < longitudes {
+            // North.
+            tris[k] = i as u32;
+            tris[k + 1] = (vert_offset_north_hemi + i) as u32;
+            tris[k + 2] = (vert_offset_north_hemi + i + 1) as u32;
+
+            // South.
+            tris[m] = (vert_offset_south_cap + i) as u32;
+            tris[m + 1] = (vert_offset_south_polar + i + 1) as u32;
+            tris[m + 2] = (vert_offset_south_polar + i) as u32;
+
+            i += 1;
+            k += 3;
+            m += 3;
+        }
+
+        // Hemispheres.
+
+        let mut i = 0;
+        let mut k = tri_offset_north_hemi;
+        let mut m = tri_offset_south_hemi;
+
+        while i < half_latsn1 {
+            let i_lonsp1 = i * lonsp1;
+
+            let vert_curr_lat_north = vert_offset_north_hemi + i_lonsp1;
+            let vert_next_lat_north = vert_curr_lat_north + lonsp1;
+
+            let vert_curr_lat_south = vert_offset_south_equator + i_lonsp1;
+            let vert_next_lat_south = vert_curr_lat_south + lonsp1;
+
+            let mut j = 0;
+            while j < longitudes {
+                // North.
+                let north00 = vert_curr_lat_north + j;
+                let north01 = vert_next_lat_north + j;
+                let north11 = vert_next_lat_north + j + 1;
+                let north10 = vert_curr_lat_north + j + 1;
+
+                tris[k] = north00 as u32;
+                tris[k + 1] = north11 as u32;
+                tris[k + 2] = north10 as u32;
+
+                tris[k + 3] = north00 as u32;
+                tris[k + 4] = north01 as u32;
+                tris[k + 5] = north11 as u32;
+
+                // South.
+                let south00 = vert_curr_lat_south + j;
+                let south01 = vert_next_lat_south + j;
+                let south11 = vert_next_lat_south + j + 1;
+                let south10 = vert_curr_lat_south + j + 1;
+
+                tris[m] = south00 as u32;
+                tris[m + 1] = south11 as u32;
+                tris[m + 2] = south10 as u32;
+
+                tris[m + 3] = south00 as u32;
+                tris[m + 4] = south01 as u32;
+                tris[m + 5] = south11 as u32;
+
+                j += 1;
+                k += 6;
+                m += 6;
+            }
+
+            i += 1;
+        }
+
+        // Cylinder.
+        let mut i = 0;
+        let mut k = tri_offset_cylinder;
+
+        while i < ringsp1 {
+            let vert_curr_lat = vert_offset_north_equator + i * lonsp1;
+            let vert_next_lat = vert_curr_lat + lonsp1;
+
+            let mut j = 0;
+            while j < longitudes {
+                let cy00 = vert_curr_lat + j;
+                let cy01 = vert_next_lat + j;
+                let cy11 = vert_next_lat + j + 1;
+                let cy10 = vert_curr_lat + j + 1;
+
+                tris[k] = cy00 as u32;
+                tris[k + 1] = cy11 as u32;
+                tris[k + 2] = cy10 as u32;
+
+                tris[k + 3] = cy00 as u32;
+                tris[k + 4] = cy01 as u32;
+                tris[k + 5] = cy11 as u32;
+
+                j += 1;
+                k += 6;
+            }
+
+            i += 1;
+        }
+
+        let vs: Vec<[f32; 3]> = vs.into_iter().map(Into::into).collect();
+        let vns: Vec<[f32; 3]> = vns.into_iter().map(Into::into).collect();
+        let vts: Vec<[f32; 2]> = vts.into_iter().map(Into::into).collect();
+
+        assert_eq!(vs.len(), vert_len);
+        assert_eq!(tris.len(), fs_len);
+
+        let mut mesh = Mesh::new(PrimitiveTopology::TriangleList);
+        mesh.set_attribute(Mesh::ATTRIBUTE_POSITION, vs);
+        mesh.set_attribute(Mesh::ATTRIBUTE_NORMAL, vns);
+        mesh.set_attribute(Mesh::ATTRIBUTE_UV_0, vts);
+        mesh.set_indices(Some(Indices::U32(tris)));
+        mesh
+    }
+}
diff --git a/pipelined/bevy_render2/src/mesh/shape/icosphere.rs b/pipelined/bevy_render2/src/mesh/shape/icosphere.rs
new file mode 100644
index 0000000000..ff2068469e
--- /dev/null
+++ b/pipelined/bevy_render2/src/mesh/shape/icosphere.rs
@@ -0,0 +1,103 @@
+use crate::mesh::{Indices, Mesh};
+use hexasphere::shapes::IcoSphere;
+use wgpu::PrimitiveTopology;
+
+/// A sphere made from a subdivided Icosahedron.
+#[derive(Debug, Clone, Copy)]
+pub struct Icosphere {
+    /// The radius of the sphere.
+    pub radius: f32,
+    /// The number of subdivisions applied.
+    pub subdivisions: usize,
+}
+
+impl Default for Icosphere {
+    fn default() -> Self {
+        Self {
+            radius: 1.0,
+            subdivisions: 5,
+        }
+    }
+}
+
+impl From<Icosphere> for Mesh {
+    fn from(sphere: Icosphere) -> Self {
+        if sphere.subdivisions >= 80 {
+            /*
+            Number of triangles:
+            N = 20
+
+            Number of edges:
+            E = 30
+
+            Number of vertices:
+            V = 12
+
+            Number of points within a triangle (triangular numbers):
+            inner(s) = (s^2 + s) / 2
+
+            Number of points on an edge:
+            edges(s) = s
+
+            Add up all vertices on the surface:
+            vertices(s) = edges(s) * E + inner(s - 1) * N + V
+
+            Expand and simplify. Notice that the triangular number formula has roots at -1, and 0, so translating it one to the right fixes it.
+            subdivisions(s) = 30s + 20((s^2 - 2s + 1 + s - 1) / 2) + 12
+            subdivisions(s) = 30s + 10s^2 - 10s + 12
+            subdivisions(s) = 10(s^2 + 2s) + 12
+
+            Factor an (s + 1) term to simplify in terms of calculation
+            subdivisions(s) = 10(s + 1)^2 + 12 - 10
+            resulting_vertices(s) = 10(s + 1)^2 + 2
+            */
+            let temp = sphere.subdivisions + 1;
+            let number_of_resulting_points = temp * temp * 10 + 2;
+
+            panic!(
+                "Cannot create an icosphere of {} subdivisions due to there being too many vertices being generated: {}. (Limited to 65535 vertices or 79 subdivisions)",
+                sphere.subdivisions,
+                number_of_resulting_points
+            );
+        }
+        let generated = IcoSphere::new(sphere.subdivisions, |point| {
+            let inclination = point.y.acos();
+            let azimuth = point.z.atan2(point.x);
+
+            let norm_inclination = inclination / std::f32::consts::PI;
+            let norm_azimuth = 0.5 - (azimuth / std::f32::consts::TAU);
+
+            [norm_azimuth, norm_inclination]
+        });
+
+        let raw_points = generated.raw_points();
+
+        let points = raw_points
+            .iter()
+            .map(|&p| (p * sphere.radius).into())
+            .collect::<Vec<[f32; 3]>>();
+
+        let normals = raw_points
+            .iter()
+            .copied()
+            .map(Into::into)
+            .collect::<Vec<[f32; 3]>>();
+
+        let uvs = generated.raw_data().to_owned();
+
+        let mut indices = Vec::with_capacity(generated.indices_per_main_triangle() * 20);
+
+        for i in 0..20 {
+            generated.get_indices(i, &mut indices);
+        }
+
+        let indices = Indices::U32(indices);
+
+        let mut mesh = Mesh::new(PrimitiveTopology::TriangleList);
+        mesh.set_indices(Some(indices));
+        mesh.set_attribute(Mesh::ATTRIBUTE_POSITION, points);
+        mesh.set_attribute(Mesh::ATTRIBUTE_NORMAL, normals);
+        mesh.set_attribute(Mesh::ATTRIBUTE_UV_0, uvs);
+        mesh
+    }
+}
diff --git a/pipelined/bevy_render2/src/mesh/shape/mod.rs b/pipelined/bevy_render2/src/mesh/shape/mod.rs
new file mode 100644
index 0000000000..e2aa285d20
--- /dev/null
+++ b/pipelined/bevy_render2/src/mesh/shape/mod.rs
@@ -0,0 +1,278 @@
+use super::{Indices, Mesh};
+use bevy_math::*;
+
+#[derive(Debug, Copy, Clone)]
+pub struct Cube {
+    pub size: f32,
+}
+
+impl Cube {
+    pub fn new(size: f32) -> Cube {
+        Cube { size }
+    }
+}
+
+impl Default for Cube {
+    fn default() -> Self {
+        Cube { size: 1.0 }
+    }
+}
+
+impl From<Cube> for Mesh {
+    fn from(cube: Cube) -> Self {
+        Box::new(cube.size, cube.size, cube.size).into()
+    }
+}
+
+/// An axis-aligned box defined by its minimum and maximum point.
+#[derive(Debug, Copy, Clone)]
+pub struct Box {
+    pub min_x: f32,
+    pub max_x: f32,
+
+    pub min_y: f32,
+    pub max_y: f32,
+
+    pub min_z: f32,
+    pub max_z: f32,
+}
+
+impl Box {
+    /// Creates a new box centered at the origin with the supplied side lengths.
+    pub fn new(x_length: f32, y_length: f32, z_length: f32) -> Box {
+        Box {
+            max_x: x_length / 2.0,
+            min_x: -x_length / 2.0,
+            max_y: y_length / 2.0,
+            min_y: -y_length / 2.0,
+            max_z: z_length / 2.0,
+            min_z: -z_length / 2.0,
+        }
+    }
+}
+
+impl Default for Box {
+    fn default() -> Self {
+        Box::new(2.0, 1.0, 1.0)
+    }
+}
+
+impl From<Box> for Mesh {
+    fn from(sp: Box) -> Self {
+        let vertices = &[
+            // Top
+            ([sp.min_x, sp.min_y, sp.max_z], [0., 0., 1.0], [0., 0.]),
+            ([sp.max_x, sp.min_y, sp.max_z], [0., 0., 1.0], [1.0, 0.]),
+            ([sp.max_x, sp.max_y, sp.max_z], [0., 0., 1.0], [1.0, 1.0]),
+            ([sp.min_x, sp.max_y, sp.max_z], [0., 0., 1.0], [0., 1.0]),
+            // Bottom
+            ([sp.min_x, sp.max_y, sp.min_z], [0., 0., -1.0], [1.0, 0.]),
+            ([sp.max_x, sp.max_y, sp.min_z], [0., 0., -1.0], [0., 0.]),
+            ([sp.max_x, sp.min_y, sp.min_z], [0., 0., -1.0], [0., 1.0]),
+            ([sp.min_x, sp.min_y, sp.min_z], [0., 0., -1.0], [1.0, 1.0]),
+            // Right
+            ([sp.max_x, sp.min_y, sp.min_z], [1.0, 0., 0.], [0., 0.]),
+            ([sp.max_x, sp.max_y, sp.min_z], [1.0, 0., 0.], [1.0, 0.]),
+            ([sp.max_x, sp.max_y, sp.max_z], [1.0, 0., 0.], [1.0, 1.0]),
+            ([sp.max_x, sp.min_y, sp.max_z], [1.0, 0., 0.], [0., 1.0]),
+            // Left
+            ([sp.min_x, sp.min_y, sp.max_z], [-1.0, 0., 0.], [1.0, 0.]),
+            ([sp.min_x, sp.max_y, sp.max_z], [-1.0, 0., 0.], [0., 0.]),
+            ([sp.min_x, sp.max_y, sp.min_z], [-1.0, 0., 0.], [0., 1.0]),
+            ([sp.min_x, sp.min_y, sp.min_z], [-1.0, 0., 0.], [1.0, 1.0]),
+            // Front
+            ([sp.max_x, sp.max_y, sp.min_z], [0., 1.0, 0.], [1.0, 0.]),
+            ([sp.min_x, sp.max_y, sp.min_z], [0., 1.0, 0.], [0., 0.]),
+            ([sp.min_x, sp.max_y, sp.max_z], [0., 1.0, 0.], [0., 1.0]),
+            ([sp.max_x, sp.max_y, sp.max_z], [0., 1.0, 0.], [1.0, 1.0]),
+            // Back
+            ([sp.max_x, sp.min_y, sp.max_z], [0., -1.0, 0.], [0., 0.]),
+            ([sp.min_x, sp.min_y, sp.max_z], [0., -1.0, 0.], [1.0, 0.]),
+            ([sp.min_x, sp.min_y, sp.min_z], [0., -1.0, 0.], [1.0, 1.0]),
+            ([sp.max_x, sp.min_y, sp.min_z], [0., -1.0, 0.], [0., 1.0]),
+        ];
+
+        let mut positions = Vec::with_capacity(24);
+        let mut normals = Vec::with_capacity(24);
+        let mut uvs = Vec::with_capacity(24);
+
+        for (position, normal, uv) in vertices.iter() {
+            positions.push(*position);
+            normals.push(*normal);
+            uvs.push(*uv);
+        }
+
+        let indices = Indices::U32(vec![
+            0, 1, 2, 2, 3, 0, // top
+            4, 5, 6, 6, 7, 4, // bottom
+            8, 9, 10, 10, 11, 8, // right
+            12, 13, 14, 14, 15, 12, // left
+            16, 17, 18, 18, 19, 16, // front
+            20, 21, 22, 22, 23, 20, // back
+        ]);
+
+        let mut mesh = Mesh::new(PrimitiveTopology::TriangleList);
+        mesh.set_attribute(Mesh::ATTRIBUTE_POSITION, positions);
+        mesh.set_attribute(Mesh::ATTRIBUTE_NORMAL, normals);
+        mesh.set_attribute(Mesh::ATTRIBUTE_UV_0, uvs);
+        mesh.set_indices(Some(indices));
+        mesh
+    }
+}
+
+/// A rectangle on the XY plane centered at the origin.
+#[derive(Debug, Copy, Clone)]
+pub struct Quad {
+    /// Full width and height of the rectangle.
+    pub size: Vec2,
+    /// Flips the texture coords of the resulting vertices.
+    pub flip: bool,
+}
+
+impl Default for Quad {
+    fn default() -> Self {
+        Quad::new(Vec2::ONE)
+    }
+}
+
+impl Quad {
+    pub fn new(size: Vec2) -> Self {
+        Self { size, flip: false }
+    }
+
+    pub fn flipped(size: Vec2) -> Self {
+        Self { size, flip: true }
+    }
+}
+
+impl From<Quad> for Mesh {
+    fn from(quad: Quad) -> Self {
+        let extent_x = quad.size.x / 2.0;
+        let extent_y = quad.size.y / 2.0;
+
+        let north_west = vec2(-extent_x, extent_y);
+        let north_east = vec2(extent_x, extent_y);
+        let south_west = vec2(-extent_x, -extent_y);
+        let south_east = vec2(extent_x, -extent_y);
+        let vertices = if quad.flip {
+            [
+                (
+                    [south_east.x, south_east.y, 0.0],
+                    [0.0, 0.0, 1.0],
+                    [1.0, 1.0],
+                ),
+                (
+                    [north_east.x, north_east.y, 0.0],
+                    [0.0, 0.0, 1.0],
+                    [1.0, 0.0],
+                ),
+                (
+                    [north_west.x, north_west.y, 0.0],
+                    [0.0, 0.0, 1.0],
+                    [0.0, 0.0],
+                ),
+                (
+                    [south_west.x, south_west.y, 0.0],
+                    [0.0, 0.0, 1.0],
+                    [0.0, 1.0],
+                ),
+            ]
+        } else {
+            [
+                (
+                    [south_west.x, south_west.y, 0.0],
+                    [0.0, 0.0, 1.0],
+                    [0.0, 1.0],
+                ),
+                (
+                    [north_west.x, north_west.y, 0.0],
+                    [0.0, 0.0, 1.0],
+                    [0.0, 0.0],
+                ),
+                (
+                    [north_east.x, north_east.y, 0.0],
+                    [0.0, 0.0, 1.0],
+                    [1.0, 0.0],
+                ),
+                (
+                    [south_east.x, south_east.y, 0.0],
+                    [0.0, 0.0, 1.0],
+                    [1.0, 1.0],
+                ),
+            ]
+        };
+
+        let indices = Indices::U32(vec![0, 2, 1, 0, 3, 2]);
+
+        let mut positions = Vec::<[f32; 3]>::new();
+        let mut normals = Vec::<[f32; 3]>::new();
+        let mut uvs = Vec::<[f32; 2]>::new();
+        for (position, normal, uv) in vertices.iter() {
+            positions.push(*position);
+            normals.push(*normal);
+            uvs.push(*uv);
+        }
+
+        let mut mesh = Mesh::new(PrimitiveTopology::TriangleList);
+        mesh.set_indices(Some(indices));
+        mesh.set_attribute(Mesh::ATTRIBUTE_POSITION, positions);
+        mesh.set_attribute(Mesh::ATTRIBUTE_NORMAL, normals);
+        mesh.set_attribute(Mesh::ATTRIBUTE_UV_0, uvs);
+        mesh
+    }
+}
+
+/// A square on the XZ plane centered at the origin.
+#[derive(Debug, Copy, Clone)]
+pub struct Plane {
+    /// The total side length of the square.
+    pub size: f32,
+}
+
+impl Default for Plane {
+    fn default() -> Self {
+        Plane { size: 1.0 }
+    }
+}
+
+impl From<Plane> for Mesh {
+    fn from(plane: Plane) -> Self {
+        let extent = plane.size / 2.0;
+
+        let vertices = [
+            ([extent, 0.0, -extent], [0.0, 1.0, 0.0], [1.0, 1.0]),
+            ([extent, 0.0, extent], [0.0, 1.0, 0.0], [1.0, 0.0]),
+            ([-extent, 0.0, extent], [0.0, 1.0, 0.0], [0.0, 0.0]),
+            ([-extent, 0.0, -extent], [0.0, 1.0, 0.0], [0.0, 1.0]),
+        ];
+
+        let indices = Indices::U32(vec![0, 2, 1, 0, 3, 2]);
+
+        let mut positions = Vec::new();
+        let mut normals = Vec::new();
+        let mut uvs = Vec::new();
+        for (position, normal, uv) in vertices.iter() {
+            positions.push(*position);
+            normals.push(*normal);
+            uvs.push(*uv);
+        }
+
+        let mut mesh = Mesh::new(PrimitiveTopology::TriangleList);
+        mesh.set_indices(Some(indices));
+        mesh.set_attribute(Mesh::ATTRIBUTE_POSITION, positions);
+        mesh.set_attribute(Mesh::ATTRIBUTE_NORMAL, normals);
+        mesh.set_attribute(Mesh::ATTRIBUTE_UV_0, uvs);
+        mesh
+    }
+}
+
+mod capsule;
+mod icosphere;
+mod torus;
+mod uvsphere;
+
+pub use capsule::{Capsule, CapsuleUvProfile};
+pub use icosphere::Icosphere;
+pub use torus::Torus;
+pub use uvsphere::UVSphere;
+use wgpu::PrimitiveTopology;
diff --git a/pipelined/bevy_render2/src/mesh/shape/torus.rs b/pipelined/bevy_render2/src/mesh/shape/torus.rs
new file mode 100644
index 0000000000..987cb3b230
--- /dev/null
+++ b/pipelined/bevy_render2/src/mesh/shape/torus.rs
@@ -0,0 +1,92 @@
+use crate::mesh::{Indices, Mesh};
+use bevy_math::Vec3;
+use wgpu::PrimitiveTopology;
+
+/// A torus (donut) shape.
+#[derive(Debug, Clone, Copy)]
+pub struct Torus {
+    pub radius: f32,
+    pub ring_radius: f32,
+    pub subdivisions_segments: usize,
+    pub subdivisions_sides: usize,
+}
+
+impl Default for Torus {
+    fn default() -> Self {
+        Torus {
+            radius: 1.0,
+            ring_radius: 0.5,
+            subdivisions_segments: 32,
+            subdivisions_sides: 24,
+        }
+    }
+}
+
+impl From<Torus> for Mesh {
+    fn from(torus: Torus) -> Self {
+        // code adapted from http://apparat-engine.blogspot.com/2013/04/procedural-meshes-torus.html
+        // (source code at https://github.com/SEilers/Apparat)
+
+        let n_vertices = (torus.subdivisions_segments + 1) * (torus.subdivisions_sides + 1);
+        let mut positions: Vec<[f32; 3]> = Vec::with_capacity(n_vertices);
+        let mut normals: Vec<[f32; 3]> = Vec::with_capacity(n_vertices);
+        let mut uvs: Vec<[f32; 2]> = Vec::with_capacity(n_vertices);
+
+        let segment_stride = 2.0 * std::f32::consts::PI / torus.subdivisions_segments as f32;
+        let side_stride = 2.0 * std::f32::consts::PI / torus.subdivisions_sides as f32;
+
+        for segment in 0..=torus.subdivisions_segments {
+            let theta = segment_stride * segment as f32;
+            let segment_pos = Vec3::new(theta.cos(), 0.0, theta.sin() * torus.radius);
+
+            for side in 0..=torus.subdivisions_sides {
+                let phi = side_stride * side as f32;
+
+                let x = theta.cos() * (torus.radius + torus.ring_radius * phi.cos());
+                let z = theta.sin() * (torus.radius + torus.ring_radius * phi.cos());
+                let y = torus.ring_radius * phi.sin();
+
+                let normal = segment_pos.cross(Vec3::Y).normalize();
+
+                positions.push([x, y, z]);
+                normals.push(normal.into());
+                uvs.push([
+                    segment as f32 / torus.subdivisions_segments as f32,
+                    side as f32 / torus.subdivisions_sides as f32,
+                ]);
+            }
+        }
+
+        let n_faces = (torus.subdivisions_segments) * (torus.subdivisions_sides);
+        let n_triangles = n_faces * 2;
+        let n_indices = n_triangles * 3;
+
+        let mut indices: Vec<u32> = Vec::with_capacity(n_indices);
+
+        let n_vertices_per_row = torus.subdivisions_sides + 1;
+        for segment in 0..torus.subdivisions_segments {
+            for side in 0..torus.subdivisions_sides {
+                let lt = side + segment * n_vertices_per_row;
+                let rt = (side + 1) + segment * n_vertices_per_row;
+
+                let lb = side + (segment + 1) * n_vertices_per_row;
+                let rb = (side + 1) + (segment + 1) * n_vertices_per_row;
+
+                indices.push(lt as u32);
+                indices.push(rt as u32);
+                indices.push(lb as u32);
+
+                indices.push(rt as u32);
+                indices.push(rb as u32);
+                indices.push(lb as u32);
+            }
+        }
+
+        let mut mesh = Mesh::new(PrimitiveTopology::TriangleList);
+        mesh.set_indices(Some(Indices::U32(indices)));
+        mesh.set_attribute(Mesh::ATTRIBUTE_POSITION, positions);
+        mesh.set_attribute(Mesh::ATTRIBUTE_NORMAL, normals);
+        mesh.set_attribute(Mesh::ATTRIBUTE_UV_0, uvs);
+        mesh
+    }
+}
diff --git a/pipelined/bevy_render2/src/mesh/shape/uvsphere.rs b/pipelined/bevy_render2/src/mesh/shape/uvsphere.rs
new file mode 100644
index 0000000000..571c3123d9
--- /dev/null
+++ b/pipelined/bevy_render2/src/mesh/shape/uvsphere.rs
@@ -0,0 +1,90 @@
+use wgpu::PrimitiveTopology;
+
+use crate::mesh::{Indices, Mesh};
+use std::f32::consts::PI;
+
+/// A sphere made of sectors and stacks.
+#[allow(clippy::upper_case_acronyms)]
+#[derive(Debug, Clone, Copy)]
+pub struct UVSphere {
+    /// The radius of the sphere.
+    pub radius: f32,
+    /// Longitudinal sectors
+    pub sectors: usize,
+    /// Latitudinal stacks
+    pub stacks: usize,
+}
+
+impl Default for UVSphere {
+    fn default() -> Self {
+        Self {
+            radius: 1.0,
+            sectors: 36,
+            stacks: 18,
+        }
+    }
+}
+
+impl From<UVSphere> for Mesh {
+    fn from(sphere: UVSphere) -> Self {
+        // Largely inspired from http://www.songho.ca/opengl/gl_sphere.html
+
+        let sectors = sphere.sectors as f32;
+        let stacks = sphere.stacks as f32;
+        let length_inv = 1. / sphere.radius;
+        let sector_step = 2. * PI / sectors;
+        let stack_step = PI / stacks;
+
+        let mut vertices: Vec<[f32; 3]> = Vec::with_capacity(sphere.stacks * sphere.sectors);
+        let mut normals: Vec<[f32; 3]> = Vec::with_capacity(sphere.stacks * sphere.sectors);
+        let mut uvs: Vec<[f32; 2]> = Vec::with_capacity(sphere.stacks * sphere.sectors);
+        let mut indices: Vec<u32> = Vec::with_capacity(sphere.stacks * sphere.sectors * 2 * 3);
+
+        for i in 0..sphere.stacks + 1 {
+            let stack_angle = PI / 2. - (i as f32) * stack_step;
+            let xy = sphere.radius * stack_angle.cos();
+            let z = sphere.radius * stack_angle.sin();
+
+            for j in 0..sphere.sectors + 1 {
+                let sector_angle = (j as f32) * sector_step;
+                let x = xy * sector_angle.cos();
+                let y = xy * sector_angle.sin();
+
+                vertices.push([x, y, z]);
+                normals.push([x * length_inv, y * length_inv, z * length_inv]);
+                uvs.push([(j as f32) / sectors, (i as f32) / stacks]);
+            }
+        }
+
+        // indices
+        //  k1--k1+1
+        //  |  / |
+        //  | /  |
+        //  k2--k2+1
+        for i in 0..sphere.stacks {
+            let mut k1 = i * (sphere.sectors + 1);
+            let mut k2 = k1 + sphere.sectors + 1;
+            for _j in 0..sphere.sectors {
+                if i != 0 {
+                    indices.push(k1 as u32);
+                    indices.push(k2 as u32);
+                    indices.push((k1 + 1) as u32);
+                }
+                if i != sphere.stacks - 1 {
+                    indices.push((k1 + 1) as u32);
+                    indices.push(k2 as u32);
+                    indices.push((k2 + 1) as u32);
+                }
+                k1 += 1;
+                k2 += 1;
+            }
+        }
+
+        let mut mesh = Mesh::new(PrimitiveTopology::TriangleList);
+        mesh.set_indices(Some(Indices::U32(indices)));
+        mesh.set_attribute(Mesh::ATTRIBUTE_POSITION, vertices);
+        mesh.set_attribute(Mesh::ATTRIBUTE_NORMAL, normals);
+        mesh.set_attribute(Mesh::ATTRIBUTE_UV_0, uvs);
+        mesh
+    }
+}
diff --git a/pipelined/bevy_render2/src/primitives/mod.rs b/pipelined/bevy_render2/src/primitives/mod.rs
new file mode 100644
index 0000000000..7d0df7a1be
--- /dev/null
+++ b/pipelined/bevy_render2/src/primitives/mod.rs
@@ -0,0 +1,140 @@
+use bevy_ecs::{component::Component, reflect::ReflectComponent};
+use bevy_math::{Mat4, Vec3, Vec3A, Vec4};
+use bevy_reflect::Reflect;
+
+/// An Axis-Aligned Bounding Box
+#[derive(Component, Clone, Debug, Default, Reflect)]
+#[reflect(Component)]
+pub struct Aabb {
+    pub center: Vec3,
+    pub half_extents: Vec3,
+}
+
+impl Aabb {
+    pub fn from_min_max(minimum: Vec3, maximum: Vec3) -> Self {
+        let center = 0.5 * (maximum + minimum);
+        let half_extents = 0.5 * (maximum - minimum);
+        Self {
+            center,
+            half_extents,
+        }
+    }
+
+    /// Calculate the relative radius of the AABB with respect to a plane
+    pub fn relative_radius(&self, p_normal: &Vec3A, axes: &[Vec3A]) -> f32 {
+        // NOTE: dot products on Vec3A use SIMD and even with the overhead of conversion are net faster than Vec3
+        let half_extents = Vec3A::from(self.half_extents);
+        Vec3A::new(
+            p_normal.dot(axes[0]),
+            p_normal.dot(axes[1]),
+            p_normal.dot(axes[2]),
+        )
+        .abs()
+        .dot(half_extents)
+    }
+}
+
+#[derive(Debug, Default)]
+pub struct Sphere {
+    pub center: Vec3,
+    pub radius: f32,
+}
+
+impl Sphere {
+    pub fn intersects_obb(&self, aabb: &Aabb, model_to_world: &Mat4) -> bool {
+        let aabb_center_world = *model_to_world * aabb.center.extend(1.0);
+        let axes = [
+            Vec3A::from(model_to_world.x_axis),
+            Vec3A::from(model_to_world.y_axis),
+            Vec3A::from(model_to_world.z_axis),
+        ];
+        let v = Vec3A::from(aabb_center_world) - Vec3A::from(self.center);
+        let d = v.length();
+        let relative_radius = aabb.relative_radius(&(v / d), &axes);
+        d < self.radius + relative_radius
+    }
+}
+
+/// A plane defined by a normal and distance value along the normal
+/// Any point p is in the plane if n.p = d
+/// For planes defining half-spaces such as for frusta, if n.p > d then p is on the positive side of the plane.
+#[derive(Clone, Copy, Debug, Default)]
+pub struct Plane {
+    pub normal_d: Vec4,
+}
+
+#[derive(Component, Clone, Copy, Debug, Default)]
+pub struct Frustum {
+    pub planes: [Plane; 6],
+}
+
+impl Frustum {
+    // NOTE: This approach of extracting the frustum planes from the view
+    // projection matrix is from Foundations of Game Engine Development 2
+    // Rendering by Lengyel. Slight modification has been made for when
+    // the far plane is infinite but we still want to cull to a far plane.
+    pub fn from_view_projection(
+        view_projection: &Mat4,
+        view_translation: &Vec3,
+        view_backward: &Vec3,
+        far: f32,
+    ) -> Self {
+        let row3 = view_projection.row(3);
+        let mut planes = [Plane::default(); 6];
+        for (i, plane) in planes.iter_mut().enumerate().take(5) {
+            let row = view_projection.row(i / 2);
+            plane.normal_d = if (i & 1) == 0 && i != 4 {
+                row3 + row
+            } else {
+                row3 - row
+            }
+            .normalize();
+        }
+        let far_center = *view_translation - far * *view_backward;
+        planes[5].normal_d = view_backward
+            .extend(-view_backward.dot(far_center))
+            .normalize();
+        Self { planes }
+    }
+
+    pub fn intersects_sphere(&self, sphere: &Sphere) -> bool {
+        for plane in &self.planes {
+            if plane.normal_d.dot(sphere.center.extend(1.0)) + sphere.radius <= 0.0 {
+                return false;
+            }
+        }
+        true
+    }
+
+    pub fn intersects_obb(&self, aabb: &Aabb, model_to_world: &Mat4) -> bool {
+        let aabb_center_world = *model_to_world * aabb.center.extend(1.0);
+        let axes = [
+            Vec3A::from(model_to_world.x_axis),
+            Vec3A::from(model_to_world.y_axis),
+            Vec3A::from(model_to_world.z_axis),
+        ];
+
+        for plane in &self.planes {
+            let p_normal = Vec3A::from(plane.normal_d);
+            let relative_radius = aabb.relative_radius(&p_normal, &axes);
+            if plane.normal_d.dot(aabb_center_world) + relative_radius <= 0.0 {
+                return false;
+            }
+        }
+        true
+    }
+}
+
+#[derive(Component, Debug, Default)]
+pub struct CubemapFrusta {
+    pub frusta: [Frustum; 6],
+}
+
+impl CubemapFrusta {
+    pub fn iter(&self) -> impl DoubleEndedIterator<Item = &Frustum> {
+        self.frusta.iter()
+    }
+    pub fn iter_mut(&mut self) -> impl DoubleEndedIterator<Item = &mut Frustum> {
+        self.frusta.iter_mut()
+    }
+}
diff --git a/pipelined/bevy_render2/src/render_asset.rs b/pipelined/bevy_render2/src/render_asset.rs
new file mode 100644
index 0000000000..6b259efd71
--- /dev/null
+++ b/pipelined/bevy_render2/src/render_asset.rs
@@ -0,0 +1,184 @@
+use crate::{RenderApp, RenderStage};
+use bevy_app::{App, Plugin};
+use bevy_asset::{Asset, AssetEvent, Assets, Handle};
+use bevy_ecs::{
+    prelude::*,
+    system::{lifetimeless::*, RunSystem, SystemParam, SystemParamItem},
+};
+use bevy_utils::{HashMap, HashSet};
+use std::marker::PhantomData;
+
+pub enum PrepareAssetError<E: Send + Sync + 'static> {
+    RetryNextUpdate(E),
+}
+
+/// Describes how an asset gets extracted and prepared for rendering.
+///
+/// In the [`RenderStage::Extract`](crate::RenderStage::Extract) step the asset is transferred
+/// from the "app world" into the "render world".
+/// Therefore it is converted into a [`RenderAsset::ExtractedAsset`], which may be the same type
+/// as the render asset itself.
+///
+/// After that in the [`RenderStage::Prepare`](crate::RenderStage::Prepare) step the extracted asset
+/// is transformed into its GPU-representation of type [`RenderAsset::PreparedAsset`].
+pub trait RenderAsset: Asset {
+    /// The representation of the the asset in the "render world".
+    type ExtractedAsset: Send + Sync + 'static;
+    /// The GPU-representation of the the asset.
+    type PreparedAsset: Send + Sync + 'static;
+    /// Specifies all ECS data required by [`RenderAsset::prepare_asset`].
+    /// For convenience use the [`lifetimeless`](bevy_ecs::system::lifetimeless) SystemParams.
+    type Param: SystemParam;
+    /// Converts the asset into a [`RenderAsset::ExtractedAsset`].
+    fn extract_asset(&self) -> Self::ExtractedAsset;
+    /// Prepares the `extracted asset` for the GPU by transforming it into
+    /// a [`RenderAsset::PreparedAsset`]. Therefore ECS data may be accessed via the `param`.
+    fn prepare_asset(
+        extracted_asset: Self::ExtractedAsset,
+        param: &mut SystemParamItem<Self::Param>,
+    ) -> Result<Self::PreparedAsset, PrepareAssetError<Self::ExtractedAsset>>;
+}
+
+/// This plugin extracts the changed assets from the "app world" into the "render world"
+/// and prepares them for the GPU. They can then be accessed from the [`RenderAssets`] resource.
+///
+/// Therefore it sets up the [`RenderStage::Extract`](crate::RenderStage::Extract) and
+/// [`RenderStage::Prepare`](crate::RenderStage::Prepare) steps for the specified [`RenderAsset`].
+pub struct RenderAssetPlugin<A: RenderAsset>(PhantomData<fn() -> A>);
+
+impl<A: RenderAsset> Default for RenderAssetPlugin<A> {
+    fn default() -> Self {
+        Self(PhantomData)
+    }
+}
+
+impl<A: RenderAsset> Plugin for RenderAssetPlugin<A> {
+    fn build(&self, app: &mut App) {
+        let render_app = app.sub_app(RenderApp);
+        let prepare_asset_system = PrepareAssetSystem::<A>::system(&mut render_app.world);
+        render_app
+            .init_resource::<ExtractedAssets<A>>()
+            .init_resource::<RenderAssets<A>>()
+            .init_resource::<PrepareNextFrameAssets<A>>()
+            .add_system_to_stage(RenderStage::Extract, extract_render_asset::<A>)
+            .add_system_to_stage(RenderStage::Prepare, prepare_asset_system);
+    }
+}
+
+/// Temporarily stores the extracted and removed assets of the current frame.
+pub struct ExtractedAssets<A: RenderAsset> {
+    extracted: Vec<(Handle<A>, A::ExtractedAsset)>,
+    removed: Vec<Handle<A>>,
+}
+
+impl<A: RenderAsset> Default for ExtractedAssets<A> {
+    fn default() -> Self {
+        Self {
+            extracted: Default::default(),
+            removed: Default::default(),
+        }
+    }
+}
+
+/// Stores all GPU representations ([`RenderAsset::PreparedAssets`](RenderAsset::PreparedAsset))
+/// of [`RenderAssets`](RenderAsset) as long as they exist.
+pub type RenderAssets<A> = HashMap<Handle<A>, <A as RenderAsset>::PreparedAsset>;
+
+/// This system extracts all crated or modified assets of the corresponding [`RenderAsset`] type
+/// into the "render world".
+fn extract_render_asset<A: RenderAsset>(
+    mut commands: Commands,
+    mut events: EventReader<AssetEvent<A>>,
+    assets: Res<Assets<A>>,
+) {
+    let mut changed_assets = HashSet::default();
+    let mut removed = Vec::new();
+    for event in events.iter() {
+        match event {
+            AssetEvent::Created { handle } => {
+                changed_assets.insert(handle);
+            }
+            AssetEvent::Modified { handle } => {
+                changed_assets.insert(handle);
+            }
+            AssetEvent::Removed { handle } => {
+                if !changed_assets.remove(handle) {
+                    removed.push(handle.clone_weak());
+                }
+            }
+        }
+    }
+
+    let mut extracted_assets = Vec::new();
+    for handle in changed_assets.drain() {
+        if let Some(asset) = assets.get(handle) {
+            extracted_assets.push((handle.clone_weak(), asset.extract_asset()));
+        }
+    }
+
+    commands.insert_resource(ExtractedAssets {
+        extracted: extracted_assets,
+        removed,
+    })
+}
+
+/// Specifies all ECS data required by [`PrepareAssetSystem`].
+pub type RenderAssetParams<R> = (
+    SResMut<ExtractedAssets<R>>,
+    SResMut<RenderAssets<R>>,
+    SResMut<PrepareNextFrameAssets<R>>,
+    <R as RenderAsset>::Param,
+);
+
+// TODO: consider storing inside system?
+/// All assets that should be prepared next frame.
+pub struct PrepareNextFrameAssets<A: RenderAsset> {
+    assets: Vec<(Handle<A>, A::ExtractedAsset)>,
+}
+
+impl<A: RenderAsset> Default for PrepareNextFrameAssets<A> {
+    fn default() -> Self {
+        Self {
+            assets: Default::default(),
+        }
+    }
+}
+
+/// This system prepares all assets of the corresponding [`RenderAsset`] type
+/// which where extracted this frame for the GPU.
+pub struct PrepareAssetSystem<R: RenderAsset>(PhantomData<R>);
+
+impl<R: RenderAsset> RunSystem for PrepareAssetSystem<R> {
+    type Param = RenderAssetParams<R>;
+
+    fn run(
+        (mut extracted_assets, mut render_assets, mut prepare_next_frame, mut param): SystemParamItem<Self::Param>,
+    ) {
+        let mut queued_assets = std::mem::take(&mut prepare_next_frame.assets);
+        for (handle, extracted_asset) in queued_assets.drain(..) {
+            match R::prepare_asset(extracted_asset, &mut param) {
+                Ok(prepared_asset) => {
+                    render_assets.insert(handle, prepared_asset);
+                }
+                Err(PrepareAssetError::RetryNextUpdate(extracted_asset)) => {
+                    prepare_next_frame.assets.push((handle, extracted_asset));
+                }
+            }
+        }
+
+        for removed in std::mem::take(&mut extracted_assets.removed) {
+            render_assets.remove(&removed);
+        }
+
+        for (handle, extracted_asset) in std::mem::take(&mut extracted_assets.extracted) {
+            match R::prepare_asset(extracted_asset, &mut param) {
+                Ok(prepared_asset) => {
+                    render_assets.insert(handle, prepared_asset);
+                }
+                Err(PrepareAssetError::RetryNextUpdate(extracted_asset)) => {
+                    prepare_next_frame.assets.push((handle, extracted_asset));
+                }
+            }
+        }
+    }
+}
diff --git a/pipelined/bevy_render2/src/render_component.rs b/pipelined/bevy_render2/src/render_component.rs
new file mode 100644
index 0000000000..25d4e3f4b7
--- /dev/null
+++ b/pipelined/bevy_render2/src/render_component.rs
@@ -0,0 +1,187 @@
+use crate::{
+    render_resource::DynamicUniformVec,
+    renderer::{RenderDevice, RenderQueue},
+    RenderApp, RenderStage,
+};
+use bevy_app::{App, Plugin};
+use bevy_asset::{Asset, Handle};
+use bevy_ecs::{
+    component::Component,
+    prelude::*,
+    query::{FilterFetch, QueryItem, ReadOnlyFetch, WorldQuery},
+    system::{
+        lifetimeless::{Read, SCommands, SQuery},
+        RunSystem, SystemParamItem,
+    },
+};
+use crevice::std140::AsStd140;
+use std::{marker::PhantomData, ops::Deref};
+
+/// Stores the index of a uniform inside of [`ComponentUniforms`].
+#[derive(Component)]
+pub struct DynamicUniformIndex<C: Component> {
+    index: u32,
+    marker: PhantomData<C>,
+}
+
+impl<C: Component> DynamicUniformIndex<C> {
+    #[inline]
+    pub fn index(&self) -> u32 {
+        self.index
+    }
+}
+
+/// Describes how a component gets extracted for rendering.
+///
+/// Therefore the component is transferred from the "app world" into the "render world"
+/// in the [`RenderStage::Extract`](crate::RenderStage::Extract) step.
+pub trait ExtractComponent: Component {
+    /// ECS [`WorldQuery`] to fetch the components to extract.
+    type Query: WorldQuery;
+    /// Filters the entities with additional constraints.
+    type Filter: WorldQuery;
+    /// Defines how the component is transferred into the "render world".
+    fn extract_component(item: QueryItem<Self::Query>) -> Self;
+}
+
+/// This plugin prepares the components of the corresponding type for the GPU
+/// by transforming them into uniforms.
+///
+/// They can then be accessed from the [`ComponentUniforms`] resource.
+/// For referencing the newly created uniforms a [`DynamicUniformIndex`] is inserted
+/// for every processed entity.
+///
+/// Therefore it sets up the [`RenderStage::Prepare`](crate::RenderStage::Prepare) step
+/// for the specified [`ExtractComponent`].
+pub struct UniformComponentPlugin<C>(PhantomData<fn() -> C>);
+
+impl<C> Default for UniformComponentPlugin<C> {
+    fn default() -> Self {
+        Self(PhantomData)
+    }
+}
+
+impl<C: Component + AsStd140 + Clone> Plugin for UniformComponentPlugin<C> {
+    fn build(&self, app: &mut App) {
+        app.sub_app(RenderApp)
+            .insert_resource(ComponentUniforms::<C>::default())
+            .add_system_to_stage(
+                RenderStage::Prepare,
+                prepare_uniform_components::<C>.system(),
+            );
+    }
+}
+
+/// Stores all uniforms of the component type.
+pub struct ComponentUniforms<C: Component + AsStd140> {
+    uniforms: DynamicUniformVec<C>,
+}
+
+impl<C: Component + AsStd140> Deref for ComponentUniforms<C> {
+    type Target = DynamicUniformVec<C>;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        &self.uniforms
+    }
+}
+
+impl<C: Component + AsStd140> ComponentUniforms<C> {
+    #[inline]
+    pub fn uniforms(&self) -> &DynamicUniformVec<C> {
+        &self.uniforms
+    }
+}
+
+impl<C: Component + AsStd140> Default for ComponentUniforms<C> {
+    fn default() -> Self {
+        Self {
+            uniforms: Default::default(),
+        }
+    }
+}
+
+/// This system prepares all components of the corresponding component type.
+/// They are transformed into uniforms and stored in the [`ComponentUniforms`] resource.
+fn prepare_uniform_components<C: Component>(
+    mut commands: Commands,
+    render_device: Res<RenderDevice>,
+    render_queue: Res<RenderQueue>,
+    mut component_uniforms: ResMut<ComponentUniforms<C>>,
+    components: Query<(Entity, &C)>,
+) where
+    C: AsStd140 + Clone,
+{
+    component_uniforms.uniforms.clear();
+    for (entity, component) in components.iter() {
+        commands
+            .get_or_spawn(entity)
+            .insert(DynamicUniformIndex::<C> {
+                index: component_uniforms.uniforms.push(component.clone()),
+                marker: PhantomData,
+            });
+    }
+
+    component_uniforms
+        .uniforms
+        .write_buffer(&render_device, &render_queue);
+}
+
+/// This plugin extracts the components into the "render world".
+///
+/// Therefore it sets up the [`RenderStage::Extract`](crate::RenderStage::Extract) step
+/// for the specified [`ExtractComponent`].
+pub struct ExtractComponentPlugin<C, F = ()>(PhantomData<fn() -> (C, F)>);
+
+impl<C, F> Default for ExtractComponentPlugin<C, F> {
+    fn default() -> Self {
+        Self(PhantomData)
+    }
+}
+
+impl<C: ExtractComponent> Plugin for ExtractComponentPlugin<C>
+where
+    <C::Query as WorldQuery>::Fetch: ReadOnlyFetch,
+    <C::Filter as WorldQuery>::Fetch: FilterFetch,
+{
+    fn build(&self, app: &mut App) {
+        let system = ExtractComponentSystem::<C>::system(&mut app.world);
+        let render_app = app.sub_app(RenderApp);
+        render_app.add_system_to_stage(RenderStage::Extract, system);
+    }
+}
+
+impl<T: Asset> ExtractComponent for Handle<T> {
+    type Query = Read<Handle<T>>;
+    type Filter = ();
+
+    #[inline]
+    fn extract_component(handle: QueryItem<Self::Query>) -> Self {
+        handle.clone_weak()
+    }
+}
+
+/// This system extracts all components of the corresponding [`ExtractComponent`] type.
+pub struct ExtractComponentSystem<C: ExtractComponent>(PhantomData<C>);
+
+impl<C: ExtractComponent> RunSystem for ExtractComponentSystem<C>
+where
+    <C::Filter as WorldQuery>::Fetch: FilterFetch,
+    <C::Query as WorldQuery>::Fetch: ReadOnlyFetch,
+{
+    type Param = (
+        SCommands,
+        // the previous amount of extracted components
+        Local<'static, usize>,
+        SQuery<(Entity, C::Query), C::Filter>,
+    );
+
+    fn run((mut commands, mut previous_len, query): SystemParamItem<Self::Param>) {
+        let mut values = Vec::with_capacity(*previous_len);
+        for (entity, query_item) in query.iter() {
+            values.push((entity, (C::extract_component(query_item),)));
+        }
+        *previous_len = values.len();
+        commands.insert_or_spawn_batch(values);
+    }
+}
diff --git a/pipelined/bevy_render2/src/render_graph/context.rs b/pipelined/bevy_render2/src/render_graph/context.rs
new file mode 100644
index 0000000000..ec300ac25e
--- /dev/null
+++ b/pipelined/bevy_render2/src/render_graph/context.rs
@@ -0,0 +1,252 @@
+use crate::{
+    render_graph::{NodeState, RenderGraph, SlotInfos, SlotLabel, SlotType, SlotValue},
+    render_resource::{Buffer, Sampler, TextureView},
+};
+use bevy_ecs::entity::Entity;
+use std::borrow::Cow;
+use thiserror::Error;
+
+/// A command that signals the graph runner to run the sub graph corresponding to the `name`
+/// with the specified `inputs` next.
+pub struct RunSubGraph {
+    pub name: Cow<'static, str>,
+    pub inputs: Vec<SlotValue>,
+}
+
+/// The context with all graph information required to run a [`Node`](super::Node).
+/// This context is created for each node by the `RenderGraphRunner`.
+///
+/// The slot input can be read from here and the outputs must be written back to the context for
+/// passing them onto the next node.
+///
+/// Sub graphs can be queued for running by adding a [`RunSubGraph`] command to the context.
+/// After the node has finished running the graph runner is responsible for executing the sub graphs.
+pub struct RenderGraphContext<'a> {
+    graph: &'a RenderGraph,
+    node: &'a NodeState,
+    inputs: &'a [SlotValue],
+    outputs: &'a mut [Option<SlotValue>],
+    run_sub_graphs: Vec<RunSubGraph>,
+}
+
+impl<'a> RenderGraphContext<'a> {
+    /// Creates a new render graph context for the `node`.
+    pub fn new(
+        graph: &'a RenderGraph,
+        node: &'a NodeState,
+        inputs: &'a [SlotValue],
+        outputs: &'a mut [Option<SlotValue>],
+    ) -> Self {
+        Self {
+            graph,
+            node,
+            inputs,
+            outputs,
+            run_sub_graphs: Vec::new(),
+        }
+    }
+
+    /// Returns the input slot values for the node.
+    #[inline]
+    pub fn inputs(&self) -> &[SlotValue] {
+        self.inputs
+    }
+
+    /// Returns the [`SlotInfos`] of the inputs.
+    pub fn input_info(&self) -> &SlotInfos {
+        &self.node.input_slots
+    }
+
+    /// Returns the [`SlotInfos`] of the outputs.
+    pub fn output_info(&self) -> &SlotInfos {
+        &self.node.output_slots
+    }
+
+    /// Retrieves the input slot value referenced by the `label`.
+    pub fn get_input(&self, label: impl Into<SlotLabel>) -> Result<&SlotValue, InputSlotError> {
+        let label = label.into();
+        let index = self
+            .input_info()
+            .get_slot_index(label.clone())
+            .ok_or(InputSlotError::InvalidSlot(label))?;
+        Ok(&self.inputs[index])
+    }
+
+    // TODO: should this return an Arc or a reference?
+    /// Retrieves the input slot value referenced by the `label` as a [`TextureView`].
+    pub fn get_input_texture(
+        &self,
+        label: impl Into<SlotLabel>,
+    ) -> Result<&TextureView, InputSlotError> {
+        let label = label.into();
+        match self.get_input(label.clone())? {
+            SlotValue::TextureView(value) => Ok(value),
+            value => Err(InputSlotError::MismatchedSlotType {
+                label,
+                actual: value.slot_type(),
+                expected: SlotType::TextureView,
+            }),
+        }
+    }
+
+    /// Retrieves the input slot value referenced by the `label` as a [`Sampler`].
+    pub fn get_input_sampler(
+        &self,
+        label: impl Into<SlotLabel>,
+    ) -> Result<&Sampler, InputSlotError> {
+        let label = label.into();
+        match self.get_input(label.clone())? {
+            SlotValue::Sampler(value) => Ok(value),
+            value => Err(InputSlotError::MismatchedSlotType {
+                label,
+                actual: value.slot_type(),
+                expected: SlotType::Sampler,
+            }),
+        }
+    }
+
+    /// Retrieves the input slot value referenced by the `label` as a [`Buffer`].
+    pub fn get_input_buffer(&self, label: impl Into<SlotLabel>) -> Result<&Buffer, InputSlotError> {
+        let label = label.into();
+        match self.get_input(label.clone())? {
+            SlotValue::Buffer(value) => Ok(value),
+            value => Err(InputSlotError::MismatchedSlotType {
+                label,
+                actual: value.slot_type(),
+                expected: SlotType::Buffer,
+            }),
+        }
+    }
+
+    /// Retrieves the input slot value referenced by the `label` as an [`Entity`].
+    pub fn get_input_entity(&self, label: impl Into<SlotLabel>) -> Result<Entity, InputSlotError> {
+        let label = label.into();
+        match self.get_input(label.clone())? {
+            SlotValue::Entity(value) => Ok(*value),
+            value => Err(InputSlotError::MismatchedSlotType {
+                label,
+                actual: value.slot_type(),
+                expected: SlotType::Entity,
+            }),
+        }
+    }
+
+    /// Sets the output slot value referenced by the `label`.
+    pub fn set_output(
+        &mut self,
+        label: impl Into<SlotLabel>,
+        value: impl Into<SlotValue>,
+    ) -> Result<(), OutputSlotError> {
+        let label = label.into();
+        let value = value.into();
+        let slot_index = self
+            .output_info()
+            .get_slot_index(label.clone())
+            .ok_or_else(|| OutputSlotError::InvalidSlot(label.clone()))?;
+        let slot = self
+            .output_info()
+            .get_slot(slot_index)
+            .expect("slot is valid");
+        if value.slot_type() != slot.slot_type {
+            return Err(OutputSlotError::MismatchedSlotType {
+                label,
+                actual: slot.slot_type,
+                expected: value.slot_type(),
+            });
+        }
+        self.outputs[slot_index] = Some(value);
+        Ok(())
+    }
+
+    /// Queues up a sub graph for execution after the node has finished running.
+    pub fn run_sub_graph(
+        &mut self,
+        name: impl Into<Cow<'static, str>>,
+        inputs: Vec<SlotValue>,
+    ) -> Result<(), RunSubGraphError> {
+        let name = name.into();
+        let sub_graph = self
+            .graph
+            .get_sub_graph(&name)
+            .ok_or_else(|| RunSubGraphError::MissingSubGraph(name.clone()))?;
+        if let Some(input_node) = sub_graph.input_node() {
+            for (i, input_slot) in input_node.input_slots.iter().enumerate() {
+                if let Some(input_value) = inputs.get(i) {
+                    if input_slot.slot_type != input_value.slot_type() {
+                        return Err(RunSubGraphError::MismatchedInputSlotType {
+                            graph_name: name,
+                            slot_index: i,
+                            actual: input_value.slot_type(),
+                            expected: input_slot.slot_type,
+                            label: input_slot.name.clone().into(),
+                        });
+                    }
+                } else {
+                    return Err(RunSubGraphError::MissingInput {
+                        slot_index: i,
+                        slot_name: input_slot.name.clone(),
+                        graph_name: name,
+                    });
+                }
+            }
+        } else if !inputs.is_empty() {
+            return Err(RunSubGraphError::SubGraphHasNoInputs(name));
+        }
+
+        self.run_sub_graphs.push(RunSubGraph { name, inputs });
+
+        Ok(())
+    }
+
+    /// Finishes the context for this [`Node`](super::Node) by
+    /// returning the sub graphs to run next.
+    pub fn finish(self) -> Vec<RunSubGraph> {
+        self.run_sub_graphs
+    }
+}
+
+#[derive(Error, Debug, Eq, PartialEq)]
+pub enum RunSubGraphError {
+    #[error("tried to run a non-existent sub-graph")]
+    MissingSubGraph(Cow<'static, str>),
+    #[error("passed in inputs, but this sub-graph doesn't have any")]
+    SubGraphHasNoInputs(Cow<'static, str>),
+    #[error("sub graph (name: '{graph_name:?}') could not be run because slot '{slot_name}' at index {slot_index} has no value")]
+    MissingInput {
+        slot_index: usize,
+        slot_name: Cow<'static, str>,
+        graph_name: Cow<'static, str>,
+    },
+    #[error("attempted to use the wrong type for input slot")]
+    MismatchedInputSlotType {
+        graph_name: Cow<'static, str>,
+        slot_index: usize,
+        label: SlotLabel,
+        expected: SlotType,
+        actual: SlotType,
+    },
+}
+
+#[derive(Error, Debug, Eq, PartialEq)]
+pub enum OutputSlotError {
+    #[error("slot does not exist")]
+    InvalidSlot(SlotLabel),
+    #[error("attempted to assign the wrong type to slot")]
+    MismatchedSlotType {
+        label: SlotLabel,
+        expected: SlotType,
+        actual: SlotType,
+    },
+}
+
+#[derive(Error, Debug, Eq, PartialEq)]
+pub enum InputSlotError {
+    #[error("slot does not exist")]
+    InvalidSlot(SlotLabel),
+    #[error("attempted to retrieve the wrong type from input slot")]
+    MismatchedSlotType {
+        label: SlotLabel,
+        expected: SlotType,
+        actual: SlotType,
+    },
+}
diff --git a/pipelined/bevy_render2/src/render_graph/edge.rs b/pipelined/bevy_render2/src/render_graph/edge.rs
new file mode 100644
index 0000000000..fce406f53d
--- /dev/null
+++ b/pipelined/bevy_render2/src/render_graph/edge.rs
@@ -0,0 +1,50 @@
+use super::NodeId;
+
+/// An edge, which connects two [`Nodes`](super::Node) in
+/// a [`RenderGraph`](crate::render_graph::RenderGraph).
+///
+/// They are used to describe the ordering (which node has to run first)
+/// and may be of two kinds: [`NodeEdge`](Self::NodeEdge) and [`SlotEdge`](Self::SlotEdge).
+///
+/// Edges are added via the render_graph::add_node_edge(output_node, input_node) and the
+/// render_graph::add_slot_edge(output_node, output_slot, input_node, input_slot) methode.
+///
+/// The former simply states that the `output_node` has to be run before the `input_node`,
+/// while the later connects an output slot of the `output_node`
+/// with an input slot of the `input_node` to pass additional data along.
+/// For more information see [`SlotType`](super::SlotType).
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum Edge {
+    /// An edge describing to ordering of both nodes (`output_node` before `input_node`)
+    /// and connecting the output slot at the `output_index` of the output_node
+    /// with the slot at the `input_index` of the `input_node`.
+    SlotEdge {
+        input_node: NodeId,
+        input_index: usize,
+        output_node: NodeId,
+        output_index: usize,
+    },
+    /// An edge describing to ordering of both nodes (`output_node` before `input_node`).
+    NodeEdge {
+        input_node: NodeId,
+        output_node: NodeId,
+    },
+}
+
+impl Edge {
+    /// Returns the id of the 'input_node'.
+    pub fn get_input_node(&self) -> NodeId {
+        match self {
+            Edge::SlotEdge { input_node, .. } => *input_node,
+            Edge::NodeEdge { input_node, .. } => *input_node,
+        }
+    }
+
+    /// Returns the id of the 'output_node'.
+    pub fn get_output_node(&self) -> NodeId {
+        match self {
+            Edge::SlotEdge { output_node, .. } => *output_node,
+            Edge::NodeEdge { output_node, .. } => *output_node,
+        }
+    }
+}
diff --git a/pipelined/bevy_render2/src/render_graph/graph.rs b/pipelined/bevy_render2/src/render_graph/graph.rs
new file mode 100644
index 0000000000..53e8bacb26
--- /dev/null
+++ b/pipelined/bevy_render2/src/render_graph/graph.rs
@@ -0,0 +1,602 @@
+use crate::{
+    render_graph::{
+        Edge, Node, NodeId, NodeLabel, NodeRunError, NodeState, RenderGraphContext,
+        RenderGraphError, SlotInfo, SlotLabel,
+    },
+    renderer::RenderContext,
+};
+use bevy_ecs::prelude::World;
+use bevy_utils::HashMap;
+use std::{borrow::Cow, fmt::Debug};
+
+/// The render graph configures the modular, parallel and re-usable render logic.
+/// It is a retained and stateless (nodes itself my have their internal state) structure,
+/// which can not be modified while it is executed by the graph runner.
+///
+/// The `RenderGraphRunner` is responsible for executing the entire graph each frame.
+///
+/// It consists of three main components: [`Nodes`](Node), [`Edges`](Edge)
+/// and [`Slots`](super::SlotType).
+///
+/// Nodes are responsible for generating draw calls and operating on input and output slots.
+/// Edges specify the order of execution for nodes and connect input and output slots together.
+/// Slots describe the render resources created or used by the nodes.
+///
+/// Additionally a render graph can contain multiple sub graphs, which are run by the
+/// corresponding nodes. Every render graph can have it’s own optional input node.
+///
+/// ## Example
+/// Here is a simple render graph example with two nodes connected by a node edge.
+/// ```
+/// # use bevy_app::prelude::*;
+/// # use bevy_ecs::prelude::World;
+/// # use bevy_render2::render_graph::{RenderGraph, Node, RenderGraphContext, NodeRunError};
+/// # use bevy_render2::renderer::RenderContext;
+/// #
+/// # struct MyNode;
+/// #
+/// # impl Node for MyNode {
+/// #     fn run(&self, graph: &mut RenderGraphContext, render_context: &mut RenderContext, world: &World) -> Result<(), NodeRunError> {
+/// #         unimplemented!()
+/// #     }
+/// # }
+/// #
+/// let mut graph = RenderGraph::default();
+/// graph.add_node("input_node", MyNode);
+/// graph.add_node("output_node", MyNode);
+/// graph.add_node_edge("output_node", "input_node").unwrap();
+/// ```
+#[derive(Default)]
+pub struct RenderGraph {
+    nodes: HashMap<NodeId, NodeState>,
+    node_names: HashMap<Cow<'static, str>, NodeId>,
+    sub_graphs: HashMap<Cow<'static, str>, RenderGraph>,
+    input_node: Option<NodeId>,
+}
+
+impl RenderGraph {
+    /// The name of the [`GraphInputNode`] of this graph. Used to connect other nodes to it.
+    pub const INPUT_NODE_NAME: &'static str = "GraphInputNode";
+
+    /// Updates all nodes and sub graphs of the render graph. Should be called before executing it.
+    pub fn update(&mut self, world: &mut World) {
+        for node in self.nodes.values_mut() {
+            node.node.update(world);
+        }
+
+        for sub_graph in self.sub_graphs.values_mut() {
+            sub_graph.update(world);
+        }
+    }
+
+    /// Creates an [`GraphInputNode`] with the specified slots if not already present.
+    pub fn set_input(&mut self, inputs: Vec<SlotInfo>) -> NodeId {
+        if self.input_node.is_some() {
+            panic!("Graph already has an input node");
+        }
+
+        let id = self.add_node("GraphInputNode", GraphInputNode { inputs });
+        self.input_node = Some(id);
+        id
+    }
+
+    /// Returns the [`NodeState`] of the input node of this graph..
+    #[inline]
+    pub fn input_node(&self) -> Option<&NodeState> {
+        self.input_node.and_then(|id| self.get_node_state(id).ok())
+    }
+
+    /// Adds the `node` with the `name` to the graph.
+    /// If the name is already present replaces it instead.
+    pub fn add_node<T>(&mut self, name: impl Into<Cow<'static, str>>, node: T) -> NodeId
+    where
+        T: Node,
+    {
+        let id = NodeId::new();
+        let name = name.into();
+        let mut node_state = NodeState::new(id, node);
+        node_state.name = Some(name.clone());
+        self.nodes.insert(id, node_state);
+        self.node_names.insert(name, id);
+        id
+    }
+
+    /// Retrieves the [`NodeState`] referenced by the `label`.
+    pub fn get_node_state(
+        &self,
+        label: impl Into<NodeLabel>,
+    ) -> Result<&NodeState, RenderGraphError> {
+        let label = label.into();
+        let node_id = self.get_node_id(&label)?;
+        self.nodes
+            .get(&node_id)
+            .ok_or(RenderGraphError::InvalidNode(label))
+    }
+
+    /// Retrieves the [`NodeState`] referenced by the `label` mutably.
+    pub fn get_node_state_mut(
+        &mut self,
+        label: impl Into<NodeLabel>,
+    ) -> Result<&mut NodeState, RenderGraphError> {
+        let label = label.into();
+        let node_id = self.get_node_id(&label)?;
+        self.nodes
+            .get_mut(&node_id)
+            .ok_or(RenderGraphError::InvalidNode(label))
+    }
+
+    /// Retrieves the [`NodeId`] referenced by the `label`.
+    pub fn get_node_id(&self, label: impl Into<NodeLabel>) -> Result<NodeId, RenderGraphError> {
+        let label = label.into();
+        match label {
+            NodeLabel::Id(id) => Ok(id),
+            NodeLabel::Name(ref name) => self
+                .node_names
+                .get(name)
+                .cloned()
+                .ok_or(RenderGraphError::InvalidNode(label)),
+        }
+    }
+
+    /// Retrieves the [`Node`] referenced by the `label`.
+    pub fn get_node<T>(&self, label: impl Into<NodeLabel>) -> Result<&T, RenderGraphError>
+    where
+        T: Node,
+    {
+        self.get_node_state(label).and_then(|n| n.node())
+    }
+
+    /// Retrieves the [`Node`] referenced by the `label` mutably.
+    pub fn get_node_mut<T>(
+        &mut self,
+        label: impl Into<NodeLabel>,
+    ) -> Result<&mut T, RenderGraphError>
+    where
+        T: Node,
+    {
+        self.get_node_state_mut(label).and_then(|n| n.node_mut())
+    }
+
+    /// Adds the [`Edge::SlotEdge`] to the graph. This guarantees that the `output_node`
+    /// is run before the `input_node` and also connects the `output_slot` to the `input_slot`.
+    pub fn add_slot_edge(
+        &mut self,
+        output_node: impl Into<NodeLabel>,
+        output_slot: impl Into<SlotLabel>,
+        input_node: impl Into<NodeLabel>,
+        input_slot: impl Into<SlotLabel>,
+    ) -> Result<(), RenderGraphError> {
+        let output_slot = output_slot.into();
+        let input_slot = input_slot.into();
+        let output_node_id = self.get_node_id(output_node)?;
+        let input_node_id = self.get_node_id(input_node)?;
+
+        let output_index = self
+            .get_node_state(output_node_id)?
+            .output_slots
+            .get_slot_index(output_slot.clone())
+            .ok_or(RenderGraphError::InvalidOutputNodeSlot(output_slot))?;
+        let input_index = self
+            .get_node_state(input_node_id)?
+            .input_slots
+            .get_slot_index(input_slot.clone())
+            .ok_or(RenderGraphError::InvalidInputNodeSlot(input_slot))?;
+
+        let edge = Edge::SlotEdge {
+            output_node: output_node_id,
+            output_index,
+            input_node: input_node_id,
+            input_index,
+        };
+
+        self.validate_edge(&edge)?;
+
+        {
+            let output_node = self.get_node_state_mut(output_node_id)?;
+            output_node.edges.add_output_edge(edge.clone())?;
+        }
+        let input_node = self.get_node_state_mut(input_node_id)?;
+        input_node.edges.add_input_edge(edge)?;
+
+        Ok(())
+    }
+
+    /// Adds the [`Edge::NodeEdge`] to the graph. This guarantees that the `output_node`
+    /// is run before the `input_node`.
+    pub fn add_node_edge(
+        &mut self,
+        output_node: impl Into<NodeLabel>,
+        input_node: impl Into<NodeLabel>,
+    ) -> Result<(), RenderGraphError> {
+        let output_node_id = self.get_node_id(output_node)?;
+        let input_node_id = self.get_node_id(input_node)?;
+
+        let edge = Edge::NodeEdge {
+            output_node: output_node_id,
+            input_node: input_node_id,
+        };
+
+        self.validate_edge(&edge)?;
+
+        {
+            let output_node = self.get_node_state_mut(output_node_id)?;
+            output_node.edges.add_output_edge(edge.clone())?;
+        }
+        let input_node = self.get_node_state_mut(input_node_id)?;
+        input_node.edges.add_input_edge(edge)?;
+
+        Ok(())
+    }
+
+    /// Verifies that the edge is not already existing and
+    /// checks that slot edges are connected correctly.
+    pub fn validate_edge(&mut self, edge: &Edge) -> Result<(), RenderGraphError> {
+        if self.has_edge(edge) {
+            return Err(RenderGraphError::EdgeAlreadyExists(edge.clone()));
+        }
+
+        match *edge {
+            Edge::SlotEdge {
+                output_node,
+                output_index,
+                input_node,
+                input_index,
+            } => {
+                let output_node_state = self.get_node_state(output_node)?;
+                let input_node_state = self.get_node_state(input_node)?;
+
+                let output_slot = output_node_state
+                    .output_slots
+                    .get_slot(output_index)
+                    .ok_or(RenderGraphError::InvalidOutputNodeSlot(SlotLabel::Index(
+                        output_index,
+                    )))?;
+                let input_slot = input_node_state.input_slots.get_slot(input_index).ok_or(
+                    RenderGraphError::InvalidInputNodeSlot(SlotLabel::Index(input_index)),
+                )?;
+
+                if let Some(Edge::SlotEdge {
+                    output_node: current_output_node,
+                    ..
+                }) = input_node_state.edges.input_edges.iter().find(|e| {
+                    if let Edge::SlotEdge {
+                        input_index: current_input_index,
+                        ..
+                    } = e
+                    {
+                        input_index == *current_input_index
+                    } else {
+                        false
+                    }
+                }) {
+                    return Err(RenderGraphError::NodeInputSlotAlreadyOccupied {
+                        node: input_node,
+                        input_slot: input_index,
+                        occupied_by_node: *current_output_node,
+                    });
+                }
+
+                if output_slot.slot_type != input_slot.slot_type {
+                    return Err(RenderGraphError::MismatchedNodeSlots {
+                        output_node,
+                        output_slot: output_index,
+                        input_node,
+                        input_slot: input_index,
+                    });
+                }
+            }
+            Edge::NodeEdge { .. } => { /* nothing to validate here */ }
+        }
+
+        Ok(())
+    }
+
+    /// Checks whether the `edge` already exists in the graph.
+    pub fn has_edge(&self, edge: &Edge) -> bool {
+        let output_node_state = self.get_node_state(edge.get_output_node());
+        let input_node_state = self.get_node_state(edge.get_input_node());
+        if let Ok(output_node_state) = output_node_state {
+            if output_node_state.edges.output_edges.contains(edge) {
+                if let Ok(input_node_state) = input_node_state {
+                    if input_node_state.edges.input_edges.contains(edge) {
+                        return true;
+                    }
+                }
+            }
+        }
+
+        false
+    }
+
+    /// Returns an iterator over the [`NodeStates`](NodeState).
+    pub fn iter_nodes(&self) -> impl Iterator<Item = &NodeState> {
+        self.nodes.values()
+    }
+
+    /// Returns an iterator over the [`NodeStates`](NodeState), that allows modifying each value.
+    pub fn iter_nodes_mut(&mut self) -> impl Iterator<Item = &mut NodeState> {
+        self.nodes.values_mut()
+    }
+
+    /// Returns an iterator over the sub graphs.
+    pub fn iter_sub_graphs(&self) -> impl Iterator<Item = (&str, &RenderGraph)> {
+        self.sub_graphs
+            .iter()
+            .map(|(name, graph)| (name.as_ref(), graph))
+    }
+
+    /// Returns an iterator over the sub graphs, that allows modifying each value.
+    pub fn iter_sub_graphs_mut(&mut self) -> impl Iterator<Item = (&str, &mut RenderGraph)> {
+        self.sub_graphs
+            .iter_mut()
+            .map(|(name, graph)| (name.as_ref(), graph))
+    }
+
+    /// Returns an iterator over a tuple of the input edges and the corresponding output nodes
+    /// for the node referenced by the label.
+    pub fn iter_node_inputs(
+        &self,
+        label: impl Into<NodeLabel>,
+    ) -> Result<impl Iterator<Item = (&Edge, &NodeState)>, RenderGraphError> {
+        let node = self.get_node_state(label)?;
+        Ok(node
+            .edges
+            .input_edges
+            .iter()
+            .map(|edge| (edge, edge.get_output_node()))
+            .map(move |(edge, output_node_id)| {
+                (edge, self.get_node_state(output_node_id).unwrap())
+            }))
+    }
+
+    /// Returns an iterator over a tuple of the ouput edges and the corresponding input nodes
+    /// for the node referenced by the label.
+    pub fn iter_node_outputs(
+        &self,
+        label: impl Into<NodeLabel>,
+    ) -> Result<impl Iterator<Item = (&Edge, &NodeState)>, RenderGraphError> {
+        let node = self.get_node_state(label)?;
+        Ok(node
+            .edges
+            .output_edges
+            .iter()
+            .map(|edge| (edge, edge.get_input_node()))
+            .map(move |(edge, input_node_id)| (edge, self.get_node_state(input_node_id).unwrap())))
+    }
+
+    /// Adds the `sub_graph` with the `name` to the graph.
+    /// If the name is already present replaces it instead.
+    pub fn add_sub_graph(&mut self, name: impl Into<Cow<'static, str>>, sub_graph: RenderGraph) {
+        self.sub_graphs.insert(name.into(), sub_graph);
+    }
+
+    /// Retrieves the sub graph corresponding to the `name`.
+    pub fn get_sub_graph(&self, name: impl AsRef<str>) -> Option<&RenderGraph> {
+        self.sub_graphs.get(name.as_ref())
+    }
+
+    /// Retrieves the sub graph corresponding to the `name` mutably.
+    pub fn get_sub_graph_mut(&mut self, name: impl AsRef<str>) -> Option<&mut RenderGraph> {
+        self.sub_graphs.get_mut(name.as_ref())
+    }
+}
+
+impl Debug for RenderGraph {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        for node in self.iter_nodes() {
+            writeln!(f, "{:?}", node.id)?;
+            writeln!(f, "  in: {:?}", node.input_slots)?;
+            writeln!(f, "  out: {:?}", node.output_slots)?;
+        }
+
+        Ok(())
+    }
+}
+
+/// A [`Node`] which acts as an entry point for a [`RenderGraph`] with custom inputs.
+/// It has the same input and output slots and simply copies them over when run.
+pub struct GraphInputNode {
+    inputs: Vec<SlotInfo>,
+}
+
+impl Node for GraphInputNode {
+    fn input(&self) -> Vec<SlotInfo> {
+        self.inputs.clone()
+    }
+
+    fn output(&self) -> Vec<SlotInfo> {
+        self.inputs.clone()
+    }
+
+    fn run(
+        &self,
+        graph: &mut RenderGraphContext,
+        _render_context: &mut RenderContext,
+        _world: &World,
+    ) -> Result<(), NodeRunError> {
+        for i in 0..graph.inputs().len() {
+            let input = graph.inputs()[i].clone();
+            graph.set_output(i, input)?;
+        }
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{
+        render_graph::{
+            Edge, Node, NodeId, NodeRunError, RenderGraph, RenderGraphContext, RenderGraphError,
+            SlotInfo, SlotType,
+        },
+        renderer::RenderContext,
+    };
+    use bevy_ecs::world::World;
+    use bevy_utils::HashSet;
+
+    #[derive(Debug)]
+    struct TestNode {
+        inputs: Vec<SlotInfo>,
+        outputs: Vec<SlotInfo>,
+    }
+
+    impl TestNode {
+        pub fn new(inputs: usize, outputs: usize) -> Self {
+            TestNode {
+                inputs: (0..inputs)
+                    .map(|i| SlotInfo::new(format!("in_{}", i), SlotType::TextureView))
+                    .collect(),
+                outputs: (0..outputs)
+                    .map(|i| SlotInfo::new(format!("out_{}", i), SlotType::TextureView))
+                    .collect(),
+            }
+        }
+    }
+
+    impl Node for TestNode {
+        fn input(&self) -> Vec<SlotInfo> {
+            self.inputs.clone()
+        }
+
+        fn output(&self) -> Vec<SlotInfo> {
+            self.outputs.clone()
+        }
+
+        fn run(
+            &self,
+            _: &mut RenderGraphContext,
+            _: &mut RenderContext,
+            _: &World,
+        ) -> Result<(), NodeRunError> {
+            Ok(())
+        }
+    }
+
+    #[test]
+    fn test_graph_edges() {
+        let mut graph = RenderGraph::default();
+        let a_id = graph.add_node("A", TestNode::new(0, 1));
+        let b_id = graph.add_node("B", TestNode::new(0, 1));
+        let c_id = graph.add_node("C", TestNode::new(1, 1));
+        let d_id = graph.add_node("D", TestNode::new(1, 0));
+
+        graph.add_slot_edge("A", "out_0", "C", "in_0").unwrap();
+        graph.add_node_edge("B", "C").unwrap();
+        graph.add_slot_edge("C", 0, "D", 0).unwrap();
+
+        fn input_nodes(name: &'static str, graph: &RenderGraph) -> HashSet<NodeId> {
+            graph
+                .iter_node_inputs(name)
+                .unwrap()
+                .map(|(_edge, node)| node.id)
+                .collect::<HashSet<NodeId>>()
+        }
+
+        fn output_nodes(name: &'static str, graph: &RenderGraph) -> HashSet<NodeId> {
+            graph
+                .iter_node_outputs(name)
+                .unwrap()
+                .map(|(_edge, node)| node.id)
+                .collect::<HashSet<NodeId>>()
+        }
+
+        assert!(input_nodes("A", &graph).is_empty(), "A has no inputs");
+        assert!(
+            output_nodes("A", &graph) == HashSet::from_iter(vec![c_id]),
+            "A outputs to C"
+        );
+
+        assert!(input_nodes("B", &graph).is_empty(), "B has no inputs");
+        assert!(
+            output_nodes("B", &graph) == HashSet::from_iter(vec![c_id]),
+            "B outputs to C"
+        );
+
+        assert!(
+            input_nodes("C", &graph) == HashSet::from_iter(vec![a_id, b_id]),
+            "A and B input to C"
+        );
+        assert!(
+            output_nodes("C", &graph) == HashSet::from_iter(vec![d_id]),
+            "C outputs to D"
+        );
+
+        assert!(
+            input_nodes("D", &graph) == HashSet::from_iter(vec![c_id]),
+            "C inputs to D"
+        );
+        assert!(output_nodes("D", &graph).is_empty(), "D has no outputs");
+    }
+
+    #[test]
+    fn test_get_node_typed() {
+        struct MyNode {
+            value: usize,
+        }
+
+        impl Node for MyNode {
+            fn run(
+                &self,
+                _: &mut RenderGraphContext,
+                _: &mut RenderContext,
+                _: &World,
+            ) -> Result<(), NodeRunError> {
+                Ok(())
+            }
+        }
+
+        let mut graph = RenderGraph::default();
+
+        graph.add_node("A", MyNode { value: 42 });
+
+        let node: &MyNode = graph.get_node("A").unwrap();
+        assert_eq!(node.value, 42, "node value matches");
+
+        let result: Result<&TestNode, RenderGraphError> = graph.get_node("A");
+        assert_eq!(
+            result.unwrap_err(),
+            RenderGraphError::WrongNodeType,
+            "expect a wrong node type error"
+        );
+    }
+
+    #[test]
+    fn test_slot_already_occupied() {
+        let mut graph = RenderGraph::default();
+
+        graph.add_node("A", TestNode::new(0, 1));
+        graph.add_node("B", TestNode::new(0, 1));
+        graph.add_node("C", TestNode::new(1, 1));
+
+        graph.add_slot_edge("A", 0, "C", 0).unwrap();
+        assert_eq!(
+            graph.add_slot_edge("B", 0, "C", 0),
+            Err(RenderGraphError::NodeInputSlotAlreadyOccupied {
+                node: graph.get_node_id("C").unwrap(),
+                input_slot: 0,
+                occupied_by_node: graph.get_node_id("A").unwrap(),
+            }),
+            "Adding to a slot that is already occupied should return an error"
+        );
+    }
+
+    #[test]
+    fn test_edge_already_exists() {
+        let mut graph = RenderGraph::default();
+
+        graph.add_node("A", TestNode::new(0, 1));
+        graph.add_node("B", TestNode::new(1, 0));
+
+        graph.add_slot_edge("A", 0, "B", 0).unwrap();
+        assert_eq!(
+            graph.add_slot_edge("A", 0, "B", 0),
+            Err(RenderGraphError::EdgeAlreadyExists(Edge::SlotEdge {
+                output_node: graph.get_node_id("A").unwrap(),
+                output_index: 0,
+                input_node: graph.get_node_id("B").unwrap(),
+                input_index: 0,
+            })),
+            "Adding to a duplicate edge should return an error"
+        );
+    }
+}
diff --git a/pipelined/bevy_render2/src/render_graph/mod.rs b/pipelined/bevy_render2/src/render_graph/mod.rs
new file mode 100644
index 0000000000..0d204a5162
--- /dev/null
+++ b/pipelined/bevy_render2/src/render_graph/mod.rs
@@ -0,0 +1,44 @@
+mod context;
+mod edge;
+mod graph;
+mod node;
+mod node_slot;
+
+pub use context::*;
+pub use edge::*;
+pub use graph::*;
+pub use node::*;
+pub use node_slot::*;
+
+use thiserror::Error;
+
+#[derive(Error, Debug, Eq, PartialEq)]
+pub enum RenderGraphError {
+    #[error("node does not exist")]
+    InvalidNode(NodeLabel),
+    #[error("output node slot does not exist")]
+    InvalidOutputNodeSlot(SlotLabel),
+    #[error("input node slot does not exist")]
+    InvalidInputNodeSlot(SlotLabel),
+    #[error("node does not match the given type")]
+    WrongNodeType,
+    #[error("attempted to connect a node output slot to an incompatible input node slot")]
+    MismatchedNodeSlots {
+        output_node: NodeId,
+        output_slot: usize,
+        input_node: NodeId,
+        input_slot: usize,
+    },
+    #[error("attempted to add an edge that already exists")]
+    EdgeAlreadyExists(Edge),
+    #[error("node has an unconnected input slot")]
+    UnconnectedNodeInputSlot { node: NodeId, input_slot: usize },
+    #[error("node has an unconnected output slot")]
+    UnconnectedNodeOutputSlot { node: NodeId, output_slot: usize },
+    #[error("node input slot already occupied")]
+    NodeInputSlotAlreadyOccupied {
+        node: NodeId,
+        input_slot: usize,
+        occupied_by_node: NodeId,
+    },
+}
diff --git a/pipelined/bevy_render2/src/render_graph/node.rs b/pipelined/bevy_render2/src/render_graph/node.rs
new file mode 100644
index 0000000000..0562cef87b
--- /dev/null
+++ b/pipelined/bevy_render2/src/render_graph/node.rs
@@ -0,0 +1,285 @@
+use crate::{
+    render_graph::{
+        Edge, InputSlotError, OutputSlotError, RenderGraphContext, RenderGraphError,
+        RunSubGraphError, SlotInfo, SlotInfos,
+    },
+    renderer::RenderContext,
+};
+use bevy_ecs::world::World;
+use bevy_utils::Uuid;
+use downcast_rs::{impl_downcast, Downcast};
+use std::{borrow::Cow, fmt::Debug};
+use thiserror::Error;
+
+/// A [`Node`] identifier.
+/// It automatically generates its own random uuid.
+///
+/// This id is used to reference the node internally (edges, etc).
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct NodeId(Uuid);
+
+impl NodeId {
+    #[allow(clippy::new_without_default)]
+    pub fn new() -> Self {
+        NodeId(Uuid::new_v4())
+    }
+
+    pub fn uuid(&self) -> &Uuid {
+        &self.0
+    }
+}
+
+/// A render node that can be added to a [`RenderGraph`](super::RenderGraph).
+///
+/// Nodes are the fundamental part of the graph and used to extend its functionality, by
+/// generating draw calls and/or running subgraphs.
+/// They are added via the render_graph::add_node(my_node) methode.
+///
+/// To determine their position in the graph and ensure that all required dependencies (inputs)
+/// are already executed, [`Edges`](Edge) are used.
+///
+/// A node can produce outputs used as dependencies by other nodes.
+/// Those inputs and outputs are called slots and are the default way of passing render data
+/// inside the graph. For more information see [`SlotType`](super::SlotType).
+pub trait Node: Downcast + Send + Sync + 'static {
+    /// Specifies the required input slots for this node.
+    /// They will then be available during the run method inside the [`RenderContext`].
+    fn input(&self) -> Vec<SlotInfo> {
+        Vec::new()
+    }
+
+    /// Specifies the produced output slots for this node.
+    /// They can then be passed one inside [`RenderContext`] during the run method.
+    fn output(&self) -> Vec<SlotInfo> {
+        Vec::new()
+    }
+
+    /// Updates internal node state using the current render [`World`] prior to the run method.
+    fn update(&mut self, _world: &mut World) {}
+
+    /// Runs the graph node logic, issues draw calls, updates the output slots and
+    /// optionally queues up subgraphs for execution. The graph data, input and output values are
+    /// passed via the [`RenderGraphContext`].
+    fn run(
+        &self,
+        graph: &mut RenderGraphContext,
+        render_context: &mut RenderContext,
+        world: &World,
+    ) -> Result<(), NodeRunError>;
+}
+
+impl_downcast!(Node);
+
+#[derive(Error, Debug, Eq, PartialEq)]
+pub enum NodeRunError {
+    #[error("encountered an input slot error")]
+    InputSlotError(#[from] InputSlotError),
+    #[error("encountered an output slot error")]
+    OutputSlotError(#[from] OutputSlotError),
+    #[error("encountered an error when running a sub-graph")]
+    RunSubGraphError(#[from] RunSubGraphError),
+}
+
+/// A collection of input and output [`Edges`](Edge) for a [`Node`].
+#[derive(Debug)]
+pub struct Edges {
+    pub id: NodeId,
+    pub input_edges: Vec<Edge>,
+    pub output_edges: Vec<Edge>,
+}
+
+impl Edges {
+    /// Adds an edge to the `input_edges` if it does not already exist.
+    pub(crate) fn add_input_edge(&mut self, edge: Edge) -> Result<(), RenderGraphError> {
+        if self.has_input_edge(&edge) {
+            return Err(RenderGraphError::EdgeAlreadyExists(edge));
+        }
+        self.input_edges.push(edge);
+        Ok(())
+    }
+
+    /// Adds an edge to the `output_edges` if it does not already exist.
+    pub(crate) fn add_output_edge(&mut self, edge: Edge) -> Result<(), RenderGraphError> {
+        if self.has_output_edge(&edge) {
+            return Err(RenderGraphError::EdgeAlreadyExists(edge));
+        }
+        self.output_edges.push(edge);
+        Ok(())
+    }
+
+    /// Checks whether the input edge already exists.
+    pub fn has_input_edge(&self, edge: &Edge) -> bool {
+        self.input_edges.contains(edge)
+    }
+
+    /// Checks whether the output edge already exists.
+    pub fn has_output_edge(&self, edge: &Edge) -> bool {
+        self.output_edges.contains(edge)
+    }
+
+    /// Searches the `input_edges` for a [`Edge::SlotEdge`],
+    /// which `input_index` matches the `index`;
+    pub fn get_input_slot_edge(&self, index: usize) -> Result<&Edge, RenderGraphError> {
+        self.input_edges
+            .iter()
+            .find(|e| {
+                if let Edge::SlotEdge { input_index, .. } = e {
+                    *input_index == index
+                } else {
+                    false
+                }
+            })
+            .ok_or(RenderGraphError::UnconnectedNodeInputSlot {
+                input_slot: index,
+                node: self.id,
+            })
+    }
+
+    /// Searches the `output_edges` for a [`Edge::SlotEdge`],
+    /// which `output_index` matches the `index`;
+    pub fn get_output_slot_edge(&self, index: usize) -> Result<&Edge, RenderGraphError> {
+        self.output_edges
+            .iter()
+            .find(|e| {
+                if let Edge::SlotEdge { output_index, .. } = e {
+                    *output_index == index
+                } else {
+                    false
+                }
+            })
+            .ok_or(RenderGraphError::UnconnectedNodeOutputSlot {
+                output_slot: index,
+                node: self.id,
+            })
+    }
+}
+
+/// The internal representation of a [`Node`], with all data required
+/// by the [`RenderGraph`](super::RenderGraph).
+///
+/// The `input_slots` and `output_slots` are provided by the `node`.
+pub struct NodeState {
+    pub id: NodeId,
+    pub name: Option<Cow<'static, str>>,
+    /// The name of the type that implements [`Node`].
+    pub type_name: &'static str,
+    pub node: Box<dyn Node>,
+    pub input_slots: SlotInfos,
+    pub output_slots: SlotInfos,
+    pub edges: Edges,
+}
+
+impl Debug for NodeState {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        writeln!(f, "{:?} ({:?})", self.id, self.name)
+    }
+}
+
+impl NodeState {
+    /// Creates an [`NodeState`] without edges, but the `input_slots` and `output_slots`
+    /// are provided by the `node`.
+    pub fn new<T>(id: NodeId, node: T) -> Self
+    where
+        T: Node,
+    {
+        NodeState {
+            id,
+            name: None,
+            input_slots: node.input().into(),
+            output_slots: node.output().into(),
+            node: Box::new(node),
+            type_name: std::any::type_name::<T>(),
+            edges: Edges {
+                id,
+                input_edges: Vec::new(),
+                output_edges: Vec::new(),
+            },
+        }
+    }
+
+    /// Retrieves the [`Node`].
+    pub fn node<T>(&self) -> Result<&T, RenderGraphError>
+    where
+        T: Node,
+    {
+        self.node
+            .downcast_ref::<T>()
+            .ok_or(RenderGraphError::WrongNodeType)
+    }
+
+    /// Retrieves the [`Node`] mutably.
+    pub fn node_mut<T>(&mut self) -> Result<&mut T, RenderGraphError>
+    where
+        T: Node,
+    {
+        self.node
+            .downcast_mut::<T>()
+            .ok_or(RenderGraphError::WrongNodeType)
+    }
+
+    /// Validates that each input slot corresponds to an input edge.
+    pub fn validate_input_slots(&self) -> Result<(), RenderGraphError> {
+        for i in 0..self.input_slots.len() {
+            self.edges.get_input_slot_edge(i)?;
+        }
+
+        Ok(())
+    }
+
+    /// Validates that each output slot corresponds to an output edge.
+    pub fn validate_output_slots(&self) -> Result<(), RenderGraphError> {
+        for i in 0..self.output_slots.len() {
+            self.edges.get_output_slot_edge(i)?;
+        }
+
+        Ok(())
+    }
+}
+
+/// A [`NodeLabel`] is used to reference a [`NodeState`] by either its name or [`NodeId`]
+/// inside the [`RenderGraph`](super::RenderGraph).
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub enum NodeLabel {
+    Id(NodeId),
+    Name(Cow<'static, str>),
+}
+
+impl From<&NodeLabel> for NodeLabel {
+    fn from(value: &NodeLabel) -> Self {
+        value.clone()
+    }
+}
+
+impl From<String> for NodeLabel {
+    fn from(value: String) -> Self {
+        NodeLabel::Name(value.into())
+    }
+}
+
+impl From<&'static str> for NodeLabel {
+    fn from(value: &'static str) -> Self {
+        NodeLabel::Name(value.into())
+    }
+}
+
+impl From<NodeId> for NodeLabel {
+    fn from(value: NodeId) -> Self {
+        NodeLabel::Id(value)
+    }
+}
+
+/// A [`Node`] without any inputs, outputs and subgraphs, which does nothing when run.
+/// Used (as a label) to bundle multiple dependencies into one inside
+/// the [`RenderGraph`](super::RenderGraph).
+pub struct EmptyNode;
+
+impl Node for EmptyNode {
+    fn run(
+        &self,
+        _graph: &mut RenderGraphContext,
+        _render_context: &mut RenderContext,
+        _world: &World,
+    ) -> Result<(), NodeRunError> {
+        Ok(())
+    }
+}
diff --git a/pipelined/bevy_render2/src/render_graph/node_slot.rs b/pipelined/bevy_render2/src/render_graph/node_slot.rs
new file mode 100644
index 0000000000..0789d62df0
--- /dev/null
+++ b/pipelined/bevy_render2/src/render_graph/node_slot.rs
@@ -0,0 +1,191 @@
+use bevy_ecs::entity::Entity;
+use std::borrow::Cow;
+
+use crate::render_resource::{Buffer, Sampler, TextureView};
+
+/// A value passed between render [`Nodes`](super::Node).
+/// Corresponds to the [SlotType] specified in the [`RenderGraph`](super::RenderGraph).
+///
+/// Slots can have four different types of values:
+/// [`Buffer`], [`TextureView`], [`Sampler`] and [`Entity`].
+///
+/// These values do not contain the actual render data, but only the ids to retrieve them.
+#[derive(Debug, Clone)]
+pub enum SlotValue {
+    /// A GPU-accessible [`Buffer`].
+    Buffer(Buffer),
+    /// A [`TextureView`] describes a texture used in a pipeline.
+    TextureView(TextureView),
+    /// A texture [`Sampler`] defines how a pipeline will sample from a [`TextureView`].
+    Sampler(Sampler),
+    /// An entity from the ECS.
+    Entity(Entity),
+}
+
+impl SlotValue {
+    /// Returns the [`SlotType`] of this value.
+    pub fn slot_type(&self) -> SlotType {
+        match self {
+            SlotValue::Buffer(_) => SlotType::Buffer,
+            SlotValue::TextureView(_) => SlotType::TextureView,
+            SlotValue::Sampler(_) => SlotType::Sampler,
+            SlotValue::Entity(_) => SlotType::Entity,
+        }
+    }
+}
+
+impl From<Buffer> for SlotValue {
+    fn from(value: Buffer) -> Self {
+        SlotValue::Buffer(value)
+    }
+}
+
+impl From<TextureView> for SlotValue {
+    fn from(value: TextureView) -> Self {
+        SlotValue::TextureView(value)
+    }
+}
+
+impl From<Sampler> for SlotValue {
+    fn from(value: Sampler) -> Self {
+        SlotValue::Sampler(value)
+    }
+}
+
+impl From<Entity> for SlotValue {
+    fn from(value: Entity) -> Self {
+        SlotValue::Entity(value)
+    }
+}
+
+/// Describes the render resources created (output) or used (input) by
+/// the render [`Nodes`](super::Node).
+///
+/// This should not be confused with [`SlotValue`], which actually contains the passed data.
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+pub enum SlotType {
+    /// A GPU-accessible [`Buffer`].
+    Buffer,
+    /// A [`TextureView`] describes a texture used in a pipeline.
+    TextureView,
+    /// A texture [`Sampler`] defines how a pipeline will sample from a [`TextureView`].
+    Sampler,
+    /// An entity from the ECS.
+    Entity,
+}
+
+/// A [`SlotLabel`] is used to reference a slot by either its name or index
+/// inside the [`RenderGraph`](super::RenderGraph).
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub enum SlotLabel {
+    Index(usize),
+    Name(Cow<'static, str>),
+}
+
+impl From<&SlotLabel> for SlotLabel {
+    fn from(value: &SlotLabel) -> Self {
+        value.clone()
+    }
+}
+
+impl From<String> for SlotLabel {
+    fn from(value: String) -> Self {
+        SlotLabel::Name(value.into())
+    }
+}
+
+impl From<&'static str> for SlotLabel {
+    fn from(value: &'static str) -> Self {
+        SlotLabel::Name(value.into())
+    }
+}
+
+impl From<Cow<'static, str>> for SlotLabel {
+    fn from(value: Cow<'static, str>) -> Self {
+        SlotLabel::Name(value.clone())
+    }
+}
+
+impl From<usize> for SlotLabel {
+    fn from(value: usize) -> Self {
+        SlotLabel::Index(value)
+    }
+}
+
+/// The internal representation of a slot, which specifies its [`SlotType`] and name.
+#[derive(Clone, Debug)]
+pub struct SlotInfo {
+    pub name: Cow<'static, str>,
+    pub slot_type: SlotType,
+}
+
+impl SlotInfo {
+    pub fn new(name: impl Into<Cow<'static, str>>, slot_type: SlotType) -> Self {
+        SlotInfo {
+            name: name.into(),
+            slot_type,
+        }
+    }
+}
+
+/// A collection of input or output [`SlotInfos`](SlotInfo) for
+/// a [`NodeState`](super::NodeState).
+#[derive(Default, Debug)]
+pub struct SlotInfos {
+    slots: Vec<SlotInfo>,
+}
+
+impl<T: IntoIterator<Item = SlotInfo>> From<T> for SlotInfos {
+    fn from(slots: T) -> Self {
+        SlotInfos {
+            slots: slots.into_iter().collect(),
+        }
+    }
+}
+
+impl SlotInfos {
+    /// Returns the count of slots.
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.slots.len()
+    }
+
+    /// Returns true if there are no slots.
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.slots.is_empty()
+    }
+
+    /// Retrieves the [`SlotInfo`] for the provided label.
+    pub fn get_slot(&self, label: impl Into<SlotLabel>) -> Option<&SlotInfo> {
+        let label = label.into();
+        let index = self.get_slot_index(&label)?;
+        self.slots.get(index)
+    }
+
+    /// Retrieves the [`SlotInfo`] for the provided label mutably.
+    pub fn get_slot_mut(&mut self, label: impl Into<SlotLabel>) -> Option<&mut SlotInfo> {
+        let label = label.into();
+        let index = self.get_slot_index(&label)?;
+        self.slots.get_mut(index)
+    }
+
+    /// Retrieves the index (inside input or output slots) of the slot for the provided label.
+    pub fn get_slot_index(&self, label: impl Into<SlotLabel>) -> Option<usize> {
+        let label = label.into();
+        match label {
+            SlotLabel::Index(index) => Some(index),
+            SlotLabel::Name(ref name) => self
+                .slots
+                .iter()
+                .enumerate()
+                .find(|(_i, s)| s.name == *name)
+                .map(|(i, _s)| i),
+        }
+    }
+
+    /// Returns an iterator over the slot infos.
+    pub fn iter(&self) -> impl Iterator<Item = &SlotInfo> {
+        self.slots.iter()
+    }
+}
diff --git a/pipelined/bevy_render2/src/render_phase/draw.rs b/pipelined/bevy_render2/src/render_phase/draw.rs
new file mode 100644
index 0000000000..2f26c540cd
--- /dev/null
+++ b/pipelined/bevy_render2/src/render_phase/draw.rs
@@ -0,0 +1,279 @@
+use crate::{
+    render_phase::TrackedRenderPass,
+    render_resource::{CachedPipelineId, RenderPipelineCache},
+};
+use bevy_app::App;
+use bevy_ecs::{
+    all_tuples,
+    entity::Entity,
+    system::{
+        lifetimeless::SRes, ReadOnlySystemParamFetch, SystemParam, SystemParamItem, SystemState,
+    },
+    world::World,
+};
+use bevy_utils::HashMap;
+use parking_lot::{RwLock, RwLockReadGuard, RwLockWriteGuard};
+use std::{any::TypeId, fmt::Debug, hash::Hash};
+
+/// A draw function which is used to draw a specific [`PhaseItem`].
+///
+/// They are the the general form of drawing items, whereas [`RenderCommands`](RenderCommand)
+/// are more modular.
+pub trait Draw<P: PhaseItem>: Send + Sync + 'static {
+    /// Draws the [`PhaseItem`] by issuing draw calls via the [`TrackedRenderPass`].
+    fn draw<'w>(
+        &mut self,
+        world: &'w World,
+        pass: &mut TrackedRenderPass<'w>,
+        view: Entity,
+        item: &P,
+    );
+}
+
+/// An item which will be drawn to the screen. A phase item should be queued up for rendering
+/// during the [`RenderStage::Queue`](crate::RenderStage::Queue) stage.
+/// Afterwards it will be sorted and rendered automatically  in the
+/// [`RenderStage::PhaseSort`](crate::RenderStage::PhaseSort) stage and
+/// [`RenderStage::Render`](crate::RenderStage::Render) stage, respectively.
+pub trait PhaseItem: Send + Sync + 'static {
+    /// The type used for ordering the items. The smallest values are drawn first.
+    type SortKey: Ord;
+    /// Determines the order in which the items are drawn during the corresponding [`RenderPhase`].
+    fn sort_key(&self) -> Self::SortKey;
+    /// Specifies the [`Draw`] function used to render the item.
+    fn draw_function(&self) -> DrawFunctionId;
+}
+
+// TODO: make this generic?
+/// /// A [`Draw`] function identifier.
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
+pub struct DrawFunctionId(usize);
+
+/// Stores all draw functions for the [`PhaseItem`] type.
+/// For retrieval they are associated with their [`TypeId`].
+pub struct DrawFunctionsInternal<P: PhaseItem> {
+    pub draw_functions: Vec<Box<dyn Draw<P>>>,
+    pub indices: HashMap<TypeId, DrawFunctionId>,
+}
+
+impl<P: PhaseItem> DrawFunctionsInternal<P> {
+    /// Adds the [`Draw`] function and associates it to its own type.
+    pub fn add<T: Draw<P>>(&mut self, draw_function: T) -> DrawFunctionId {
+        self.add_with::<T, T>(draw_function)
+    }
+
+    /// Adds the [`Draw`] function and associates it to the type `T`
+    pub fn add_with<T: 'static, D: Draw<P>>(&mut self, draw_function: D) -> DrawFunctionId {
+        self.draw_functions.push(Box::new(draw_function));
+        let id = DrawFunctionId(self.draw_functions.len() - 1);
+        self.indices.insert(TypeId::of::<T>(), id);
+        id
+    }
+
+    /// Retrieves the [`Draw`] function corresponding to the `id` mutably.
+    pub fn get_mut(&mut self, id: DrawFunctionId) -> Option<&mut dyn Draw<P>> {
+        self.draw_functions.get_mut(id.0).map(|f| &mut **f)
+    }
+
+    /// Retrieves the id of the [`Draw`] function corresponding to their associated type `T`.
+    pub fn get_id<T: 'static>(&self) -> Option<DrawFunctionId> {
+        self.indices.get(&TypeId::of::<T>()).copied()
+    }
+}
+
+/// Stores all draw functions for the [`PhaseItem`] type hidden behind a reader-writer lock.
+/// To access them the [`DrawFunctions::read`] and [`DrawFunctions::write`] methods are used.
+pub struct DrawFunctions<P: PhaseItem> {
+    internal: RwLock<DrawFunctionsInternal<P>>,
+}
+
+impl<P: PhaseItem> Default for DrawFunctions<P> {
+    fn default() -> Self {
+        Self {
+            internal: RwLock::new(DrawFunctionsInternal {
+                draw_functions: Vec::new(),
+                indices: HashMap::default(),
+            }),
+        }
+    }
+}
+
+impl<P: PhaseItem> DrawFunctions<P> {
+    /// Accesses the draw functions in read mode.
+    pub fn read(&self) -> RwLockReadGuard<'_, DrawFunctionsInternal<P>> {
+        self.internal.read()
+    }
+
+    /// Accesses the draw functions in write mode.
+    pub fn write(&self) -> RwLockWriteGuard<'_, DrawFunctionsInternal<P>> {
+        self.internal.write()
+    }
+}
+
+/// RenderCommand is a trait that runs an ECS query and produces one or more
+/// [`TrackedRenderPass`] calls. Types implementing this trait can be composed (as tuples).
+///
+/// They can be registered as a [`Draw`] function via the
+/// [`AddRenderCommand::add_render_command`] method.
+///
+/// # Example
+/// The `DrawPbr` draw function is created from the following render command
+/// tuple.  Const generics are used to set specific bind group locations:
+///
+/// ```ignore
+/// pub type DrawPbr = (
+///     SetItemPipeline,
+///     SetMeshViewBindGroup<0>,
+///     SetStandardMaterialBindGroup<1>,
+///     SetTransformBindGroup<2>,
+///     DrawMesh,
+/// );
+/// ```
+pub trait RenderCommand<P: PhaseItem> {
+    /// Specifies all ECS data required by [`RenderCommand::render`].
+    /// All parameters have to be read only.
+    type Param: SystemParam;
+
+    /// Renders the [`PhaseItem`] by issuing draw calls via the [`TrackedRenderPass`].
+    fn render<'w>(
+        view: Entity,
+        item: &P,
+        param: SystemParamItem<'w, '_, Self::Param>,
+        pass: &mut TrackedRenderPass<'w>,
+    ) -> RenderCommandResult;
+}
+
+pub enum RenderCommandResult {
+    Success,
+    Failure,
+}
+
+pub trait EntityRenderCommand {
+    type Param: SystemParam;
+    fn render<'w>(
+        view: Entity,
+        item: Entity,
+        param: SystemParamItem<'w, '_, Self::Param>,
+        pass: &mut TrackedRenderPass<'w>,
+    ) -> RenderCommandResult;
+}
+
+pub trait EntityPhaseItem: PhaseItem {
+    fn entity(&self) -> Entity;
+}
+
+pub trait CachedPipelinePhaseItem: PhaseItem {
+    fn cached_pipeline(&self) -> CachedPipelineId;
+}
+
+impl<P: EntityPhaseItem, E: EntityRenderCommand> RenderCommand<P> for E {
+    type Param = E::Param;
+
+    #[inline]
+    fn render<'w>(
+        view: Entity,
+        item: &P,
+        param: SystemParamItem<'w, '_, Self::Param>,
+        pass: &mut TrackedRenderPass<'w>,
+    ) -> RenderCommandResult {
+        <E as EntityRenderCommand>::render(view, item.entity(), param, pass)
+    }
+}
+
+pub struct SetItemPipeline;
+impl<P: CachedPipelinePhaseItem> RenderCommand<P> for SetItemPipeline {
+    type Param = SRes<RenderPipelineCache>;
+    #[inline]
+    fn render<'w>(
+        _view: Entity,
+        item: &P,
+        pipeline_cache: SystemParamItem<'w, '_, Self::Param>,
+        pass: &mut TrackedRenderPass<'w>,
+    ) -> RenderCommandResult {
+        if let Some(pipeline) = pipeline_cache.into_inner().get(item.cached_pipeline()) {
+            pass.set_render_pipeline(pipeline);
+            RenderCommandResult::Success
+        } else {
+            RenderCommandResult::Failure
+        }
+    }
+}
+
+macro_rules! render_command_tuple_impl {
+    ($($name: ident),*) => {
+        impl<P: PhaseItem, $($name: RenderCommand<P>),*> RenderCommand<P> for ($($name,)*) {
+            type Param = ($($name::Param,)*);
+
+            #[allow(non_snake_case)]
+            fn render<'w>(
+                _view: Entity,
+                _item: &P,
+                ($($name,)*): SystemParamItem<'w, '_, Self::Param>,
+                _pass: &mut TrackedRenderPass<'w>,
+            ) -> RenderCommandResult{
+                $(if let RenderCommandResult::Failure = $name::render(_view, _item, $name, _pass) {
+                    return RenderCommandResult::Failure;
+                })*
+                RenderCommandResult::Success
+            }
+        }
+    };
+}
+
+all_tuples!(render_command_tuple_impl, 0, 15, C);
+
+/// Wraps a [`RenderCommand`] into a state so that it can be used as a [`Draw`] function.
+/// Therefore the [`RenderCommand::Param`] is queried from the ECS and passed to the command.
+pub struct RenderCommandState<P: PhaseItem, C: RenderCommand<P>> {
+    state: SystemState<C::Param>,
+}
+
+impl<P: PhaseItem, C: RenderCommand<P>> RenderCommandState<P, C> {
+    pub fn new(world: &mut World) -> Self {
+        Self {
+            state: SystemState::new(world),
+        }
+    }
+}
+
+impl<P: PhaseItem, C: RenderCommand<P> + Send + Sync + 'static> Draw<P> for RenderCommandState<P, C>
+where
+    <C::Param as SystemParam>::Fetch: ReadOnlySystemParamFetch,
+{
+    /// Prepares the ECS parameters for the wrapped [`RenderCommand`] and then renders it.
+    fn draw<'w>(
+        &mut self,
+        world: &'w World,
+        pass: &mut TrackedRenderPass<'w>,
+        view: Entity,
+        item: &P,
+    ) {
+        let param = self.state.get(world);
+        C::render(view, item, param, pass);
+    }
+}
+
+/// Registers a [`RenderCommand`] as a [`Draw`] function.
+/// They are stored inside the [`DrawFunctions`] resource of the app.
+pub trait AddRenderCommand {
+    /// Adds the [`RenderCommand`] for the specified [`RenderPhase`](super::RenderPhase) to the app.
+    fn add_render_command<P: PhaseItem, C: RenderCommand<P> + Send + Sync + 'static>(
+        &mut self,
+    ) -> &mut Self
+    where
+        <C::Param as SystemParam>::Fetch: ReadOnlySystemParamFetch;
+}
+
+impl AddRenderCommand for App {
+    fn add_render_command<P: PhaseItem, C: RenderCommand<P> + Send + Sync + 'static>(
+        &mut self,
+    ) -> &mut Self
+    where
+        <C::Param as SystemParam>::Fetch: ReadOnlySystemParamFetch,
+    {
+        let draw_function = RenderCommandState::<P, C>::new(&mut self.world);
+        let draw_functions = self.world.get_resource::<DrawFunctions<P>>().unwrap();
+        draw_functions.write().add_with::<C, _>(draw_function);
+        self
+    }
+}
diff --git a/pipelined/bevy_render2/src/render_phase/draw_state.rs b/pipelined/bevy_render2/src/render_phase/draw_state.rs
new file mode 100644
index 0000000000..62c19706d1
--- /dev/null
+++ b/pipelined/bevy_render2/src/render_phase/draw_state.rs
@@ -0,0 +1,231 @@
+use crate::render_resource::{
+    BindGroup, BindGroupId, BufferId, BufferSlice, RenderPipeline, RenderPipelineId,
+};
+use bevy_utils::tracing::debug;
+use std::ops::Range;
+use wgpu::{IndexFormat, RenderPass};
+
+/// Tracks the current [`TrackedRenderPipeline`] state to ensure draw calls are valid.
+#[derive(Debug, Default)]
+pub struct DrawState {
+    pipeline: Option<RenderPipelineId>,
+    bind_groups: Vec<(Option<BindGroupId>, Vec<u32>)>,
+    vertex_buffers: Vec<Option<(BufferId, u64)>>,
+    index_buffer: Option<(BufferId, u64, IndexFormat)>,
+}
+
+impl DrawState {
+    pub fn set_bind_group(
+        &mut self,
+        index: usize,
+        bind_group: BindGroupId,
+        dynamic_indices: &[u32],
+    ) {
+        if index >= self.bind_groups.len() {
+            self.bind_groups.resize(index + 1, (None, Vec::new()));
+        }
+        self.bind_groups[index].0 = Some(bind_group);
+        self.bind_groups[index].1.clear();
+        self.bind_groups[index].1.extend(dynamic_indices);
+    }
+
+    pub fn is_bind_group_set(
+        &self,
+        index: usize,
+        bind_group: BindGroupId,
+        dynamic_indices: &[u32],
+    ) -> bool {
+        if let Some(current_bind_group) = self.bind_groups.get(index) {
+            current_bind_group.0 == Some(bind_group) && dynamic_indices == current_bind_group.1
+        } else {
+            false
+        }
+    }
+
+    pub fn set_vertex_buffer(&mut self, index: usize, buffer: BufferId, offset: u64) {
+        if index >= self.vertex_buffers.len() {
+            self.vertex_buffers.resize(index + 1, None);
+        }
+        self.vertex_buffers[index] = Some((buffer, offset));
+    }
+
+    pub fn is_vertex_buffer_set(&self, index: usize, buffer: BufferId, offset: u64) -> bool {
+        if let Some(current) = self.vertex_buffers.get(index) {
+            *current == Some((buffer, offset))
+        } else {
+            false
+        }
+    }
+
+    pub fn set_index_buffer(&mut self, buffer: BufferId, offset: u64, index_format: IndexFormat) {
+        self.index_buffer = Some((buffer, offset, index_format));
+    }
+
+    pub fn is_index_buffer_set(
+        &self,
+        buffer: BufferId,
+        offset: u64,
+        index_format: IndexFormat,
+    ) -> bool {
+        self.index_buffer == Some((buffer, offset, index_format))
+    }
+
+    pub fn is_pipeline_set(&self, pipeline: RenderPipelineId) -> bool {
+        self.pipeline == Some(pipeline)
+    }
+
+    pub fn set_pipeline(&mut self, pipeline: RenderPipelineId) {
+        // TODO: do these need to be cleared?
+        // self.bind_groups.clear();
+        // self.vertex_buffers.clear();
+        // self.index_buffer = None;
+        self.pipeline = Some(pipeline);
+    }
+}
+
+/// A [`RenderPass`], which tracks the current pipeline state to ensure all draw calls are valid.
+/// It is used to set the current [`RenderPipeline`], [`BindGroups`](BindGroup) and buffers.
+/// After all requirements are specified, draw calls can be issued.
+pub struct TrackedRenderPass<'a> {
+    pass: RenderPass<'a>,
+    state: DrawState,
+}
+
+impl<'a> TrackedRenderPass<'a> {
+    /// Tracks the supplied render pass.
+    pub fn new(pass: RenderPass<'a>) -> Self {
+        Self {
+            state: DrawState::default(),
+            pass,
+        }
+    }
+
+    /// Sets the active [`RenderPipeline`].
+    ///
+    /// Subsequent draw calls will exhibit the behavior defined by the `pipeline`.
+    pub fn set_render_pipeline(&mut self, pipeline: &'a RenderPipeline) {
+        debug!("set pipeline: {:?}", pipeline);
+        if self.state.is_pipeline_set(pipeline.id()) {
+            return;
+        }
+        self.pass.set_pipeline(pipeline);
+        self.state.set_pipeline(pipeline.id());
+    }
+
+    /// Sets the active [`BindGroup`] for a given bind group index. The bind group layout in the
+    /// active pipeline when any `draw()` function is called must match the layout
+    /// of this `bind group`.
+    pub fn set_bind_group(
+        &mut self,
+        index: usize,
+        bind_group: &'a BindGroup,
+        dynamic_uniform_indices: &[u32],
+    ) {
+        if self
+            .state
+            .is_bind_group_set(index as usize, bind_group.id(), dynamic_uniform_indices)
+        {
+            debug!(
+                "set bind_group {} (already set): {:?} ({:?})",
+                index, bind_group, dynamic_uniform_indices
+            );
+            return;
+        } else {
+            debug!(
+                "set bind_group {}: {:?} ({:?})",
+                index, bind_group, dynamic_uniform_indices
+            );
+        }
+        self.pass
+            .set_bind_group(index as u32, bind_group, dynamic_uniform_indices);
+        self.state
+            .set_bind_group(index as usize, bind_group.id(), dynamic_uniform_indices);
+    }
+
+    /// Assign a vertex buffer to a slot.
+    ///
+    /// Subsequent calls to [`TrackedRenderPass::draw`] and [`TrackedRenderPass::draw_indexed`]
+    /// will use the `buffer` as one of the source vertex buffers.
+    ///
+    /// The `slot` refers to the index of the matching descriptor in
+    /// [`VertexState::buffers`](crate::render_resource::VertexState::buffers).
+    pub fn set_vertex_buffer(&mut self, index: usize, buffer_slice: BufferSlice<'a>) {
+        let offset = buffer_slice.offset();
+        if self
+            .state
+            .is_vertex_buffer_set(index, buffer_slice.id(), offset)
+        {
+            debug!(
+                "set vertex buffer {} (already set): {:?} ({})",
+                index,
+                buffer_slice.id(),
+                offset
+            );
+            return;
+        } else {
+            debug!(
+                "set vertex buffer {}: {:?} ({})",
+                index,
+                buffer_slice.id(),
+                offset
+            );
+        }
+        self.pass.set_vertex_buffer(index as u32, *buffer_slice);
+        self.state
+            .set_vertex_buffer(index, buffer_slice.id(), offset);
+    }
+
+    /// Sets the active index buffer.
+    ///
+    /// Subsequent calls to [`TrackedRenderPass::draw_indexed`] will use the `buffer` as
+    /// the source index buffer.
+    pub fn set_index_buffer(
+        &mut self,
+        buffer_slice: BufferSlice<'a>,
+        offset: u64,
+        index_format: IndexFormat,
+    ) {
+        if self
+            .state
+            .is_index_buffer_set(buffer_slice.id(), offset, index_format)
+        {
+            debug!(
+                "set index buffer (already set): {:?} ({})",
+                buffer_slice.id(),
+                offset
+            );
+            return;
+        } else {
+            debug!("set index buffer: {:?} ({})", buffer_slice.id(), offset);
+        }
+        self.pass.set_index_buffer(*buffer_slice, index_format);
+        self.state
+            .set_index_buffer(buffer_slice.id(), offset, index_format);
+    }
+
+    /// Draws primitives from the active vertex buffer(s).
+    ///
+    /// The active vertex buffers can be set with [`TrackedRenderPass::set_vertex_buffer`].
+    pub fn draw(&mut self, vertices: Range<u32>, instances: Range<u32>) {
+        debug!("draw: {:?} {:?}", vertices, instances);
+        self.pass.draw(vertices, instances);
+    }
+
+    /// Draws indexed primitives using the active index buffer and the active vertex buffer(s).
+    ///
+    /// The active index buffer can be set with [`TrackedRenderPass::set_index_buffer`], while the
+    /// active vertex buffers can be set with [`TrackedRenderPass::set_vertex_buffer`].
+    pub fn draw_indexed(&mut self, indices: Range<u32>, base_vertex: i32, instances: Range<u32>) {
+        debug!(
+            "draw indexed: {:?} {} {:?}",
+            indices, base_vertex, instances
+        );
+        self.pass.draw_indexed(indices, base_vertex, instances);
+    }
+
+    pub fn set_stencil_reference(&mut self, reference: u32) {
+        debug!("set stencil reference: {}", reference);
+
+        self.pass.set_stencil_reference(reference);
+    }
+}
diff --git a/pipelined/bevy_render2/src/render_phase/mod.rs b/pipelined/bevy_render2/src/render_phase/mod.rs
new file mode 100644
index 0000000000..594b9bbfe0
--- /dev/null
+++ b/pipelined/bevy_render2/src/render_phase/mod.rs
@@ -0,0 +1,39 @@
+mod draw;
+mod draw_state;
+
+pub use draw::*;
+pub use draw_state::*;
+
+use bevy_ecs::prelude::{Component, Query};
+
+/// A resource to collect and sort draw requests for specific [`PhaseItems`](PhaseItem).
+#[derive(Component)]
+pub struct RenderPhase<I: PhaseItem> {
+    pub items: Vec<I>,
+}
+
+impl<I: PhaseItem> Default for RenderPhase<I> {
+    fn default() -> Self {
+        Self { items: Vec::new() }
+    }
+}
+
+impl<I: PhaseItem> RenderPhase<I> {
+    /// Adds a [`PhaseItem`] to this render phase.
+    #[inline]
+    pub fn add(&mut self, item: I) {
+        self.items.push(item);
+    }
+
+    /// Sorts all of its [`PhaseItems`](PhaseItem).
+    pub fn sort(&mut self) {
+        self.items.sort_by_key(|d| d.sort_key());
+    }
+}
+
+/// This system sorts all [`RenderPhases`](RenderPhase) for the [`PhaseItem`] type.
+pub fn sort_phase_system<I: PhaseItem>(mut render_phases: Query<&mut RenderPhase<I>>) {
+    for mut phase in render_phases.iter_mut() {
+        phase.sort();
+    }
+}
diff --git a/pipelined/bevy_render2/src/render_resource/bind_group.rs b/pipelined/bevy_render2/src/render_resource/bind_group.rs
new file mode 100644
index 0000000000..6ee9633c2b
--- /dev/null
+++ b/pipelined/bevy_render2/src/render_resource/bind_group.rs
@@ -0,0 +1,44 @@
+use bevy_reflect::Uuid;
+use std::{ops::Deref, sync::Arc};
+
+/// A [`BindGroup`] identifier.
+#[derive(Copy, Clone, Hash, Eq, PartialEq, Debug)]
+pub struct BindGroupId(Uuid);
+
+/// Bind groups are responsible for binding render resources (e.g. buffers, textures, samplers)
+/// to a [`TrackedRenderPass`](crate::render_phase::TrackedRenderPass).
+/// This makes them accessible in the pipeline (shaders) as uniforms.
+///
+/// May be converted from and dereferences to a wgpu [`BindGroup`](wgpu::BindGroup).
+/// Can be created via [`RenderDevice::create_bind_group`](crate::renderer::RenderDevice::create_bind_group).
+#[derive(Clone, Debug)]
+pub struct BindGroup {
+    id: BindGroupId,
+    value: Arc<wgpu::BindGroup>,
+}
+
+impl BindGroup {
+    /// Returns the [`BindGroupId`].
+    #[inline]
+    pub fn id(&self) -> BindGroupId {
+        self.id
+    }
+}
+
+impl From<wgpu::BindGroup> for BindGroup {
+    fn from(value: wgpu::BindGroup) -> Self {
+        BindGroup {
+            id: BindGroupId(Uuid::new_v4()),
+            value: Arc::new(value),
+        }
+    }
+}
+
+impl Deref for BindGroup {
+    type Target = wgpu::BindGroup;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        &self.value
+    }
+}
diff --git a/pipelined/bevy_render2/src/render_resource/bind_group_layout.rs b/pipelined/bevy_render2/src/render_resource/bind_group_layout.rs
new file mode 100644
index 0000000000..d17d639c3a
--- /dev/null
+++ b/pipelined/bevy_render2/src/render_resource/bind_group_layout.rs
@@ -0,0 +1,41 @@
+use bevy_reflect::Uuid;
+use std::{ops::Deref, sync::Arc};
+
+#[derive(Copy, Clone, Hash, Eq, PartialEq, Debug)]
+pub struct BindGroupLayoutId(Uuid);
+
+#[derive(Clone, Debug)]
+pub struct BindGroupLayout {
+    id: BindGroupLayoutId,
+    value: Arc<wgpu::BindGroupLayout>,
+}
+
+impl BindGroupLayout {
+    #[inline]
+    pub fn id(&self) -> BindGroupLayoutId {
+        self.id
+    }
+
+    #[inline]
+    pub fn value(&self) -> &wgpu::BindGroupLayout {
+        &self.value
+    }
+}
+
+impl From<wgpu::BindGroupLayout> for BindGroupLayout {
+    fn from(value: wgpu::BindGroupLayout) -> Self {
+        BindGroupLayout {
+            id: BindGroupLayoutId(Uuid::new_v4()),
+            value: Arc::new(value),
+        }
+    }
+}
+
+impl Deref for BindGroupLayout {
+    type Target = wgpu::BindGroupLayout;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        &self.value
+    }
+}
diff --git a/pipelined/bevy_render2/src/render_resource/buffer.rs b/pipelined/bevy_render2/src/render_resource/buffer.rs
new file mode 100644
index 0000000000..a902af5834
--- /dev/null
+++ b/pipelined/bevy_render2/src/render_resource/buffer.rs
@@ -0,0 +1,85 @@
+use bevy_utils::Uuid;
+use std::{
+    ops::{Bound, Deref, RangeBounds},
+    sync::Arc,
+};
+
+#[derive(Copy, Clone, Hash, Eq, PartialEq, Debug)]
+pub struct BufferId(Uuid);
+
+#[derive(Clone, Debug)]
+pub struct Buffer {
+    id: BufferId,
+    value: Arc<wgpu::Buffer>,
+}
+
+impl Buffer {
+    #[inline]
+    pub fn id(&self) -> BufferId {
+        self.id
+    }
+
+    pub fn slice(&self, bounds: impl RangeBounds<wgpu::BufferAddress>) -> BufferSlice {
+        BufferSlice {
+            id: self.id,
+            // need to compute and store this manually because wgpu doesn't export offset on wgpu::BufferSlice
+            offset: match bounds.start_bound() {
+                Bound::Included(&bound) => bound,
+                Bound::Excluded(&bound) => bound + 1,
+                Bound::Unbounded => 0,
+            },
+            value: self.value.slice(bounds),
+        }
+    }
+
+    #[inline]
+    pub fn unmap(&self) {
+        self.value.unmap()
+    }
+}
+
+impl From<wgpu::Buffer> for Buffer {
+    fn from(value: wgpu::Buffer) -> Self {
+        Buffer {
+            id: BufferId(Uuid::new_v4()),
+            value: Arc::new(value),
+        }
+    }
+}
+
+impl Deref for Buffer {
+    type Target = wgpu::Buffer;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        &self.value
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct BufferSlice<'a> {
+    id: BufferId,
+    offset: wgpu::BufferAddress,
+    value: wgpu::BufferSlice<'a>,
+}
+
+impl<'a> BufferSlice<'a> {
+    #[inline]
+    pub fn id(&self) -> BufferId {
+        self.id
+    }
+
+    #[inline]
+    pub fn offset(&self) -> wgpu::BufferAddress {
+        self.offset
+    }
+}
+
+impl<'a> Deref for BufferSlice<'a> {
+    type Target = wgpu::BufferSlice<'a>;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        &self.value
+    }
+}
diff --git a/pipelined/bevy_render2/src/render_resource/buffer_vec.rs b/pipelined/bevy_render2/src/render_resource/buffer_vec.rs
new file mode 100644
index 0000000000..ccdadb119c
--- /dev/null
+++ b/pipelined/bevy_render2/src/render_resource/buffer_vec.rs
@@ -0,0 +1,90 @@
+use crate::{
+    render_resource::Buffer,
+    renderer::{RenderDevice, RenderQueue},
+};
+use bevy_core::{cast_slice, Pod};
+use wgpu::BufferUsages;
+
+pub struct BufferVec<T: Pod> {
+    values: Vec<T>,
+    buffer: Option<Buffer>,
+    capacity: usize,
+    item_size: usize,
+    buffer_usage: BufferUsages,
+}
+
+impl<T: Pod> Default for BufferVec<T> {
+    fn default() -> Self {
+        Self {
+            values: Vec::new(),
+            buffer: None,
+            capacity: 0,
+            buffer_usage: BufferUsages::all(),
+            item_size: std::mem::size_of::<T>(),
+        }
+    }
+}
+
+impl<T: Pod> BufferVec<T> {
+    pub fn new(buffer_usage: BufferUsages) -> Self {
+        Self {
+            buffer_usage,
+            ..Default::default()
+        }
+    }
+
+    #[inline]
+    pub fn buffer(&self) -> Option<&Buffer> {
+        self.buffer.as_ref()
+    }
+
+    #[inline]
+    pub fn capacity(&self) -> usize {
+        self.capacity
+    }
+
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.values.len()
+    }
+
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.values.is_empty()
+    }
+
+    pub fn push(&mut self, value: T) -> usize {
+        let index = self.values.len();
+        self.values.push(value);
+        index
+    }
+
+    pub fn reserve(&mut self, capacity: usize, device: &RenderDevice) {
+        if capacity > self.capacity {
+            self.capacity = capacity;
+            let size = self.item_size * capacity;
+            self.buffer = Some(device.create_buffer(&wgpu::BufferDescriptor {
+                label: None,
+                size: size as wgpu::BufferAddress,
+                usage: BufferUsages::COPY_DST | self.buffer_usage,
+                mapped_at_creation: false,
+            }));
+        }
+    }
+
+    pub fn write_buffer(&mut self, device: &RenderDevice, queue: &RenderQueue) {
+        if self.values.is_empty() {
+            return;
+        }
+        self.reserve(self.values.len(), device);
+        if let Some(buffer) = &self.buffer {
+            let range = 0..self.item_size * self.values.len();
+            let bytes: &[u8] = cast_slice(&self.values);
+            queue.write_buffer(buffer, 0, &bytes[range]);
+        }
+    }
+
+    pub fn clear(&mut self) {
+        self.values.clear();
+    }
+}
diff --git a/pipelined/bevy_render2/src/render_resource/mod.rs b/pipelined/bevy_render2/src/render_resource/mod.rs
new file mode 100644
index 0000000000..144fe4917f
--- /dev/null
+++ b/pipelined/bevy_render2/src/render_resource/mod.rs
@@ -0,0 +1,41 @@
+mod bind_group;
+mod bind_group_layout;
+mod buffer;
+mod buffer_vec;
+mod pipeline;
+mod pipeline_cache;
+mod pipeline_specializer;
+mod shader;
+mod texture;
+mod uniform_vec;
+
+pub use bind_group::*;
+pub use bind_group_layout::*;
+pub use buffer::*;
+pub use buffer_vec::*;
+pub use pipeline::*;
+pub use pipeline_cache::*;
+pub use pipeline_specializer::*;
+pub use shader::*;
+pub use texture::*;
+pub use uniform_vec::*;
+
+// TODO: decide where re-exports should go
+pub use wgpu::{
+    util::BufferInitDescriptor, AddressMode, BindGroupDescriptor, BindGroupEntry,
+    BindGroupLayoutDescriptor, BindGroupLayoutEntry, BindingResource, BindingType, BlendComponent,
+    BlendFactor, BlendOperation, BlendState, BufferAddress, BufferBindingType, BufferSize,
+    BufferUsages, ColorTargetState, ColorWrites, CompareFunction, ComputePassDescriptor,
+    ComputePipelineDescriptor, DepthBiasState, DepthStencilState, Extent3d, Face, FilterMode,
+    FragmentState as RawFragmentState, FrontFace, ImageCopyBuffer, ImageCopyBufferBase,
+    ImageCopyTexture, ImageCopyTextureBase, ImageDataLayout, ImageSubresourceRange, IndexFormat,
+    LoadOp, MultisampleState, Operations, Origin3d, PipelineLayout, PipelineLayoutDescriptor,
+    PolygonMode, PrimitiveState, PrimitiveTopology, RenderPassColorAttachment,
+    RenderPassDepthStencilAttachment, RenderPassDescriptor,
+    RenderPipelineDescriptor as RawRenderPipelineDescriptor, SamplerDescriptor, ShaderModule,
+    ShaderModuleDescriptor, ShaderSource, ShaderStages, StencilFaceState, StencilOperation,
+    StencilState, StorageTextureAccess, TextureAspect, TextureDescriptor, TextureDimension,
+    TextureFormat, TextureSampleType, TextureUsages, TextureViewDescriptor, TextureViewDimension,
+    VertexAttribute, VertexBufferLayout as RawVertexBufferLayout, VertexFormat,
+    VertexState as RawVertexState, VertexStepMode,
+};
diff --git a/pipelined/bevy_render2/src/render_resource/pipeline.rs b/pipelined/bevy_render2/src/render_resource/pipeline.rs
new file mode 100644
index 0000000000..f462c98c53
--- /dev/null
+++ b/pipelined/bevy_render2/src/render_resource/pipeline.rs
@@ -0,0 +1,142 @@
+use crate::render_resource::{BindGroupLayout, Shader};
+use bevy_asset::Handle;
+use bevy_reflect::Uuid;
+use std::{borrow::Cow, ops::Deref, sync::Arc};
+use wgpu::{
+    BufferAddress, ColorTargetState, DepthStencilState, MultisampleState, PrimitiveState,
+    VertexAttribute, VertexStepMode,
+};
+
+/// A [`RenderPipeline`] identifier.
+#[derive(Copy, Clone, Hash, Eq, PartialEq, Debug)]
+pub struct RenderPipelineId(Uuid);
+
+/// A RenderPipeline represents a graphics pipeline and its stages (shaders), bindings and vertex buffers.
+///
+/// May be converted from and dereferences to a wgpu [`RenderPipeline`](wgpu::RenderPipeline).
+/// Can be created via [`RenderDevice::create_render_pipeline`](crate::renderer::RenderDevice::create_render_pipeline).
+#[derive(Clone, Debug)]
+pub struct RenderPipeline {
+    id: RenderPipelineId,
+    value: Arc<wgpu::RenderPipeline>,
+}
+
+impl RenderPipeline {
+    #[inline]
+    pub fn id(&self) -> RenderPipelineId {
+        self.id
+    }
+}
+
+impl From<wgpu::RenderPipeline> for RenderPipeline {
+    fn from(value: wgpu::RenderPipeline) -> Self {
+        RenderPipeline {
+            id: RenderPipelineId(Uuid::new_v4()),
+            value: Arc::new(value),
+        }
+    }
+}
+
+impl Deref for RenderPipeline {
+    type Target = wgpu::RenderPipeline;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        &self.value
+    }
+}
+
+/// A [`ComputePipeline`] identifier.
+#[derive(Copy, Clone, Hash, Eq, PartialEq, Debug)]
+pub struct ComputePipelineId(Uuid);
+
+/// A ComputePipeline represents a compute pipeline and its single shader stage.
+///
+/// May be converted from and dereferences to a wgpu [`ComputePipeline`](wgpu::ComputePipeline).
+/// Can be created via [`RenderDevice::create_compute_pipeline`](crate::renderer::RenderDevice::create_compute_pipeline).
+#[derive(Clone, Debug)]
+pub struct ComputePipeline {
+    id: ComputePipelineId,
+    value: Arc<wgpu::ComputePipeline>,
+}
+
+impl ComputePipeline {
+    /// Returns the [`ComputePipelineId`].
+    #[inline]
+    pub fn id(&self) -> ComputePipelineId {
+        self.id
+    }
+}
+
+impl From<wgpu::ComputePipeline> for ComputePipeline {
+    fn from(value: wgpu::ComputePipeline) -> Self {
+        ComputePipeline {
+            id: ComputePipelineId(Uuid::new_v4()),
+            value: Arc::new(value),
+        }
+    }
+}
+
+impl Deref for ComputePipeline {
+    type Target = wgpu::ComputePipeline;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        &self.value
+    }
+}
+
+/// Describes a render (graphics) pipeline.
+#[derive(Clone, Debug)]
+pub struct RenderPipelineDescriptor {
+    /// Debug label of the pipeline. This will show up in graphics debuggers for easy identification.
+    pub label: Option<Cow<'static, str>>,
+    /// The layout of bind groups for this pipeline.
+    pub layout: Option<Vec<BindGroupLayout>>,
+    /// The compiled vertex stage, its entry point, and the input buffers layout.
+    pub vertex: VertexState,
+    /// The properties of the pipeline at the primitive assembly and rasterization level.
+    pub primitive: PrimitiveState,
+    /// The effect of draw calls on the depth and stencil aspects of the output target, if any.
+    pub depth_stencil: Option<DepthStencilState>,
+    /// The multi-sampling properties of the pipeline.
+    pub multisample: MultisampleState,
+    /// The compiled fragment stage, its entry point, and the color targets.
+    pub fragment: Option<FragmentState>,
+}
+
+#[derive(Clone, Debug)]
+pub struct VertexState {
+    /// The compiled shader module for this stage.
+    pub shader: Handle<Shader>,
+    pub shader_defs: Vec<String>,
+    /// The name of the entry point in the compiled shader. There must be a function that returns
+    /// void with this name in the shader.
+    pub entry_point: Cow<'static, str>,
+    /// The format of any vertex buffers used with this pipeline.
+    pub buffers: Vec<VertexBufferLayout>,
+}
+
+/// Describes how the vertex buffer is interpreted.
+#[derive(Clone, Debug, Hash, Eq, PartialEq)]
+pub struct VertexBufferLayout {
+    /// The stride, in bytes, between elements of this buffer.
+    pub array_stride: BufferAddress,
+    /// How often this vertex buffer is "stepped" forward.
+    pub step_mode: VertexStepMode,
+    /// The list of attributes which comprise a single vertex.
+    pub attributes: Vec<VertexAttribute>,
+}
+
+/// Describes the fragment process in a render pipeline.
+#[derive(Clone, Debug)]
+pub struct FragmentState {
+    /// The compiled shader module for this stage.
+    pub shader: Handle<Shader>,
+    pub shader_defs: Vec<String>,
+    /// The name of the entry point in the compiled shader. There must be a function that returns
+    /// void with this name in the shader.
+    pub entry_point: Cow<'static, str>,
+    /// The color state of the render targets.
+    pub targets: Vec<ColorTargetState>,
+}
diff --git a/pipelined/bevy_render2/src/render_resource/pipeline_cache.rs b/pipelined/bevy_render2/src/render_resource/pipeline_cache.rs
new file mode 100644
index 0000000000..1dff4fe617
--- /dev/null
+++ b/pipelined/bevy_render2/src/render_resource/pipeline_cache.rs
@@ -0,0 +1,387 @@
+use crate::{
+    render_resource::{
+        AsModuleDescriptorError, BindGroupLayout, BindGroupLayoutId, ProcessShaderError,
+        RawFragmentState, RawRenderPipelineDescriptor, RawVertexState, RenderPipeline,
+        RenderPipelineDescriptor, Shader, ShaderImport, ShaderProcessor,
+    },
+    renderer::RenderDevice,
+    RenderWorld,
+};
+use bevy_app::EventReader;
+use bevy_asset::{AssetEvent, Assets, Handle};
+use bevy_ecs::system::{Res, ResMut};
+use bevy_utils::{HashMap, HashSet};
+use std::{collections::hash_map::Entry, hash::Hash, ops::Deref, sync::Arc};
+use thiserror::Error;
+use wgpu::{PipelineLayoutDescriptor, ShaderModule, VertexBufferLayout};
+
+#[derive(Default)]
+pub struct ShaderData {
+    pipelines: HashSet<CachedPipelineId>,
+    processed_shaders: HashMap<Vec<String>, Arc<ShaderModule>>,
+    resolved_imports: HashMap<ShaderImport, Handle<Shader>>,
+    dependents: HashSet<Handle<Shader>>,
+}
+
+#[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
+pub struct CachedPipelineId(usize);
+
+impl CachedPipelineId {
+    pub const INVALID: Self = CachedPipelineId(usize::MAX);
+}
+
+#[derive(Default)]
+struct ShaderCache {
+    data: HashMap<Handle<Shader>, ShaderData>,
+    shaders: HashMap<Handle<Shader>, Shader>,
+    import_path_shaders: HashMap<ShaderImport, Handle<Shader>>,
+    waiting_on_import: HashMap<ShaderImport, Vec<Handle<Shader>>>,
+    processor: ShaderProcessor,
+}
+
+impl ShaderCache {
+    fn get(
+        &mut self,
+        render_device: &RenderDevice,
+        pipeline: CachedPipelineId,
+        handle: &Handle<Shader>,
+        shader_defs: &[String],
+    ) -> Result<Arc<ShaderModule>, RenderPipelineError> {
+        let shader = self
+            .shaders
+            .get(handle)
+            .ok_or_else(|| RenderPipelineError::ShaderNotLoaded(handle.clone_weak()))?;
+        let data = self.data.entry(handle.clone_weak()).or_default();
+        if shader.imports().len() != data.resolved_imports.len() {
+            return Err(RenderPipelineError::ShaderImportNotYetAvailable);
+        }
+
+        data.pipelines.insert(pipeline);
+
+        // PERF: this shader_defs clone isn't great. use raw_entry_mut when it stabilizes
+        let module = match data.processed_shaders.entry(shader_defs.to_vec()) {
+            Entry::Occupied(entry) => entry.into_mut(),
+            Entry::Vacant(entry) => {
+                let processed = self.processor.process(
+                    shader,
+                    shader_defs,
+                    &self.shaders,
+                    &self.import_path_shaders,
+                )?;
+                let module_descriptor = processed.get_module_descriptor()?;
+                entry.insert(Arc::new(
+                    render_device.create_shader_module(&module_descriptor),
+                ))
+            }
+        };
+
+        Ok(module.clone())
+    }
+
+    fn clear(&mut self, handle: &Handle<Shader>) -> Vec<CachedPipelineId> {
+        let mut shaders_to_clear = vec![handle.clone_weak()];
+        let mut pipelines_to_queue = Vec::new();
+        while let Some(handle) = shaders_to_clear.pop() {
+            if let Some(data) = self.data.get_mut(&handle) {
+                data.processed_shaders.clear();
+                pipelines_to_queue.extend(data.pipelines.iter().cloned());
+                shaders_to_clear.extend(data.dependents.iter().map(|h| h.clone_weak()));
+            }
+        }
+
+        pipelines_to_queue
+    }
+
+    fn set_shader(&mut self, handle: &Handle<Shader>, shader: Shader) -> Vec<CachedPipelineId> {
+        let pipelines_to_queue = self.clear(handle);
+        if let Some(path) = shader.import_path() {
+            self.import_path_shaders
+                .insert(path.clone(), handle.clone_weak());
+            if let Some(waiting_shaders) = self.waiting_on_import.get_mut(path) {
+                for waiting_shader in waiting_shaders.drain(..) {
+                    // resolve waiting shader import
+                    let data = self.data.entry(waiting_shader.clone_weak()).or_default();
+                    data.resolved_imports
+                        .insert(path.clone(), handle.clone_weak());
+                    // add waiting shader as dependent of this shader
+                    let data = self.data.entry(handle.clone_weak()).or_default();
+                    data.dependents.insert(waiting_shader.clone_weak());
+                }
+            }
+        }
+
+        for import in shader.imports() {
+            if let Some(import_handle) = self.import_path_shaders.get(import) {
+                // resolve import because it is currently available
+                let data = self.data.entry(handle.clone_weak()).or_default();
+                data.resolved_imports
+                    .insert(import.clone(), import_handle.clone_weak());
+                // add this shader as a dependent of the import
+                let data = self.data.entry(import_handle.clone_weak()).or_default();
+                data.dependents.insert(handle.clone_weak());
+            } else {
+                let waiting = self.waiting_on_import.entry(import.clone()).or_default();
+                waiting.push(handle.clone_weak());
+            }
+        }
+
+        self.shaders.insert(handle.clone_weak(), shader);
+        pipelines_to_queue
+    }
+
+    fn remove(&mut self, handle: &Handle<Shader>) -> Vec<CachedPipelineId> {
+        let pipelines_to_queue = self.clear(handle);
+        if let Some(shader) = self.shaders.remove(handle) {
+            if let Some(import_path) = shader.import_path() {
+                self.import_path_shaders.remove(import_path);
+            }
+        }
+
+        pipelines_to_queue
+    }
+}
+
+#[derive(Default)]
+struct LayoutCache {
+    layouts: HashMap<Vec<BindGroupLayoutId>, wgpu::PipelineLayout>,
+}
+
+impl LayoutCache {
+    fn get(
+        &mut self,
+        render_device: &RenderDevice,
+        bind_group_layouts: &[BindGroupLayout],
+    ) -> &wgpu::PipelineLayout {
+        let key = bind_group_layouts.iter().map(|l| l.id()).collect();
+        self.layouts.entry(key).or_insert_with(|| {
+            let bind_group_layouts = bind_group_layouts
+                .iter()
+                .map(|l| l.value())
+                .collect::<Vec<_>>();
+            render_device.create_pipeline_layout(&PipelineLayoutDescriptor {
+                bind_group_layouts: &bind_group_layouts,
+                ..Default::default()
+            })
+        })
+    }
+}
+
+pub struct RenderPipelineCache {
+    layout_cache: LayoutCache,
+    shader_cache: ShaderCache,
+    device: RenderDevice,
+    pipelines: Vec<CachedPipeline>,
+    waiting_pipelines: HashSet<CachedPipelineId>,
+}
+
+struct CachedPipeline {
+    descriptor: RenderPipelineDescriptor,
+    state: CachedPipelineState,
+}
+
+#[derive(Debug)]
+pub enum CachedPipelineState {
+    Queued,
+    Ok(RenderPipeline),
+    Err(RenderPipelineError),
+}
+
+impl CachedPipelineState {
+    pub fn unwrap(&self) -> &RenderPipeline {
+        match self {
+            CachedPipelineState::Ok(pipeline) => pipeline,
+            CachedPipelineState::Queued => {
+                panic!("Pipeline has not been compiled yet. It is still in the 'Queued' state.")
+            }
+            CachedPipelineState::Err(err) => panic!("{}", err),
+        }
+    }
+}
+
+#[derive(Error, Debug)]
+pub enum RenderPipelineError {
+    #[error(
+        "Pipeline cound not be compiled because the following shader is not loaded yet: {0:?}"
+    )]
+    ShaderNotLoaded(Handle<Shader>),
+    #[error(transparent)]
+    ProcessShaderError(#[from] ProcessShaderError),
+    #[error(transparent)]
+    AsModuleDescriptorError(#[from] AsModuleDescriptorError),
+    #[error("Shader import not yet available.")]
+    ShaderImportNotYetAvailable,
+}
+
+impl RenderPipelineCache {
+    pub fn new(device: RenderDevice) -> Self {
+        Self {
+            device,
+            layout_cache: Default::default(),
+            shader_cache: Default::default(),
+            waiting_pipelines: Default::default(),
+            pipelines: Default::default(),
+        }
+    }
+
+    #[inline]
+    pub fn get_state(&self, id: CachedPipelineId) -> &CachedPipelineState {
+        &self.pipelines[id.0].state
+    }
+
+    #[inline]
+    pub fn get(&self, id: CachedPipelineId) -> Option<&RenderPipeline> {
+        if let CachedPipelineState::Ok(pipeline) = &self.pipelines[id.0].state {
+            Some(pipeline)
+        } else {
+            None
+        }
+    }
+
+    pub fn queue(&mut self, descriptor: RenderPipelineDescriptor) -> CachedPipelineId {
+        let id = CachedPipelineId(self.pipelines.len());
+        self.pipelines.push(CachedPipeline {
+            descriptor,
+            state: CachedPipelineState::Queued,
+        });
+        self.waiting_pipelines.insert(id);
+        id
+    }
+
+    fn set_shader(&mut self, handle: &Handle<Shader>, shader: &Shader) {
+        let pipelines_to_queue = self.shader_cache.set_shader(handle, shader.clone());
+        for cached_pipeline in pipelines_to_queue {
+            self.pipelines[cached_pipeline.0].state = CachedPipelineState::Queued;
+            self.waiting_pipelines.insert(cached_pipeline);
+        }
+    }
+
+    fn remove_shader(&mut self, shader: &Handle<Shader>) {
+        let pipelines_to_queue = self.shader_cache.remove(shader);
+        for cached_pipeline in pipelines_to_queue {
+            self.pipelines[cached_pipeline.0].state = CachedPipelineState::Queued;
+            self.waiting_pipelines.insert(cached_pipeline);
+        }
+    }
+
+    pub fn process_queue(&mut self) {
+        let pipelines = std::mem::take(&mut self.waiting_pipelines);
+        for id in pipelines {
+            let state = &mut self.pipelines[id.0];
+            match &state.state {
+                CachedPipelineState::Ok(_) => continue,
+                CachedPipelineState::Queued => {}
+                CachedPipelineState::Err(err) => {
+                    match err {
+                        RenderPipelineError::ShaderNotLoaded(_)
+                        | RenderPipelineError::ShaderImportNotYetAvailable => { /* retry */ }
+                        RenderPipelineError::ProcessShaderError(_)
+                        | RenderPipelineError::AsModuleDescriptorError(_) => {
+                            // shader could not be processed ... retrying won't help
+                            continue;
+                        }
+                    }
+                }
+            }
+
+            let descriptor = &state.descriptor;
+            let vertex_module = match self.shader_cache.get(
+                &self.device,
+                id,
+                &descriptor.vertex.shader,
+                &descriptor.vertex.shader_defs,
+            ) {
+                Ok(module) => module,
+                Err(err) => {
+                    state.state = CachedPipelineState::Err(err);
+                    self.waiting_pipelines.insert(id);
+                    continue;
+                }
+            };
+
+            let fragment_data = if let Some(fragment) = &descriptor.fragment {
+                let fragment_module = match self.shader_cache.get(
+                    &self.device,
+                    id,
+                    &fragment.shader,
+                    &fragment.shader_defs,
+                ) {
+                    Ok(module) => module,
+                    Err(err) => {
+                        state.state = CachedPipelineState::Err(err);
+                        self.waiting_pipelines.insert(id);
+                        continue;
+                    }
+                };
+                Some((
+                    fragment_module,
+                    fragment.entry_point.deref(),
+                    &fragment.targets,
+                ))
+            } else {
+                None
+            };
+
+            let vertex_buffer_layouts = descriptor
+                .vertex
+                .buffers
+                .iter()
+                .map(|layout| VertexBufferLayout {
+                    array_stride: layout.array_stride,
+                    attributes: &layout.attributes,
+                    step_mode: layout.step_mode,
+                })
+                .collect::<Vec<_>>();
+
+            let layout = if let Some(layout) = &descriptor.layout {
+                Some(self.layout_cache.get(&self.device, layout))
+            } else {
+                None
+            };
+
+            let descriptor = RawRenderPipelineDescriptor {
+                depth_stencil: descriptor.depth_stencil.clone(),
+                label: descriptor.label.as_deref(),
+                layout,
+                multisample: descriptor.multisample,
+                primitive: descriptor.primitive,
+                vertex: RawVertexState {
+                    buffers: &vertex_buffer_layouts,
+                    entry_point: descriptor.vertex.entry_point.deref(),
+                    module: &vertex_module,
+                },
+                fragment: fragment_data
+                    .as_ref()
+                    .map(|(module, entry_point, targets)| RawFragmentState {
+                        entry_point,
+                        module,
+                        targets,
+                    }),
+            };
+
+            let pipeline = self.device.create_render_pipeline(&descriptor);
+            state.state = CachedPipelineState::Ok(pipeline);
+        }
+    }
+
+    pub(crate) fn process_pipeline_queue_system(mut cache: ResMut<Self>) {
+        cache.process_queue();
+    }
+
+    pub(crate) fn extract_shaders(
+        mut world: ResMut<RenderWorld>,
+        shaders: Res<Assets<Shader>>,
+        mut events: EventReader<AssetEvent<Shader>>,
+    ) {
+        let mut cache = world.get_resource_mut::<Self>().unwrap();
+        for event in events.iter() {
+            match event {
+                AssetEvent::Created { handle } | AssetEvent::Modified { handle } => {
+                    if let Some(shader) = shaders.get(handle) {
+                        cache.set_shader(handle, shader);
+                    }
+                }
+                AssetEvent::Removed { handle } => cache.remove_shader(handle),
+            }
+        }
+    }
+}
diff --git a/pipelined/bevy_render2/src/render_resource/pipeline_specializer.rs b/pipelined/bevy_render2/src/render_resource/pipeline_specializer.rs
new file mode 100644
index 0000000000..a5cb472aa4
--- /dev/null
+++ b/pipelined/bevy_render2/src/render_resource/pipeline_specializer.rs
@@ -0,0 +1,34 @@
+use crate::render_resource::{CachedPipelineId, RenderPipelineCache, RenderPipelineDescriptor};
+use bevy_utils::HashMap;
+use std::hash::Hash;
+
+pub struct SpecializedPipelines<S: SpecializedPipeline> {
+    cache: HashMap<S::Key, CachedPipelineId>,
+}
+
+impl<S: SpecializedPipeline> Default for SpecializedPipelines<S> {
+    fn default() -> Self {
+        Self {
+            cache: Default::default(),
+        }
+    }
+}
+
+impl<S: SpecializedPipeline> SpecializedPipelines<S> {
+    pub fn specialize(
+        &mut self,
+        cache: &mut RenderPipelineCache,
+        specialize_pipeline: &S,
+        key: S::Key,
+    ) -> CachedPipelineId {
+        *self.cache.entry(key.clone()).or_insert_with(|| {
+            let descriptor = specialize_pipeline.specialize(key);
+            cache.queue(descriptor)
+        })
+    }
+}
+
+pub trait SpecializedPipeline {
+    type Key: Clone + Hash + PartialEq + Eq;
+    fn specialize(&self, key: Self::Key) -> RenderPipelineDescriptor;
+}
diff --git a/pipelined/bevy_render2/src/render_resource/shader.rs b/pipelined/bevy_render2/src/render_resource/shader.rs
new file mode 100644
index 0000000000..a278151379
--- /dev/null
+++ b/pipelined/bevy_render2/src/render_resource/shader.rs
@@ -0,0 +1,889 @@
+use bevy_asset::{AssetLoader, Handle, LoadContext, LoadedAsset};
+use bevy_reflect::{TypeUuid, Uuid};
+use bevy_utils::{tracing::error, BoxedFuture, HashMap};
+use naga::{valid::ModuleInfo, Module};
+use once_cell::sync::Lazy;
+use regex::Regex;
+use std::{
+    borrow::Cow, collections::HashSet, marker::Copy, ops::Deref, path::PathBuf, str::FromStr,
+};
+use thiserror::Error;
+use wgpu::{ShaderModuleDescriptor, ShaderSource};
+
+#[derive(Copy, Clone, Hash, Eq, PartialEq, Debug)]
+pub struct ShaderId(Uuid);
+
+impl ShaderId {
+    #[allow(clippy::new_without_default)]
+    pub fn new() -> Self {
+        ShaderId(Uuid::new_v4())
+    }
+}
+
+#[derive(Error, Debug)]
+pub enum ShaderReflectError {
+    #[error(transparent)]
+    WgslParse(#[from] naga::front::wgsl::ParseError),
+    #[error("GLSL Parse Error: {0:?}")]
+    GlslParse(Vec<naga::front::glsl::Error>),
+    #[error(transparent)]
+    SpirVParse(#[from] naga::front::spv::Error),
+    #[error(transparent)]
+    Validation(#[from] naga::valid::ValidationError),
+}
+
+/// A shader, as defined by its [ShaderSource] and [ShaderStage]
+/// This is an "unprocessed" shader. It can contain preprocessor directives.
+#[derive(Debug, Clone, TypeUuid)]
+#[uuid = "d95bc916-6c55-4de3-9622-37e7b6969fda"]
+pub struct Shader {
+    source: Source,
+    import_path: Option<ShaderImport>,
+    imports: Vec<ShaderImport>,
+}
+
+impl Shader {
+    pub fn from_wgsl(source: impl Into<Cow<'static, str>>) -> Shader {
+        let source = source.into();
+        Shader {
+            imports: SHADER_IMPORT_PROCESSOR.get_imports_from_str(&source),
+            source: Source::Wgsl(source),
+            import_path: None,
+        }
+    }
+
+    pub fn from_glsl(source: impl Into<Cow<'static, str>>, stage: naga::ShaderStage) -> Shader {
+        let source = source.into();
+        Shader {
+            imports: SHADER_IMPORT_PROCESSOR.get_imports_from_str(&source),
+            source: Source::Glsl(source, stage),
+            import_path: None,
+        }
+    }
+
+    pub fn from_spirv(source: impl Into<Cow<'static, [u8]>>) -> Shader {
+        Shader {
+            imports: Vec::new(),
+            source: Source::SpirV(source.into()),
+            import_path: None,
+        }
+    }
+
+    pub fn set_import_path<P: Into<String>>(&mut self, import_path: P) {
+        self.import_path = Some(ShaderImport::Custom(import_path.into()));
+    }
+
+    pub fn with_import_path<P: Into<String>>(mut self, import_path: P) -> Self {
+        self.set_import_path(import_path);
+        self
+    }
+
+    #[inline]
+    pub fn import_path(&self) -> Option<&ShaderImport> {
+        self.import_path.as_ref()
+    }
+
+    pub fn imports(&self) -> impl ExactSizeIterator<Item = &ShaderImport> {
+        self.imports.iter()
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum Source {
+    Wgsl(Cow<'static, str>),
+    Glsl(Cow<'static, str>, naga::ShaderStage),
+    SpirV(Cow<'static, [u8]>),
+    // TODO: consider the following
+    // PrecompiledSpirVMacros(HashMap<HashSet<String>, Vec<u32>>)
+    // NagaModule(Module) ... Module impls Serialize/Deserialize
+}
+
+/// A processed [Shader]. This cannot contain preprocessor directions. It must be "ready to compile"
+#[derive(PartialEq, Eq, Debug)]
+pub enum ProcessedShader {
+    Wgsl(Cow<'static, str>),
+    Glsl(Cow<'static, str>, naga::ShaderStage),
+    SpirV(Cow<'static, [u8]>),
+}
+
+impl ProcessedShader {
+    pub fn get_wgsl_source(&self) -> Option<&str> {
+        if let ProcessedShader::Wgsl(source) = self {
+            Some(source)
+        } else {
+            None
+        }
+    }
+    pub fn get_glsl_source(&self) -> Option<&str> {
+        if let ProcessedShader::Glsl(source, _stage) = self {
+            Some(source)
+        } else {
+            None
+        }
+    }
+
+    pub fn reflect(&self) -> Result<ShaderReflection, ShaderReflectError> {
+        let module = match &self {
+            // TODO: process macros here
+            ProcessedShader::Wgsl(source) => naga::front::wgsl::parse_str(source)?,
+            ProcessedShader::Glsl(source, shader_stage) => {
+                let mut parser = naga::front::glsl::Parser::default();
+                parser
+                    .parse(&naga::front::glsl::Options::from(*shader_stage), source)
+                    .map_err(ShaderReflectError::GlslParse)?
+            }
+            ProcessedShader::SpirV(source) => naga::front::spv::parse_u8_slice(
+                source,
+                &naga::front::spv::Options {
+                    adjust_coordinate_space: false,
+                    ..naga::front::spv::Options::default()
+                },
+            )?,
+        };
+        let module_info = naga::valid::Validator::new(
+            naga::valid::ValidationFlags::default(),
+            naga::valid::Capabilities::default(),
+        )
+        .validate(&module)?;
+
+        Ok(ShaderReflection {
+            module,
+            module_info,
+        })
+    }
+
+    pub fn get_module_descriptor(&self) -> Result<ShaderModuleDescriptor, AsModuleDescriptorError> {
+        Ok(ShaderModuleDescriptor {
+            label: None,
+            source: match self {
+                ProcessedShader::Wgsl(source) => ShaderSource::Wgsl(source.clone()),
+                ProcessedShader::Glsl(_source, _stage) => {
+                    let reflection = self.reflect()?;
+                    // TODO: it probably makes more sense to convert this to spirv, but as of writing
+                    // this comment, naga's spirv conversion is broken
+                    let wgsl = reflection.get_wgsl()?;
+                    ShaderSource::Wgsl(wgsl.into())
+                }
+                ProcessedShader::SpirV(_) => {
+                    // TODO: we can probably just transmute the u8 array to u32?
+                    let reflection = self.reflect()?;
+                    let spirv = reflection.get_spirv()?;
+                    ShaderSource::SpirV(Cow::Owned(spirv))
+                }
+            },
+        })
+    }
+}
+
+#[derive(Error, Debug)]
+pub enum AsModuleDescriptorError {
+    #[error(transparent)]
+    ShaderReflectError(#[from] ShaderReflectError),
+    #[error(transparent)]
+    WgslConversion(#[from] naga::back::wgsl::Error),
+    #[error(transparent)]
+    SpirVConversion(#[from] naga::back::spv::Error),
+}
+
+pub struct ShaderReflection {
+    pub module: Module,
+    pub module_info: ModuleInfo,
+}
+
+impl ShaderReflection {
+    pub fn get_spirv(&self) -> Result<Vec<u32>, naga::back::spv::Error> {
+        naga::back::spv::write_vec(
+            &self.module,
+            &self.module_info,
+            &naga::back::spv::Options {
+                flags: naga::back::spv::WriterFlags::empty(),
+                ..naga::back::spv::Options::default()
+            },
+            None,
+        )
+    }
+
+    pub fn get_wgsl(&self) -> Result<String, naga::back::wgsl::Error> {
+        naga::back::wgsl::write_string(&self.module, &self.module_info)
+    }
+}
+
+#[derive(Default)]
+pub struct ShaderLoader;
+
+impl AssetLoader for ShaderLoader {
+    fn load<'a>(
+        &'a self,
+        bytes: &'a [u8],
+        load_context: &'a mut LoadContext,
+    ) -> BoxedFuture<'a, Result<(), anyhow::Error>> {
+        Box::pin(async move {
+            let ext = load_context.path().extension().unwrap().to_str().unwrap();
+
+            let mut shader = match ext {
+                "spv" => Shader::from_spirv(Vec::from(bytes)),
+                "wgsl" => Shader::from_wgsl(String::from_utf8(Vec::from(bytes))?),
+                "vert" => Shader::from_glsl(
+                    String::from_utf8(Vec::from(bytes))?,
+                    naga::ShaderStage::Vertex,
+                ),
+                "frag" => Shader::from_glsl(
+                    String::from_utf8(Vec::from(bytes))?,
+                    naga::ShaderStage::Fragment,
+                ),
+                _ => panic!("unhandled extension: {}", ext),
+            };
+
+            shader.import_path = Some(ShaderImport::AssetPath(
+                load_context.path().to_string_lossy().to_string(),
+            ));
+            let imports = SHADER_IMPORT_PROCESSOR.get_imports(&shader);
+            let mut asset = LoadedAsset::new(shader);
+            for import in imports {
+                if let ShaderImport::AssetPath(asset_path) = import {
+                    let path = PathBuf::from_str(&asset_path)?;
+                    asset.add_dependency(path.into());
+                }
+            }
+
+            load_context.set_default_asset(asset);
+            Ok(())
+        })
+    }
+
+    fn extensions(&self) -> &[&str] {
+        &["spv", "wgsl", "vert", "frag"]
+    }
+}
+
+#[derive(Error, Debug, PartialEq, Eq)]
+pub enum ProcessShaderError {
+    #[error("Too many '# endif' lines. Each endif should be preceded by an if statement.")]
+    TooManyEndIfs,
+    #[error(
+        "Not enough '# endif' lines. Each if statement should be followed by an endif statement."
+    )]
+    NotEnoughEndIfs,
+    #[error("This Shader's format does not support processing shader defs.")]
+    ShaderFormatDoesNotSupportShaderDefs,
+    #[error("This Shader's formatdoes not support imports.")]
+    ShaderFormatDoesNotSupportImports,
+    #[error("Unresolved import: {0:?}.")]
+    UnresolvedImport(ShaderImport),
+    #[error("The shader import {0:?} does not match the source file type. Support for this might be added in the future.")]
+    MismatchedImportFormat(ShaderImport),
+}
+
+pub struct ShaderImportProcessor {
+    import_asset_path_regex: Regex,
+    import_custom_path_regex: Regex,
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Hash)]
+pub enum ShaderImport {
+    AssetPath(String),
+    Custom(String),
+}
+
+impl Default for ShaderImportProcessor {
+    fn default() -> Self {
+        Self {
+            import_asset_path_regex: Regex::new(r#"^\s*#\s*import\s*"(.+)""#).unwrap(),
+            import_custom_path_regex: Regex::new(r"^\s*#\s*import\s*(.+)").unwrap(),
+        }
+    }
+}
+
+impl ShaderImportProcessor {
+    pub fn get_imports(&self, shader: &Shader) -> Vec<ShaderImport> {
+        match &shader.source {
+            Source::Wgsl(source) => self.get_imports_from_str(source),
+            Source::Glsl(source, _stage) => self.get_imports_from_str(source),
+            Source::SpirV(_source) => Vec::new(),
+        }
+    }
+
+    pub fn get_imports_from_str(&self, shader: &str) -> Vec<ShaderImport> {
+        let mut imports = Vec::new();
+        for line in shader.split('\n') {
+            if let Some(cap) = self.import_asset_path_regex.captures(line) {
+                let import = cap.get(1).unwrap();
+                imports.push(ShaderImport::AssetPath(import.as_str().to_string()));
+            } else if let Some(cap) = self.import_custom_path_regex.captures(line) {
+                let import = cap.get(1).unwrap();
+                imports.push(ShaderImport::Custom(import.as_str().to_string()));
+            }
+        }
+
+        imports
+    }
+}
+
+pub static SHADER_IMPORT_PROCESSOR: Lazy<ShaderImportProcessor> =
+    Lazy::new(ShaderImportProcessor::default);
+
+pub struct ShaderProcessor {
+    ifdef_regex: Regex,
+    ifndef_regex: Regex,
+    endif_regex: Regex,
+}
+
+impl Default for ShaderProcessor {
+    fn default() -> Self {
+        Self {
+            ifdef_regex: Regex::new(r"^\s*#\s*ifdef\s*([\w|\d|_]+)").unwrap(),
+            ifndef_regex: Regex::new(r"^\s*#\s*ifndef\s*([\w|\d|_]+)").unwrap(),
+            endif_regex: Regex::new(r"^\s*#\s*endif").unwrap(),
+        }
+    }
+}
+
+impl ShaderProcessor {
+    pub fn process(
+        &self,
+        shader: &Shader,
+        shader_defs: &[String],
+        shaders: &HashMap<Handle<Shader>, Shader>,
+        import_handles: &HashMap<ShaderImport, Handle<Shader>>,
+    ) -> Result<ProcessedShader, ProcessShaderError> {
+        let shader_str = match &shader.source {
+            Source::Wgsl(source) => source.deref(),
+            Source::Glsl(source, _stage) => source.deref(),
+            Source::SpirV(source) => {
+                if shader_defs.is_empty() {
+                    return Ok(ProcessedShader::SpirV(source.clone()));
+                } else {
+                    return Err(ProcessShaderError::ShaderFormatDoesNotSupportShaderDefs);
+                }
+            }
+        };
+
+        let shader_defs = HashSet::<String>::from_iter(shader_defs.iter().cloned());
+        let mut scopes = vec![true];
+        let mut final_string = String::new();
+        for line in shader_str.split('\n') {
+            if let Some(cap) = self.ifdef_regex.captures(line) {
+                let def = cap.get(1).unwrap();
+                scopes.push(*scopes.last().unwrap() && shader_defs.contains(def.as_str()));
+            } else if let Some(cap) = self.ifndef_regex.captures(line) {
+                let def = cap.get(1).unwrap();
+                scopes.push(*scopes.last().unwrap() && !shader_defs.contains(def.as_str()));
+            } else if self.endif_regex.is_match(line) {
+                scopes.pop();
+                if scopes.is_empty() {
+                    return Err(ProcessShaderError::TooManyEndIfs);
+                }
+            } else if let Some(cap) = SHADER_IMPORT_PROCESSOR
+                .import_asset_path_regex
+                .captures(line)
+            {
+                let import = ShaderImport::AssetPath(cap.get(1).unwrap().as_str().to_string());
+                apply_import(import_handles, shaders, &import, shader, &mut final_string)?;
+            } else if let Some(cap) = SHADER_IMPORT_PROCESSOR
+                .import_custom_path_regex
+                .captures(line)
+            {
+                let import = ShaderImport::Custom(cap.get(1).unwrap().as_str().to_string());
+                apply_import(import_handles, shaders, &import, shader, &mut final_string)?;
+            } else if *scopes.last().unwrap() {
+                final_string.push_str(line);
+                final_string.push('\n');
+            }
+        }
+
+        final_string.pop();
+
+        if scopes.len() != 1 {
+            return Err(ProcessShaderError::NotEnoughEndIfs);
+        }
+
+        let processed_source = Cow::from(final_string);
+
+        match &shader.source {
+            Source::Wgsl(_source) => Ok(ProcessedShader::Wgsl(processed_source)),
+            Source::Glsl(_source, stage) => Ok(ProcessedShader::Glsl(processed_source, *stage)),
+            Source::SpirV(_source) => {
+                unreachable!("SpirV has early return");
+            }
+        }
+    }
+}
+
+fn apply_import(
+    import_handles: &HashMap<ShaderImport, Handle<Shader>>,
+    shaders: &HashMap<Handle<Shader>, Shader>,
+    import: &ShaderImport,
+    shader: &Shader,
+    final_string: &mut String,
+) -> Result<(), ProcessShaderError> {
+    let imported_shader = import_handles
+        .get(import)
+        .and_then(|handle| shaders.get(handle))
+        .ok_or_else(|| ProcessShaderError::UnresolvedImport(import.clone()))?;
+    match &shader.source {
+        Source::Wgsl(_) => {
+            if let Source::Wgsl(import_source) = &imported_shader.source {
+                final_string.push_str(import_source);
+            } else {
+                return Err(ProcessShaderError::MismatchedImportFormat(import.clone()));
+            }
+        }
+        Source::Glsl(_, _) => {
+            if let Source::Glsl(import_source, _) = &imported_shader.source {
+                final_string.push_str(import_source);
+            } else {
+                return Err(ProcessShaderError::MismatchedImportFormat(import.clone()));
+            }
+        }
+        Source::SpirV(_) => {
+            return Err(ProcessShaderError::ShaderFormatDoesNotSupportImports);
+        }
+    }
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use bevy_asset::Handle;
+    use bevy_utils::HashMap;
+    use naga::ShaderStage;
+
+    use crate::render_resource::{ProcessShaderError, Shader, ShaderImport, ShaderProcessor};
+    #[rustfmt::skip]
+const WGSL: &str = r"
+[[block]]
+struct View {
+    view_proj: mat4x4<f32>;
+    world_position: vec3<f32>;
+};
+[[group(0), binding(0)]]
+var<uniform> view: View;
+
+#ifdef TEXTURE
+[[group(1), binding(0)]]
+var sprite_texture: texture_2d<f32>;
+#endif
+
+struct VertexOutput {
+    [[location(0)]] uv: vec2<f32>;
+    [[builtin(position)]] position: vec4<f32>;
+};
+
+[[stage(vertex)]]
+fn vertex(
+    [[location(0)]] vertex_position: vec3<f32>,
+    [[location(1)]] vertex_uv: vec2<f32>
+) -> VertexOutput {
+    var out: VertexOutput;
+    out.uv = vertex_uv;
+    out.position = view.view_proj * vec4<f32>(vertex_position, 1.0);
+    return out;
+}
+";
+    const WGSL_NESTED_IFDEF: &str = r"
+[[block]]
+struct View {
+    view_proj: mat4x4<f32>;
+    world_position: vec3<f32>;
+};
+[[group(0), binding(0)]]
+var<uniform> view: View;
+
+# ifdef TEXTURE
+# ifdef ATTRIBUTE
+[[group(1), binding(0)]]
+var sprite_texture: texture_2d<f32>;
+# endif
+# endif
+
+struct VertexOutput {
+    [[location(0)]] uv: vec2<f32>;
+    [[builtin(position)]] position: vec4<f32>;
+};
+
+[[stage(vertex)]]
+fn vertex(
+    [[location(0)]] vertex_position: vec3<f32>,
+    [[location(1)]] vertex_uv: vec2<f32>
+) -> VertexOutput {
+    var out: VertexOutput;
+    out.uv = vertex_uv;
+    out.position = view.view_proj * vec4<f32>(vertex_position, 1.0);
+    return out;
+}
+";
+
+    #[test]
+    fn process_shader_def_defined() {
+        #[rustfmt::skip]
+    const EXPECTED: &str = r"
+[[block]]
+struct View {
+    view_proj: mat4x4<f32>;
+    world_position: vec3<f32>;
+};
+[[group(0), binding(0)]]
+var<uniform> view: View;
+
+[[group(1), binding(0)]]
+var sprite_texture: texture_2d<f32>;
+
+struct VertexOutput {
+    [[location(0)]] uv: vec2<f32>;
+    [[builtin(position)]] position: vec4<f32>;
+};
+
+[[stage(vertex)]]
+fn vertex(
+    [[location(0)]] vertex_position: vec3<f32>,
+    [[location(1)]] vertex_uv: vec2<f32>
+) -> VertexOutput {
+    var out: VertexOutput;
+    out.uv = vertex_uv;
+    out.position = view.view_proj * vec4<f32>(vertex_position, 1.0);
+    return out;
+}
+";
+        let processor = ShaderProcessor::default();
+        let result = processor
+            .process(
+                &Shader::from_wgsl(WGSL),
+                &["TEXTURE".to_string()],
+                &HashMap::default(),
+                &HashMap::default(),
+            )
+            .unwrap();
+        assert_eq!(result.get_wgsl_source().unwrap(), EXPECTED);
+    }
+
+    #[test]
+    fn process_shader_def_not_defined() {
+        #[rustfmt::skip]
+        const EXPECTED: &str = r"
+[[block]]
+struct View {
+    view_proj: mat4x4<f32>;
+    world_position: vec3<f32>;
+};
+[[group(0), binding(0)]]
+var<uniform> view: View;
+
+
+struct VertexOutput {
+    [[location(0)]] uv: vec2<f32>;
+    [[builtin(position)]] position: vec4<f32>;
+};
+
+[[stage(vertex)]]
+fn vertex(
+    [[location(0)]] vertex_position: vec3<f32>,
+    [[location(1)]] vertex_uv: vec2<f32>
+) -> VertexOutput {
+    var out: VertexOutput;
+    out.uv = vertex_uv;
+    out.position = view.view_proj * vec4<f32>(vertex_position, 1.0);
+    return out;
+}
+";
+        let processor = ShaderProcessor::default();
+        let result = processor
+            .process(
+                &Shader::from_wgsl(WGSL),
+                &[],
+                &HashMap::default(),
+                &HashMap::default(),
+            )
+            .unwrap();
+        assert_eq!(result.get_wgsl_source().unwrap(), EXPECTED);
+    }
+
+    #[test]
+    fn process_shader_def_unclosed() {
+        #[rustfmt::skip]
+        const INPUT: &str = r"
+#ifdef FOO
+";
+        let processor = ShaderProcessor::default();
+        let result = processor.process(
+            &Shader::from_wgsl(INPUT),
+            &[],
+            &HashMap::default(),
+            &HashMap::default(),
+        );
+        assert_eq!(result, Err(ProcessShaderError::NotEnoughEndIfs));
+    }
+
+    #[test]
+    fn process_shader_def_too_closed() {
+        #[rustfmt::skip]
+        const INPUT: &str = r"
+#endif
+";
+        let processor = ShaderProcessor::default();
+        let result = processor.process(
+            &Shader::from_wgsl(INPUT),
+            &[],
+            &HashMap::default(),
+            &HashMap::default(),
+        );
+        assert_eq!(result, Err(ProcessShaderError::TooManyEndIfs));
+    }
+
+    #[test]
+    fn process_shader_def_commented() {
+        #[rustfmt::skip]
+        const INPUT: &str = r"
+// #ifdef FOO
+fn foo() { }
+";
+        let processor = ShaderProcessor::default();
+        let result = processor
+            .process(
+                &Shader::from_wgsl(INPUT),
+                &[],
+                &HashMap::default(),
+                &HashMap::default(),
+            )
+            .unwrap();
+        assert_eq!(result.get_wgsl_source().unwrap(), INPUT);
+    }
+
+    #[test]
+    fn process_import_wgsl() {
+        #[rustfmt::skip]
+        const FOO: &str = r"
+fn foo() { }
+";
+        #[rustfmt::skip]
+        const INPUT: &str = r"
+#import FOO
+fn bar() { }
+";
+        #[rustfmt::skip]
+        const EXPECTED: &str = r"
+
+fn foo() { }
+fn bar() { }
+";
+        let processor = ShaderProcessor::default();
+        let mut shaders = HashMap::default();
+        let mut import_handles = HashMap::default();
+        let foo_handle = Handle::<Shader>::default();
+        shaders.insert(foo_handle.clone_weak(), Shader::from_wgsl(FOO));
+        import_handles.insert(
+            ShaderImport::Custom("FOO".to_string()),
+            foo_handle.clone_weak(),
+        );
+        let result = processor
+            .process(&Shader::from_wgsl(INPUT), &[], &shaders, &import_handles)
+            .unwrap();
+        assert_eq!(result.get_wgsl_source().unwrap(), EXPECTED);
+    }
+
+    #[test]
+    fn process_import_glsl() {
+        #[rustfmt::skip]
+        const FOO: &str = r"
+void foo() { }
+";
+        #[rustfmt::skip]
+        const INPUT: &str = r"
+#import FOO
+void bar() { }
+";
+        #[rustfmt::skip]
+        const EXPECTED: &str = r"
+
+void foo() { }
+void bar() { }
+";
+        let processor = ShaderProcessor::default();
+        let mut shaders = HashMap::default();
+        let mut import_handles = HashMap::default();
+        let foo_handle = Handle::<Shader>::default();
+        shaders.insert(
+            foo_handle.clone_weak(),
+            Shader::from_glsl(FOO, ShaderStage::Vertex),
+        );
+        import_handles.insert(
+            ShaderImport::Custom("FOO".to_string()),
+            foo_handle.clone_weak(),
+        );
+        let result = processor
+            .process(
+                &Shader::from_glsl(INPUT, ShaderStage::Vertex),
+                &[],
+                &shaders,
+                &import_handles,
+            )
+            .unwrap();
+        assert_eq!(result.get_glsl_source().unwrap(), EXPECTED);
+    }
+
+    #[test]
+    fn process_nested_shader_def_outer_defined_inner_not() {
+        #[rustfmt::skip]
+    const EXPECTED: &str = r"
+[[block]]
+struct View {
+    view_proj: mat4x4<f32>;
+    world_position: vec3<f32>;
+};
+[[group(0), binding(0)]]
+var<uniform> view: View;
+
+
+struct VertexOutput {
+    [[location(0)]] uv: vec2<f32>;
+    [[builtin(position)]] position: vec4<f32>;
+};
+
+[[stage(vertex)]]
+fn vertex(
+    [[location(0)]] vertex_position: vec3<f32>,
+    [[location(1)]] vertex_uv: vec2<f32>
+) -> VertexOutput {
+    var out: VertexOutput;
+    out.uv = vertex_uv;
+    out.position = view.view_proj * vec4<f32>(vertex_position, 1.0);
+    return out;
+}
+";
+        let processor = ShaderProcessor::default();
+        let result = processor
+            .process(
+                &Shader::from_wgsl(WGSL_NESTED_IFDEF),
+                &["TEXTURE".to_string()],
+                &HashMap::default(),
+                &HashMap::default(),
+            )
+            .unwrap();
+        assert_eq!(result.get_wgsl_source().unwrap(), EXPECTED);
+    }
+
+    #[test]
+    fn process_nested_shader_def_neither_defined() {
+        #[rustfmt::skip]
+    const EXPECTED: &str = r"
+[[block]]
+struct View {
+    view_proj: mat4x4<f32>;
+    world_position: vec3<f32>;
+};
+[[group(0), binding(0)]]
+var<uniform> view: View;
+
+
+struct VertexOutput {
+    [[location(0)]] uv: vec2<f32>;
+    [[builtin(position)]] position: vec4<f32>;
+};
+
+[[stage(vertex)]]
+fn vertex(
+    [[location(0)]] vertex_position: vec3<f32>,
+    [[location(1)]] vertex_uv: vec2<f32>
+) -> VertexOutput {
+    var out: VertexOutput;
+    out.uv = vertex_uv;
+    out.position = view.view_proj * vec4<f32>(vertex_position, 1.0);
+    return out;
+}
+";
+        let processor = ShaderProcessor::default();
+        let result = processor
+            .process(
+                &Shader::from_wgsl(WGSL_NESTED_IFDEF),
+                &[],
+                &HashMap::default(),
+                &HashMap::default(),
+            )
+            .unwrap();
+        assert_eq!(result.get_wgsl_source().unwrap(), EXPECTED);
+    }
+
+    #[test]
+    fn process_nested_shader_def_inner_defined_outer_not() {
+        #[rustfmt::skip]
+    const EXPECTED: &str = r"
+[[block]]
+struct View {
+    view_proj: mat4x4<f32>;
+    world_position: vec3<f32>;
+};
+[[group(0), binding(0)]]
+var<uniform> view: View;
+
+
+struct VertexOutput {
+    [[location(0)]] uv: vec2<f32>;
+    [[builtin(position)]] position: vec4<f32>;
+};
+
+[[stage(vertex)]]
+fn vertex(
+    [[location(0)]] vertex_position: vec3<f32>,
+    [[location(1)]] vertex_uv: vec2<f32>
+) -> VertexOutput {
+    var out: VertexOutput;
+    out.uv = vertex_uv;
+    out.position = view.view_proj * vec4<f32>(vertex_position, 1.0);
+    return out;
+}
+";
+        let processor = ShaderProcessor::default();
+        let result = processor
+            .process(
+                &Shader::from_wgsl(WGSL_NESTED_IFDEF),
+                &["ATTRIBUTE".to_string()],
+                &HashMap::default(),
+                &HashMap::default(),
+            )
+            .unwrap();
+        assert_eq!(result.get_wgsl_source().unwrap(), EXPECTED);
+    }
+
+    #[test]
+    fn process_nested_shader_def_both_defined() {
+        #[rustfmt::skip]
+    const EXPECTED: &str = r"
+[[block]]
+struct View {
+    view_proj: mat4x4<f32>;
+    world_position: vec3<f32>;
+};
+[[group(0), binding(0)]]
+var<uniform> view: View;
+
+[[group(1), binding(0)]]
+var sprite_texture: texture_2d<f32>;
+
+struct VertexOutput {
+    [[location(0)]] uv: vec2<f32>;
+    [[builtin(position)]] position: vec4<f32>;
+};
+
+[[stage(vertex)]]
+fn vertex(
+    [[location(0)]] vertex_position: vec3<f32>,
+    [[location(1)]] vertex_uv: vec2<f32>
+) -> VertexOutput {
+    var out: VertexOutput;
+    out.uv = vertex_uv;
+    out.position = view.view_proj * vec4<f32>(vertex_position, 1.0);
+    return out;
+}
+";
+        let processor = ShaderProcessor::default();
+        let result = processor
+            .process(
+                &Shader::from_wgsl(WGSL_NESTED_IFDEF),
+                &["TEXTURE".to_string(), "ATTRIBUTE".to_string()],
+                &HashMap::default(),
+                &HashMap::default(),
+            )
+            .unwrap();
+        assert_eq!(result.get_wgsl_source().unwrap(), EXPECTED);
+    }
+}
diff --git a/pipelined/bevy_render2/src/render_resource/texture.rs b/pipelined/bevy_render2/src/render_resource/texture.rs
new file mode 100644
index 0000000000..047c042123
--- /dev/null
+++ b/pipelined/bevy_render2/src/render_resource/texture.rs
@@ -0,0 +1,169 @@
+use bevy_utils::Uuid;
+use std::{ops::Deref, sync::Arc};
+
+/// A [`Texture`] identifier.
+#[derive(Copy, Clone, Hash, Eq, PartialEq, Debug)]
+pub struct TextureId(Uuid);
+
+/// A GPU-accessible texture.
+///
+/// May be converted from and dereferences to a wgpu [`Texture`](wgpu::Texture).
+/// Can be created via [`RenderDevice::create_texture`](crate::renderer::RenderDevice::create_texture).
+#[derive(Clone, Debug)]
+pub struct Texture {
+    id: TextureId,
+    value: Arc<wgpu::Texture>,
+}
+
+impl Texture {
+    /// Returns the [`TextureId`].
+    #[inline]
+    pub fn id(&self) -> TextureId {
+        self.id
+    }
+
+    /// Creates a view of this texture.
+    pub fn create_view(&self, desc: &wgpu::TextureViewDescriptor) -> TextureView {
+        TextureView::from(self.value.create_view(desc))
+    }
+}
+
+impl From<wgpu::Texture> for Texture {
+    fn from(value: wgpu::Texture) -> Self {
+        Texture {
+            id: TextureId(Uuid::new_v4()),
+            value: Arc::new(value),
+        }
+    }
+}
+
+impl Deref for Texture {
+    type Target = wgpu::Texture;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        &self.value
+    }
+}
+
+/// A [`TextureView`] identifier.
+#[derive(Copy, Clone, Hash, Eq, PartialEq, Debug)]
+pub struct TextureViewId(Uuid);
+
+/// This type combines wgpu's [`TextureView`](wgpu::TextureView) and
+/// [SurfaceTexture`](wgpu::SurfaceTexture) into the same interface.
+#[derive(Clone, Debug)]
+pub enum TextureViewValue {
+    /// The value is an actual wgpu [`TextureView`](wgpu::TextureView).
+    TextureView(Arc<wgpu::TextureView>),
+
+    /// The value is a wgpu [`SurfaceTexture`](wgpu::SurfaceTexture), but dereferences to
+    /// a [`TextureView`](wgpu::TextureView).
+    SurfaceTexture {
+        // NOTE: The order of these fields is important because the view must be dropped before the
+        // frame is dropped
+        view: Arc<wgpu::TextureView>,
+        texture: Arc<wgpu::SurfaceTexture>,
+    },
+}
+
+/// Describes a [`Texture`] with its associated metadata required by a pipeline or [`BindGroup`](super::BindGroup).
+///
+/// May be converted from a [`TextureView`](wgpu::TextureView) or [`SurfaceTexture`](wgpu::SurfaceTexture)
+/// or dereferences to a wgpu [`TextureView`](wgpu::TextureView).
+#[derive(Clone, Debug)]
+pub struct TextureView {
+    id: TextureViewId,
+    value: TextureViewValue,
+}
+
+impl TextureView {
+    /// Returns the [`TextureViewId`].
+    #[inline]
+    pub fn id(&self) -> TextureViewId {
+        self.id
+    }
+
+    /// Returns the [`SurfaceTexture`](wgpu::SurfaceTexture) of the texture view if it is of that type.
+    #[inline]
+    pub fn take_surface_texture(self) -> Option<wgpu::SurfaceTexture> {
+        match self.value {
+            TextureViewValue::TextureView(_) => None,
+            TextureViewValue::SurfaceTexture { texture, .. } => Arc::try_unwrap(texture).ok(),
+        }
+    }
+}
+
+impl From<wgpu::TextureView> for TextureView {
+    fn from(value: wgpu::TextureView) -> Self {
+        TextureView {
+            id: TextureViewId(Uuid::new_v4()),
+            value: TextureViewValue::TextureView(Arc::new(value)),
+        }
+    }
+}
+
+impl From<wgpu::SurfaceTexture> for TextureView {
+    fn from(value: wgpu::SurfaceTexture) -> Self {
+        let texture = Arc::new(value);
+        let view = Arc::new(texture.texture.create_view(&Default::default()));
+
+        TextureView {
+            id: TextureViewId(Uuid::new_v4()),
+            value: TextureViewValue::SurfaceTexture { texture, view },
+        }
+    }
+}
+
+impl Deref for TextureView {
+    type Target = wgpu::TextureView;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        match &self.value {
+            TextureViewValue::TextureView(value) => value,
+            TextureViewValue::SurfaceTexture { view, .. } => view,
+        }
+    }
+}
+
+/// A [`Sampler`] identifier.
+#[derive(Copy, Clone, Hash, Eq, PartialEq, Debug)]
+pub struct SamplerId(Uuid);
+
+/// A Sampler defines how a pipeline will sample from a [`TextureView`].
+/// They define image filters (including anisotropy) and address (wrapping) modes, among other things.
+///
+/// May be converted from and dereferences to a wgpu [`Sampler`](wgpu::Sampler).
+/// Can be created via [`RenderDevice::create_sampler`](crate::renderer::RenderDevice::create_sampler).
+#[derive(Clone, Debug)]
+pub struct Sampler {
+    id: SamplerId,
+    value: Arc<wgpu::Sampler>,
+}
+
+impl Sampler {
+    /// Returns the [`SamplerId`].
+    #[inline]
+    pub fn id(&self) -> SamplerId {
+        self.id
+    }
+}
+
+impl From<wgpu::Sampler> for Sampler {
+    fn from(value: wgpu::Sampler) -> Self {
+        Sampler {
+            id: SamplerId(Uuid::new_v4()),
+            value: Arc::new(value),
+        }
+    }
+}
+
+impl Deref for Sampler {
+    type Target = wgpu::Sampler;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        &self.value
+    }
+}
diff --git a/pipelined/bevy_render2/src/render_resource/uniform_vec.rs b/pipelined/bevy_render2/src/render_resource/uniform_vec.rs
new file mode 100644
index 0000000000..73d9c2a535
--- /dev/null
+++ b/pipelined/bevy_render2/src/render_resource/uniform_vec.rs
@@ -0,0 +1,158 @@
+use crate::{
+    render_resource::Buffer,
+    renderer::{RenderDevice, RenderQueue},
+};
+use crevice::std140::{self, AsStd140, DynamicUniform, Std140};
+use std::num::NonZeroU64;
+use wgpu::{BindingResource, BufferBinding, BufferDescriptor, BufferUsages};
+
+pub struct UniformVec<T: AsStd140> {
+    values: Vec<T>,
+    scratch: Vec<u8>,
+    uniform_buffer: Option<Buffer>,
+    capacity: usize,
+    item_size: usize,
+}
+
+impl<T: AsStd140> Default for UniformVec<T> {
+    fn default() -> Self {
+        Self {
+            values: Vec::new(),
+            scratch: Vec::new(),
+            uniform_buffer: None,
+            capacity: 0,
+            item_size: (T::std140_size_static() + <T as AsStd140>::Output::ALIGNMENT - 1)
+                & !(<T as AsStd140>::Output::ALIGNMENT - 1),
+        }
+    }
+}
+
+impl<T: AsStd140> UniformVec<T> {
+    #[inline]
+    pub fn uniform_buffer(&self) -> Option<&Buffer> {
+        self.uniform_buffer.as_ref()
+    }
+
+    #[inline]
+    pub fn binding(&self) -> Option<BindingResource> {
+        Some(BindingResource::Buffer(BufferBinding {
+            buffer: self.uniform_buffer()?,
+            offset: 0,
+            size: Some(NonZeroU64::new(self.item_size as u64).unwrap()),
+        }))
+    }
+
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.values.len()
+    }
+
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.values.is_empty()
+    }
+
+    #[inline]
+    pub fn capacity(&self) -> usize {
+        self.capacity
+    }
+
+    pub fn push(&mut self, value: T) -> usize {
+        let index = self.values.len();
+        self.values.push(value);
+        index
+    }
+
+    pub fn reserve(&mut self, capacity: usize, device: &RenderDevice) -> bool {
+        if capacity > self.capacity {
+            self.capacity = capacity;
+            let size = self.item_size * capacity;
+            self.scratch.resize(size, 0);
+            self.uniform_buffer = Some(device.create_buffer(&BufferDescriptor {
+                label: None,
+                size: size as wgpu::BufferAddress,
+                usage: BufferUsages::COPY_DST | BufferUsages::UNIFORM,
+                mapped_at_creation: false,
+            }));
+            true
+        } else {
+            false
+        }
+    }
+
+    pub fn write_buffer(&mut self, device: &RenderDevice, queue: &RenderQueue) {
+        if self.values.is_empty() {
+            return;
+        }
+        self.reserve(self.values.len(), device);
+        if let Some(uniform_buffer) = &self.uniform_buffer {
+            let range = 0..self.item_size * self.values.len();
+            let mut writer = std140::Writer::new(&mut self.scratch[range.clone()]);
+            writer.write(self.values.as_slice()).unwrap();
+            queue.write_buffer(uniform_buffer, 0, &self.scratch[range]);
+        }
+    }
+
+    pub fn clear(&mut self) {
+        self.values.clear();
+    }
+}
+
+pub struct DynamicUniformVec<T: AsStd140> {
+    uniform_vec: UniformVec<DynamicUniform<T>>,
+}
+
+impl<T: AsStd140> Default for DynamicUniformVec<T> {
+    fn default() -> Self {
+        Self {
+            uniform_vec: Default::default(),
+        }
+    }
+}
+
+impl<T: AsStd140> DynamicUniformVec<T> {
+    #[inline]
+    pub fn uniform_buffer(&self) -> Option<&Buffer> {
+        self.uniform_vec.uniform_buffer()
+    }
+
+    #[inline]
+    pub fn binding(&self) -> Option<BindingResource> {
+        self.uniform_vec.binding()
+    }
+
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.uniform_vec.len()
+    }
+
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.uniform_vec.is_empty()
+    }
+
+    #[inline]
+    pub fn capacity(&self) -> usize {
+        self.uniform_vec.capacity()
+    }
+
+    #[inline]
+    pub fn push(&mut self, value: T) -> u32 {
+        (self.uniform_vec.push(DynamicUniform(value)) * self.uniform_vec.item_size) as u32
+    }
+
+    #[inline]
+    pub fn reserve(&mut self, capacity: usize, device: &RenderDevice) {
+        self.uniform_vec.reserve(capacity, device);
+    }
+
+    #[inline]
+    pub fn write_buffer(&mut self, device: &RenderDevice, queue: &RenderQueue) {
+        self.uniform_vec.write_buffer(device, queue);
+    }
+
+    #[inline]
+    pub fn clear(&mut self) {
+        self.uniform_vec.clear();
+    }
+}
diff --git a/pipelined/bevy_render2/src/renderer/graph_runner.rs b/pipelined/bevy_render2/src/renderer/graph_runner.rs
new file mode 100644
index 0000000000..5df63dd3ad
--- /dev/null
+++ b/pipelined/bevy_render2/src/renderer/graph_runner.rs
@@ -0,0 +1,219 @@
+use bevy_ecs::world::World;
+#[cfg(feature = "trace")]
+use bevy_utils::tracing::info_span;
+use bevy_utils::HashMap;
+use smallvec::{smallvec, SmallVec};
+#[cfg(feature = "trace")]
+use std::ops::Deref;
+use std::{borrow::Cow, collections::VecDeque};
+use thiserror::Error;
+
+use crate::{
+    render_graph::{
+        Edge, NodeId, NodeRunError, NodeState, RenderGraph, RenderGraphContext, SlotLabel,
+        SlotType, SlotValue,
+    },
+    renderer::{RenderContext, RenderDevice},
+};
+
+pub(crate) struct RenderGraphRunner;
+
+#[derive(Error, Debug)]
+pub enum RenderGraphRunnerError {
+    #[error(transparent)]
+    NodeRunError(#[from] NodeRunError),
+    #[error("node output slot not set (index {slot_index}, name {slot_name})")]
+    EmptyNodeOutputSlot {
+        type_name: &'static str,
+        slot_index: usize,
+        slot_name: Cow<'static, str>,
+    },
+    #[error("graph (name: '{graph_name:?}') could not be run because slot '{slot_name}' at index {slot_index} has no value")]
+    MissingInput {
+        slot_index: usize,
+        slot_name: Cow<'static, str>,
+        graph_name: Option<Cow<'static, str>>,
+    },
+    #[error("attempted to use the wrong type for input slot")]
+    MismatchedInputSlotType {
+        slot_index: usize,
+        label: SlotLabel,
+        expected: SlotType,
+        actual: SlotType,
+    },
+}
+
+impl RenderGraphRunner {
+    pub fn run(
+        graph: &RenderGraph,
+        render_device: RenderDevice,
+        queue: &wgpu::Queue,
+        world: &World,
+    ) -> Result<(), RenderGraphRunnerError> {
+        let command_encoder =
+            render_device.create_command_encoder(&wgpu::CommandEncoderDescriptor::default());
+        let mut render_context = RenderContext {
+            render_device,
+            command_encoder,
+        };
+
+        Self::run_graph(graph, None, &mut render_context, world, &[])?;
+        {
+            #[cfg(feature = "trace")]
+            let span = info_span!("submit_graph_commands");
+            #[cfg(feature = "trace")]
+            let _guard = span.enter();
+            queue.submit(vec![render_context.command_encoder.finish()]);
+        }
+        Ok(())
+    }
+
+    fn run_graph(
+        graph: &RenderGraph,
+        graph_name: Option<Cow<'static, str>>,
+        render_context: &mut RenderContext,
+        world: &World,
+        inputs: &[SlotValue],
+    ) -> Result<(), RenderGraphRunnerError> {
+        let mut node_outputs: HashMap<NodeId, SmallVec<[SlotValue; 4]>> = HashMap::default();
+        #[cfg(feature = "trace")]
+        let span = if let Some(name) = &graph_name {
+            info_span!("run_graph", name = name.deref())
+        } else {
+            info_span!("run_graph", name = "main_graph")
+        };
+        #[cfg(feature = "trace")]
+        let _guard = span.enter();
+
+        // Queue up nodes without inputs, which can be run immediately
+        let mut node_queue: VecDeque<&NodeState> = graph
+            .iter_nodes()
+            .filter(|node| node.input_slots.is_empty())
+            .collect();
+
+        // pass inputs into the graph
+        if let Some(input_node) = graph.input_node() {
+            let mut input_values: SmallVec<[SlotValue; 4]> = SmallVec::new();
+            for (i, input_slot) in input_node.input_slots.iter().enumerate() {
+                if let Some(input_value) = inputs.get(i) {
+                    if input_slot.slot_type != input_value.slot_type() {
+                        return Err(RenderGraphRunnerError::MismatchedInputSlotType {
+                            slot_index: i,
+                            actual: input_value.slot_type(),
+                            expected: input_slot.slot_type,
+                            label: input_slot.name.clone().into(),
+                        });
+                    } else {
+                        input_values.push(input_value.clone());
+                    }
+                } else {
+                    return Err(RenderGraphRunnerError::MissingInput {
+                        slot_index: i,
+                        slot_name: input_slot.name.clone(),
+                        graph_name: graph_name.clone(),
+                    });
+                }
+            }
+
+            node_outputs.insert(input_node.id, input_values);
+
+            for (_, node_state) in graph.iter_node_outputs(input_node.id).expect("node exists") {
+                node_queue.push_front(node_state);
+            }
+        }
+
+        'handle_node: while let Some(node_state) = node_queue.pop_back() {
+            // skip nodes that are already processed
+            if node_outputs.contains_key(&node_state.id) {
+                continue;
+            }
+
+            let mut slot_indices_and_inputs: SmallVec<[(usize, SlotValue); 4]> = SmallVec::new();
+            // check if all dependencies have finished running
+            for (edge, input_node) in graph
+                .iter_node_inputs(node_state.id)
+                .expect("node is in graph")
+            {
+                match edge {
+                    Edge::SlotEdge {
+                        output_index,
+                        input_index,
+                        ..
+                    } => {
+                        if let Some(outputs) = node_outputs.get(&input_node.id) {
+                            slot_indices_and_inputs
+                                .push((*input_index, outputs[*output_index].clone()));
+                        } else {
+                            node_queue.push_front(node_state);
+                            continue 'handle_node;
+                        }
+                    }
+                    Edge::NodeEdge { .. } => {
+                        if !node_outputs.contains_key(&input_node.id) {
+                            node_queue.push_front(node_state);
+                            continue 'handle_node;
+                        }
+                    }
+                }
+            }
+
+            // construct final sorted input list
+            slot_indices_and_inputs.sort_by_key(|(index, _)| *index);
+            let inputs: SmallVec<[SlotValue; 4]> = slot_indices_and_inputs
+                .into_iter()
+                .map(|(_, value)| value)
+                .collect();
+
+            assert_eq!(inputs.len(), node_state.input_slots.len());
+
+            let mut outputs: SmallVec<[Option<SlotValue>; 4]> =
+                smallvec![None; node_state.output_slots.len()];
+            {
+                let mut context = RenderGraphContext::new(graph, node_state, &inputs, &mut outputs);
+                #[cfg(feature = "trace")]
+                let span = info_span!("node", name = node_state.type_name);
+                #[cfg(feature = "trace")]
+                let guard = span.enter();
+
+                node_state.node.run(&mut context, render_context, world)?;
+
+                #[cfg(feature = "trace")]
+                drop(guard);
+
+                for run_sub_graph in context.finish() {
+                    let sub_graph = graph
+                        .get_sub_graph(&run_sub_graph.name)
+                        .expect("sub graph exists because it was validated when queued.");
+                    Self::run_graph(
+                        sub_graph,
+                        Some(run_sub_graph.name),
+                        render_context,
+                        world,
+                        &run_sub_graph.inputs,
+                    )?;
+                }
+            }
+
+            let mut values: SmallVec<[SlotValue; 4]> = SmallVec::new();
+            for (i, output) in outputs.into_iter().enumerate() {
+                if let Some(value) = output {
+                    values.push(value);
+                } else {
+                    let empty_slot = node_state.output_slots.get_slot(i).unwrap();
+                    return Err(RenderGraphRunnerError::EmptyNodeOutputSlot {
+                        type_name: node_state.type_name,
+                        slot_index: i,
+                        slot_name: empty_slot.name.clone(),
+                    });
+                }
+            }
+            node_outputs.insert(node_state.id, values);
+
+            for (_, node_state) in graph.iter_node_outputs(node_state.id).expect("node exists") {
+                node_queue.push_front(node_state);
+            }
+        }
+
+        Ok(())
+    }
+}
diff --git a/pipelined/bevy_render2/src/renderer/mod.rs b/pipelined/bevy_render2/src/renderer/mod.rs
new file mode 100644
index 0000000000..dab1295dba
--- /dev/null
+++ b/pipelined/bevy_render2/src/renderer/mod.rs
@@ -0,0 +1,104 @@
+mod graph_runner;
+mod render_device;
+
+use bevy_utils::tracing::{info, info_span};
+pub use graph_runner::*;
+pub use render_device::*;
+
+use crate::{
+    render_graph::RenderGraph,
+    view::{ExtractedWindows, ViewTarget},
+};
+use bevy_ecs::prelude::*;
+use std::sync::Arc;
+use wgpu::{CommandEncoder, DeviceDescriptor, Instance, Queue, RequestAdapterOptions};
+
+/// Updates the [`RenderGraph`] with all of its nodes and then runs it to render the entire frame.
+pub fn render_system(world: &mut World) {
+    world.resource_scope(|world, mut graph: Mut<RenderGraph>| {
+        graph.update(world);
+    });
+    let graph = world.get_resource::<RenderGraph>().unwrap();
+    let render_device = world.get_resource::<RenderDevice>().unwrap();
+    let render_queue = world.get_resource::<RenderQueue>().unwrap();
+    RenderGraphRunner::run(
+        graph,
+        render_device.clone(), // TODO: is this clone really necessary?
+        render_queue,
+        world,
+    )
+    .unwrap();
+    {
+        let span = info_span!("present_frames");
+        let _guard = span.enter();
+
+        // Remove ViewTarget components to ensure swap chain TextureViews are dropped.
+        // If all TextureViews aren't dropped before present, acquiring the next swap chain texture will fail.
+        let view_entities = world
+            .query_filtered::<Entity, With<ViewTarget>>()
+            .iter(world)
+            .collect::<Vec<_>>();
+        for view_entity in view_entities {
+            world.entity_mut(view_entity).remove::<ViewTarget>();
+        }
+
+        let mut windows = world.get_resource_mut::<ExtractedWindows>().unwrap();
+        for window in windows.values_mut() {
+            if let Some(texture_view) = window.swap_chain_texture.take() {
+                if let Some(surface_texture) = texture_view.take_surface_texture() {
+                    surface_texture.present();
+                }
+            }
+        }
+    }
+}
+
+/// This queue is used to enqueue tasks for the GPU to execute asynchronously.
+pub type RenderQueue = Arc<Queue>;
+
+/// The GPU instance is used to initialize the [`RenderQueue`] and [`RenderDevice`],
+/// aswell as to create [`WindowSurfaces`](crate::view::window::WindowSurfaces).
+pub type RenderInstance = Instance;
+
+/// Initializes the renderer by retrieving and preparing the GPU instance, device and queue
+/// for the specified backend.
+pub async fn initialize_renderer(
+    instance: &Instance,
+    request_adapter_options: &RequestAdapterOptions<'_>,
+    device_descriptor: &DeviceDescriptor<'_>,
+) -> (RenderDevice, RenderQueue) {
+    let adapter = instance
+        .request_adapter(request_adapter_options)
+        .await
+        .expect("Unable to find a GPU! Make sure you have installed required drivers!");
+
+    #[cfg(not(target_arch = "wasm32"))]
+    info!("{:?}", adapter.get_info());
+
+    #[cfg(feature = "trace")]
+    let trace_path = {
+        let path = std::path::Path::new("wgpu_trace");
+        // ignore potential error, wgpu will log it
+        let _ = std::fs::create_dir(path);
+        Some(path)
+    };
+    #[cfg(not(feature = "trace"))]
+    let trace_path = None;
+
+    let (device, queue) = adapter
+        .request_device(device_descriptor, trace_path)
+        .await
+        .unwrap();
+    let device = Arc::new(device);
+    let queue = Arc::new(queue);
+    (RenderDevice::from(device), queue)
+}
+
+/// The context with all information required to interact with the GPU.
+///
+/// The [`RenderDevice`] is used to create render resources and the
+/// the [`CommandEncoder`] is used to record a series of GPU operations.
+pub struct RenderContext {
+    pub render_device: RenderDevice,
+    pub command_encoder: CommandEncoder,
+}
diff --git a/pipelined/bevy_render2/src/renderer/render_device.rs b/pipelined/bevy_render2/src/renderer/render_device.rs
new file mode 100644
index 0000000000..dda70368aa
--- /dev/null
+++ b/pipelined/bevy_render2/src/renderer/render_device.rs
@@ -0,0 +1,168 @@
+use crate::render_resource::{
+    BindGroup, BindGroupLayout, Buffer, ComputePipeline, RawRenderPipelineDescriptor,
+    RenderPipeline, Sampler, Texture,
+};
+use futures_lite::future;
+use std::sync::Arc;
+use wgpu::util::DeviceExt;
+
+/// This GPU device is responsible for the creation of most rendering and compute resources.
+#[derive(Clone)]
+pub struct RenderDevice {
+    device: Arc<wgpu::Device>,
+}
+
+impl From<Arc<wgpu::Device>> for RenderDevice {
+    fn from(device: Arc<wgpu::Device>) -> Self {
+        Self { device }
+    }
+}
+
+impl RenderDevice {
+    /// List all [`Features`](wgpu::Features) that may be used with this device.
+    ///
+    /// Functions may panic if you use unsupported features.
+    #[inline]
+    pub fn features(&self) -> wgpu::Features {
+        self.device.features()
+    }
+
+    /// List all [`Limits`](wgpu::Limits) that were requested of this device.
+    ///
+    /// If any of these limits are exceeded, functions may panic.
+    #[inline]
+    pub fn limits(&self) -> wgpu::Limits {
+        self.device.limits()
+    }
+
+    /// Creates a [ShaderModule](wgpu::ShaderModule) from either SPIR-V or WGSL source code.
+    #[inline]
+    pub fn create_shader_module(&self, desc: &wgpu::ShaderModuleDescriptor) -> wgpu::ShaderModule {
+        self.device.create_shader_module(desc)
+    }
+
+    /// Check for resource cleanups and mapping callbacks.
+    ///
+    /// no-op on the web, device is automatically polled.
+    #[inline]
+    pub fn poll(&self, maintain: wgpu::Maintain) {
+        self.device.poll(maintain)
+    }
+
+    /// Creates an empty [`CommandEncoder`](wgpu::CommandEncoder).
+    #[inline]
+    pub fn create_command_encoder(
+        &self,
+        desc: &wgpu::CommandEncoderDescriptor,
+    ) -> wgpu::CommandEncoder {
+        self.device.create_command_encoder(desc)
+    }
+
+    /// Creates an empty [`RenderBundleEncoder`](wgpu::RenderBundleEncoder).
+    #[inline]
+    pub fn create_render_bundle_encoder(
+        &self,
+        desc: &wgpu::RenderBundleEncoderDescriptor,
+    ) -> wgpu::RenderBundleEncoder {
+        self.device.create_render_bundle_encoder(desc)
+    }
+
+    /// Creates a new [`BindGroup`](wgpu::BindGroup).
+    #[inline]
+    pub fn create_bind_group(&self, desc: &wgpu::BindGroupDescriptor) -> BindGroup {
+        let wgpu_bind_group = self.device.create_bind_group(desc);
+        BindGroup::from(wgpu_bind_group)
+    }
+
+    /// Creates a [`BindGroupLayout`](wgpu::BindGroupLayout).
+    #[inline]
+    pub fn create_bind_group_layout(
+        &self,
+        desc: &wgpu::BindGroupLayoutDescriptor,
+    ) -> BindGroupLayout {
+        BindGroupLayout::from(self.device.create_bind_group_layout(desc))
+    }
+
+    /// Creates a [`PipelineLayout`](wgpu::PipelineLayout).
+    #[inline]
+    pub fn create_pipeline_layout(
+        &self,
+        desc: &wgpu::PipelineLayoutDescriptor,
+    ) -> wgpu::PipelineLayout {
+        self.device.create_pipeline_layout(desc)
+    }
+
+    /// Creates a [`RenderPipeline`].
+    #[inline]
+    pub fn create_render_pipeline(&self, desc: &RawRenderPipelineDescriptor) -> RenderPipeline {
+        let wgpu_render_pipeline = self.device.create_render_pipeline(desc);
+        RenderPipeline::from(wgpu_render_pipeline)
+    }
+
+    /// Creates a [`ComputePipeline`].
+    #[inline]
+    pub fn create_compute_pipeline(
+        &self,
+        desc: &wgpu::ComputePipelineDescriptor,
+    ) -> ComputePipeline {
+        let wgpu_compute_pipeline = self.device.create_compute_pipeline(desc);
+        ComputePipeline::from(wgpu_compute_pipeline)
+    }
+
+    /// Creates a [`Buffer`].
+    pub fn create_buffer(&self, desc: &wgpu::BufferDescriptor) -> Buffer {
+        let wgpu_buffer = self.device.create_buffer(desc);
+        Buffer::from(wgpu_buffer)
+    }
+
+    /// Creates a [`Buffer`] and initializes it with the specified data.
+    pub fn create_buffer_with_data(&self, desc: &wgpu::util::BufferInitDescriptor) -> Buffer {
+        let wgpu_buffer = self.device.create_buffer_init(desc);
+        Buffer::from(wgpu_buffer)
+    }
+
+    /// Creates a new [`Texture`].
+    ///
+    /// `desc` specifies the general format of the texture.
+    pub fn create_texture(&self, desc: &wgpu::TextureDescriptor) -> Texture {
+        let wgpu_texture = self.device.create_texture(desc);
+        Texture::from(wgpu_texture)
+    }
+
+    /// Creates a new [`Sampler`].
+    ///
+    /// `desc` specifies the behavior of the sampler.
+    pub fn create_sampler(&self, desc: &wgpu::SamplerDescriptor) -> Sampler {
+        let wgpu_sampler = self.device.create_sampler(desc);
+        Sampler::from(wgpu_sampler)
+    }
+
+    /// Create a new [`SwapChain`](wgpu::SwapChain) which targets `surface`.
+    ///
+    /// # Panics
+    ///
+    /// - A old [`SwapChainFrame`](wgpu::SwapChain) is still alive referencing an old swap chain.
+    /// - Texture format requested is unsupported on the swap chain.
+    pub fn configure_surface(&self, surface: &wgpu::Surface, config: &wgpu::SurfaceConfiguration) {
+        surface.configure(&self.device, config)
+    }
+
+    /// Returns the wgpu [`Device`](wgpu::Device).
+    pub fn wgpu_device(&self) -> &wgpu::Device {
+        &self.device
+    }
+
+    pub fn map_buffer(&self, buffer: &wgpu::BufferSlice, map_mode: wgpu::MapMode) {
+        let data = buffer.map_async(map_mode);
+        self.poll(wgpu::Maintain::Wait);
+        if future::block_on(data).is_err() {
+            panic!("Failed to map buffer to host.");
+        }
+    }
+
+    pub fn align_copy_bytes_per_row(row_bytes: usize) -> usize {
+        let align = wgpu::COPY_BYTES_PER_ROW_ALIGNMENT as usize;
+        let padded_bytes_per_row_padding = (align - row_bytes % align) % align;
+        row_bytes + padded_bytes_per_row_padding
+    }
+}
diff --git a/pipelined/bevy_render2/src/texture/hdr_texture_loader.rs b/pipelined/bevy_render2/src/texture/hdr_texture_loader.rs
new file mode 100644
index 0000000000..09890c0033
--- /dev/null
+++ b/pipelined/bevy_render2/src/texture/hdr_texture_loader.rs
@@ -0,0 +1,58 @@
+use crate::texture::{Image, TextureFormatPixelInfo};
+use anyhow::Result;
+use bevy_asset::{AssetLoader, LoadContext, LoadedAsset};
+use bevy_utils::BoxedFuture;
+use wgpu::{Extent3d, TextureDimension, TextureFormat};
+
+/// Loads HDR textures as Texture assets
+#[derive(Clone, Default)]
+pub struct HdrTextureLoader;
+
+impl AssetLoader for HdrTextureLoader {
+    fn load<'a>(
+        &'a self,
+        bytes: &'a [u8],
+        load_context: &'a mut LoadContext,
+    ) -> BoxedFuture<'a, Result<()>> {
+        Box::pin(async move {
+            let format = TextureFormat::Rgba32Float;
+            debug_assert_eq!(
+                format.pixel_size(),
+                4 * 4,
+                "Format should have 32bit x 4 size"
+            );
+
+            let decoder = image::hdr::HdrDecoder::new(bytes)?;
+            let info = decoder.metadata();
+            let rgb_data = decoder.read_image_hdr()?;
+            let mut rgba_data = Vec::with_capacity(rgb_data.len() * format.pixel_size());
+
+            for rgb in rgb_data {
+                let alpha = 1.0f32;
+
+                rgba_data.extend_from_slice(&rgb.0[0].to_ne_bytes());
+                rgba_data.extend_from_slice(&rgb.0[1].to_ne_bytes());
+                rgba_data.extend_from_slice(&rgb.0[2].to_ne_bytes());
+                rgba_data.extend_from_slice(&alpha.to_ne_bytes());
+            }
+
+            let texture = Image::new(
+                Extent3d {
+                    width: info.width,
+                    height: info.height,
+                    depth_or_array_layers: 1,
+                },
+                TextureDimension::D2,
+                rgba_data,
+                format,
+            );
+
+            load_context.set_default_asset(LoadedAsset::new(texture));
+            Ok(())
+        })
+    }
+
+    fn extensions(&self) -> &[&str] {
+        &["hdr"]
+    }
+}
diff --git a/pipelined/bevy_render2/src/texture/image.rs b/pipelined/bevy_render2/src/texture/image.rs
new file mode 100644
index 0000000000..30b7b84394
--- /dev/null
+++ b/pipelined/bevy_render2/src/texture/image.rs
@@ -0,0 +1,432 @@
+use super::image_texture_conversion::image_to_texture;
+use crate::{
+    render_asset::{PrepareAssetError, RenderAsset},
+    render_resource::{Sampler, Texture, TextureView},
+    renderer::{RenderDevice, RenderQueue},
+    texture::BevyDefault,
+};
+use bevy_ecs::system::{lifetimeless::SRes, SystemParamItem};
+use bevy_reflect::TypeUuid;
+use thiserror::Error;
+use wgpu::{
+    Extent3d, ImageCopyTexture, ImageDataLayout, Origin3d, TextureDimension, TextureFormat,
+    TextureViewDescriptor,
+};
+
+pub const TEXTURE_ASSET_INDEX: u64 = 0;
+pub const SAMPLER_ASSET_INDEX: u64 = 1;
+
+#[derive(Debug, Clone, TypeUuid)]
+#[uuid = "6ea26da6-6cf8-4ea2-9986-1d7bf6c17d6f"]
+pub struct Image {
+    pub data: Vec<u8>,
+    // TODO: this nesting makes accessing Image metadata verbose. Either flatten out descriptor or add accessors
+    pub texture_descriptor: wgpu::TextureDescriptor<'static>,
+    pub sampler_descriptor: wgpu::SamplerDescriptor<'static>,
+}
+
+impl Default for Image {
+    fn default() -> Self {
+        let format = wgpu::TextureFormat::bevy_default();
+        let data = vec![1; format.pixel_size() as usize];
+        Image {
+            data,
+            texture_descriptor: wgpu::TextureDescriptor {
+                size: wgpu::Extent3d {
+                    width: 1,
+                    height: 1,
+                    depth_or_array_layers: 1,
+                },
+                format,
+                dimension: wgpu::TextureDimension::D2,
+                label: None,
+                mip_level_count: 1,
+                sample_count: 1,
+                usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
+            },
+            sampler_descriptor: wgpu::SamplerDescriptor::default(),
+        }
+    }
+}
+
+impl Image {
+    /// Creates a new image from raw binary data and the corresponding metadata.
+    ///
+    /// # Panics
+    /// Panics if the length of the `data`, volume of the `size` and the size of the `format`
+    /// do not match.
+    pub fn new(
+        size: Extent3d,
+        dimension: TextureDimension,
+        data: Vec<u8>,
+        format: TextureFormat,
+    ) -> Self {
+        debug_assert_eq!(
+            size.volume() * format.pixel_size(),
+            data.len(),
+            "Pixel data, size and format have to match",
+        );
+        let mut image = Self {
+            data,
+            ..Default::default()
+        };
+        image.texture_descriptor.dimension = dimension;
+        image.texture_descriptor.size = size;
+        image.texture_descriptor.format = format;
+        image
+    }
+
+    /// Creates a new image from raw binary data and the corresponding metadata, by filling
+    /// the image data with the `pixel` data repeated multiple times.
+    ///
+    /// # Panics
+    /// Panics if the size of the `format` is not a multiple of the length of the `pixel` data.
+    /// do not match.
+    pub fn new_fill(
+        size: Extent3d,
+        dimension: TextureDimension,
+        pixel: &[u8],
+        format: TextureFormat,
+    ) -> Self {
+        let mut value = Image::default();
+        value.texture_descriptor.format = format;
+        value.texture_descriptor.dimension = dimension;
+        value.resize(size);
+
+        debug_assert_eq!(
+            pixel.len() % format.pixel_size(),
+            0,
+            "Must not have incomplete pixel data."
+        );
+        debug_assert!(
+            pixel.len() <= value.data.len(),
+            "Fill data must fit within pixel buffer."
+        );
+
+        for current_pixel in value.data.chunks_exact_mut(pixel.len()) {
+            current_pixel.copy_from_slice(pixel);
+        }
+        value
+    }
+
+    /// Returns the aspect ratio (height/width) of a 2D image.
+    pub fn aspect_2d(&self) -> f32 {
+        self.texture_descriptor.size.height as f32 / self.texture_descriptor.size.width as f32
+    }
+
+    /// Resizes the image to the new size, by removing information or appending 0 to the `data`.
+    /// Does not properly resize the contents of the image, but only its internal `data` buffer.
+    pub fn resize(&mut self, size: Extent3d) {
+        self.texture_descriptor.size = size;
+        self.data.resize(
+            size.volume() * self.texture_descriptor.format.pixel_size(),
+            0,
+        );
+    }
+
+    /// Changes the `size`, asserting that the total number of data elements (pixels) remains the
+    /// same.
+    ///
+    /// # Panics
+    /// Panics if the `new_size` does not have the same volume as to old one.
+    pub fn reinterpret_size(&mut self, new_size: Extent3d) {
+        assert!(
+            new_size.volume() == self.texture_descriptor.size.volume(),
+            "Incompatible sizes: old = {:?} new = {:?}",
+            self.texture_descriptor.size,
+            new_size
+        );
+
+        self.texture_descriptor.size = new_size;
+    }
+
+    /// Takes a 2D image containing vertically stacked images of the same size, and reinterprets
+    /// it as a 2D array texture, where each of the stacked images becomes one layer of the
+    /// array. This is primarily for use with the `texture2DArray` shader uniform type.
+    ///
+    /// # Panics
+    /// Panics if the texture is not 2D, has more than one layers or is not evenly dividable into
+    /// the `layers`.
+    pub fn reinterpret_stacked_2d_as_array(&mut self, layers: u32) {
+        // Must be a stacked image, and the height must be divisible by layers.
+        assert!(self.texture_descriptor.dimension == TextureDimension::D2);
+        assert!(self.texture_descriptor.size.depth_or_array_layers == 1);
+        assert_eq!(self.texture_descriptor.size.height % layers, 0);
+
+        self.reinterpret_size(Extent3d {
+            width: self.texture_descriptor.size.width,
+            height: self.texture_descriptor.size.height / layers,
+            depth_or_array_layers: layers,
+        });
+    }
+
+    /// Convert a texture from a format to another
+    /// Only a few formats are supported as input and output:
+    /// - `TextureFormat::R8Unorm`
+    /// - `TextureFormat::Rg8Unorm`
+    /// - `TextureFormat::Rgba8UnormSrgb`
+    /// - `TextureFormat::Bgra8UnormSrgb`
+    pub fn convert(&self, new_format: TextureFormat) -> Option<Self> {
+        super::image_texture_conversion::texture_to_image(self)
+            .and_then(|img| match new_format {
+                TextureFormat::R8Unorm => Some(image::DynamicImage::ImageLuma8(img.into_luma8())),
+                TextureFormat::Rg8Unorm => {
+                    Some(image::DynamicImage::ImageLumaA8(img.into_luma_alpha8()))
+                }
+                TextureFormat::Rgba8UnormSrgb => {
+                    Some(image::DynamicImage::ImageRgba8(img.into_rgba8()))
+                }
+                TextureFormat::Bgra8UnormSrgb => {
+                    Some(image::DynamicImage::ImageBgra8(img.into_bgra8()))
+                }
+                _ => None,
+            })
+            .map(super::image_texture_conversion::image_to_texture)
+    }
+
+    /// Load a bytes buffer in a [`Texture`], according to type `image_type`, using the `image`
+    /// crate`
+    pub fn from_buffer(buffer: &[u8], image_type: ImageType) -> Result<Image, TextureError> {
+        let format = match image_type {
+            ImageType::MimeType(mime_type) => match mime_type {
+                "image/png" => Ok(image::ImageFormat::Png),
+                "image/vnd-ms.dds" => Ok(image::ImageFormat::Dds),
+                "image/x-targa" => Ok(image::ImageFormat::Tga),
+                "image/x-tga" => Ok(image::ImageFormat::Tga),
+                "image/jpeg" => Ok(image::ImageFormat::Jpeg),
+                "image/bmp" => Ok(image::ImageFormat::Bmp),
+                "image/x-bmp" => Ok(image::ImageFormat::Bmp),
+                _ => Err(TextureError::InvalidImageMimeType(mime_type.to_string())),
+            },
+            ImageType::Extension(extension) => image::ImageFormat::from_extension(extension)
+                .ok_or_else(|| TextureError::InvalidImageMimeType(extension.to_string())),
+        }?;
+
+        // Load the image in the expected format.
+        // Some formats like PNG allow for R or RG textures too, so the texture
+        // format needs to be determined. For RGB textures an alpha channel
+        // needs to be added, so the image data needs to be converted in those
+        // cases.
+
+        let dyn_img = image::load_from_memory_with_format(buffer, format)?;
+        Ok(image_to_texture(dyn_img))
+    }
+}
+
+/// An error that occurs when loading a texture
+#[derive(Error, Debug)]
+pub enum TextureError {
+    #[error("invalid image mime type")]
+    InvalidImageMimeType(String),
+    #[error("invalid image extension")]
+    InvalidImageExtension(String),
+    #[error("failed to load an image: {0}")]
+    ImageError(#[from] image::ImageError),
+}
+
+/// The type of a raw image buffer.
+pub enum ImageType<'a> {
+    /// The mime type of an image, for example `"image/png"`.
+    MimeType(&'a str),
+    /// The extension of an image file, for example `"png"`.
+    Extension(&'a str),
+}
+
+/// Used to calculate the volume of an item.
+pub trait Volume {
+    fn volume(&self) -> usize;
+}
+
+impl Volume for Extent3d {
+    /// Calculates the volume of the [`Extent3D`].
+    fn volume(&self) -> usize {
+        (self.width * self.height * self.depth_or_array_layers) as usize
+    }
+}
+
+/// Information about the pixel size in bytes and the number of different components.
+pub struct PixelInfo {
+    /// The size of a component of a pixel in bytes.
+    pub type_size: usize,
+    /// The amount of different components (color channels).
+    pub num_components: usize,
+}
+
+/// Extends the wgpu [`TextureFormat`] with information about the pixel.
+pub trait TextureFormatPixelInfo {
+    /// Returns the pixel information of the format.
+    fn pixel_info(&self) -> PixelInfo;
+    /// Returns the size of a pixel of the format.
+    fn pixel_size(&self) -> usize {
+        let info = self.pixel_info();
+        info.type_size * info.num_components
+    }
+}
+
+impl TextureFormatPixelInfo for TextureFormat {
+    fn pixel_info(&self) -> PixelInfo {
+        let type_size = match self {
+            // 8bit
+            TextureFormat::R8Unorm
+            | TextureFormat::R8Snorm
+            | TextureFormat::R8Uint
+            | TextureFormat::R8Sint
+            | TextureFormat::Rg8Unorm
+            | TextureFormat::Rg8Snorm
+            | TextureFormat::Rg8Uint
+            | TextureFormat::Rg8Sint
+            | TextureFormat::Rgba8Unorm
+            | TextureFormat::Rgba8UnormSrgb
+            | TextureFormat::Rgba8Snorm
+            | TextureFormat::Rgba8Uint
+            | TextureFormat::Rgba8Sint
+            | TextureFormat::Bgra8Unorm
+            | TextureFormat::Bgra8UnormSrgb => 1,
+
+            // 16bit
+            TextureFormat::R16Uint
+            | TextureFormat::R16Sint
+            | TextureFormat::R16Float
+            | TextureFormat::Rg16Uint
+            | TextureFormat::Rg16Sint
+            | TextureFormat::Rg16Float
+            | TextureFormat::Rgba16Uint
+            | TextureFormat::Rgba16Sint
+            | TextureFormat::Rgba16Float => 2,
+
+            // 32bit
+            TextureFormat::R32Uint
+            | TextureFormat::R32Sint
+            | TextureFormat::R32Float
+            | TextureFormat::Rg32Uint
+            | TextureFormat::Rg32Sint
+            | TextureFormat::Rg32Float
+            | TextureFormat::Rgba32Uint
+            | TextureFormat::Rgba32Sint
+            | TextureFormat::Rgba32Float
+            | TextureFormat::Depth32Float => 4,
+
+            // special cases
+            TextureFormat::Rgb10a2Unorm => 4,
+            TextureFormat::Rg11b10Float => 4,
+            TextureFormat::Depth24Plus => 3, // FIXME is this correct?
+            TextureFormat::Depth24PlusStencil8 => 4,
+            // TODO: this is not good! this is a temporary step while porting bevy_render to direct wgpu usage
+            _ => panic!("cannot get pixel info for type"),
+        };
+
+        let components = match self {
+            TextureFormat::R8Unorm
+            | TextureFormat::R8Snorm
+            | TextureFormat::R8Uint
+            | TextureFormat::R8Sint
+            | TextureFormat::R16Uint
+            | TextureFormat::R16Sint
+            | TextureFormat::R16Float
+            | TextureFormat::R32Uint
+            | TextureFormat::R32Sint
+            | TextureFormat::R32Float => 1,
+
+            TextureFormat::Rg8Unorm
+            | TextureFormat::Rg8Snorm
+            | TextureFormat::Rg8Uint
+            | TextureFormat::Rg8Sint
+            | TextureFormat::Rg16Uint
+            | TextureFormat::Rg16Sint
+            | TextureFormat::Rg16Float
+            | TextureFormat::Rg32Uint
+            | TextureFormat::Rg32Sint
+            | TextureFormat::Rg32Float => 2,
+
+            TextureFormat::Rgba8Unorm
+            | TextureFormat::Rgba8UnormSrgb
+            | TextureFormat::Rgba8Snorm
+            | TextureFormat::Rgba8Uint
+            | TextureFormat::Rgba8Sint
+            | TextureFormat::Bgra8Unorm
+            | TextureFormat::Bgra8UnormSrgb
+            | TextureFormat::Rgba16Uint
+            | TextureFormat::Rgba16Sint
+            | TextureFormat::Rgba16Float
+            | TextureFormat::Rgba32Uint
+            | TextureFormat::Rgba32Sint
+            | TextureFormat::Rgba32Float => 4,
+
+            // special cases
+            TextureFormat::Rgb10a2Unorm
+            | TextureFormat::Rg11b10Float
+            | TextureFormat::Depth32Float
+            | TextureFormat::Depth24Plus
+            | TextureFormat::Depth24PlusStencil8 => 1,
+            // TODO: this is not good! this is a temporary step while porting bevy_render to direct wgpu usage
+            _ => panic!("cannot get pixel info for type"),
+        };
+
+        PixelInfo {
+            type_size,
+            num_components: components,
+        }
+    }
+}
+
+/// The GPU-representation of an [`Image`].
+/// Consists of the [`Texture`], its [`TextureView`] and the corresponding [`Sampler`].
+#[derive(Debug, Clone)]
+pub struct GpuImage {
+    pub texture: Texture,
+    pub texture_view: TextureView,
+    pub sampler: Sampler,
+}
+
+impl RenderAsset for Image {
+    type ExtractedAsset = Image;
+    type PreparedAsset = GpuImage;
+    type Param = (SRes<RenderDevice>, SRes<RenderQueue>);
+
+    /// Clones the Image.
+    fn extract_asset(&self) -> Self::ExtractedAsset {
+        self.clone()
+    }
+
+    /// Converts the extracted image into a [`GpuImage`].
+    fn prepare_asset(
+        image: Self::ExtractedAsset,
+        (render_device, render_queue): &mut SystemParamItem<Self::Param>,
+    ) -> Result<Self::PreparedAsset, PrepareAssetError<Self::ExtractedAsset>> {
+        let texture = render_device.create_texture(&image.texture_descriptor);
+        let sampler = render_device.create_sampler(&image.sampler_descriptor);
+
+        let format_size = image.texture_descriptor.format.pixel_size();
+        render_queue.write_texture(
+            ImageCopyTexture {
+                texture: &texture,
+                mip_level: 0,
+                origin: Origin3d::ZERO,
+                aspect: wgpu::TextureAspect::All,
+            },
+            &image.data,
+            ImageDataLayout {
+                offset: 0,
+                bytes_per_row: Some(
+                    std::num::NonZeroU32::new(
+                        image.texture_descriptor.size.width * format_size as u32,
+                    )
+                    .unwrap(),
+                ),
+                rows_per_image: if image.texture_descriptor.size.depth_or_array_layers > 1 {
+                    std::num::NonZeroU32::new(image.texture_descriptor.size.height)
+                } else {
+                    None
+                },
+            },
+            image.texture_descriptor.size,
+        );
+
+        let texture_view = texture.create_view(&TextureViewDescriptor::default());
+        Ok(GpuImage {
+            texture,
+            texture_view,
+            sampler,
+        })
+    }
+}
diff --git a/pipelined/bevy_render2/src/texture/image_texture_conversion.rs b/pipelined/bevy_render2/src/texture/image_texture_conversion.rs
new file mode 100644
index 0000000000..d3c243bad4
--- /dev/null
+++ b/pipelined/bevy_render2/src/texture/image_texture_conversion.rs
@@ -0,0 +1,158 @@
+use crate::texture::{Image, TextureFormatPixelInfo};
+use wgpu::{Extent3d, TextureDimension, TextureFormat};
+
+// TODO: fix name?
+/// Converts a [`DynamicImage`] to an [`Image`].
+pub(crate) fn image_to_texture(dyn_img: image::DynamicImage) -> Image {
+    use bevy_core::cast_slice;
+    let width;
+    let height;
+
+    let data: Vec<u8>;
+    let format: TextureFormat;
+
+    match dyn_img {
+        image::DynamicImage::ImageLuma8(i) => {
+            let i = image::DynamicImage::ImageLuma8(i).into_rgba8();
+            width = i.width();
+            height = i.height();
+            format = TextureFormat::Rgba8UnormSrgb;
+
+            data = i.into_raw();
+        }
+        image::DynamicImage::ImageLumaA8(i) => {
+            let i = image::DynamicImage::ImageLumaA8(i).into_rgba8();
+            width = i.width();
+            height = i.height();
+            format = TextureFormat::Rgba8UnormSrgb;
+
+            data = i.into_raw();
+        }
+        image::DynamicImage::ImageRgb8(i) => {
+            let i = image::DynamicImage::ImageRgb8(i).into_rgba8();
+            width = i.width();
+            height = i.height();
+            format = TextureFormat::Rgba8UnormSrgb;
+
+            data = i.into_raw();
+        }
+        image::DynamicImage::ImageRgba8(i) => {
+            width = i.width();
+            height = i.height();
+            format = TextureFormat::Rgba8UnormSrgb;
+
+            data = i.into_raw();
+        }
+        image::DynamicImage::ImageBgr8(i) => {
+            let i = image::DynamicImage::ImageBgr8(i).into_bgra8();
+
+            width = i.width();
+            height = i.height();
+            format = TextureFormat::Bgra8UnormSrgb;
+
+            data = i.into_raw();
+        }
+        image::DynamicImage::ImageBgra8(i) => {
+            width = i.width();
+            height = i.height();
+            format = TextureFormat::Bgra8UnormSrgb;
+
+            data = i.into_raw();
+        }
+        image::DynamicImage::ImageLuma16(i) => {
+            width = i.width();
+            height = i.height();
+            format = TextureFormat::R16Uint;
+
+            let raw_data = i.into_raw();
+
+            data = cast_slice(&raw_data).to_owned();
+        }
+        image::DynamicImage::ImageLumaA16(i) => {
+            width = i.width();
+            height = i.height();
+            format = TextureFormat::Rg16Uint;
+
+            let raw_data = i.into_raw();
+
+            data = cast_slice(&raw_data).to_owned();
+        }
+
+        image::DynamicImage::ImageRgb16(image) => {
+            width = image.width();
+            height = image.height();
+            format = TextureFormat::Rgba16Uint;
+
+            let mut local_data =
+                Vec::with_capacity(width as usize * height as usize * format.pixel_size());
+
+            for pixel in image.into_raw().chunks_exact(3) {
+                // TODO use the array_chunks method once stabilised
+                // https://github.com/rust-lang/rust/issues/74985
+                let r = pixel[0];
+                let g = pixel[1];
+                let b = pixel[2];
+                let a = u16::max_value();
+
+                local_data.extend_from_slice(&r.to_ne_bytes());
+                local_data.extend_from_slice(&g.to_ne_bytes());
+                local_data.extend_from_slice(&b.to_ne_bytes());
+                local_data.extend_from_slice(&a.to_ne_bytes());
+            }
+
+            data = local_data;
+        }
+        image::DynamicImage::ImageRgba16(i) => {
+            width = i.width();
+            height = i.height();
+            format = TextureFormat::Rgba16Uint;
+
+            let raw_data = i.into_raw();
+
+            data = cast_slice(&raw_data).to_owned();
+        }
+    }
+
+    Image::new(
+        Extent3d {
+            width,
+            height,
+            depth_or_array_layers: 1,
+        },
+        TextureDimension::D2,
+        data,
+        format,
+    )
+}
+
+/// Converts an [`Image`] to a [`DynamicImage`]. Not all [`TextureFormat`] are
+/// covered, therefore it will return `None` if the format is unsupported.
+pub(crate) fn texture_to_image(texture: &Image) -> Option<image::DynamicImage> {
+    match texture.texture_descriptor.format {
+        TextureFormat::R8Unorm => image::ImageBuffer::from_raw(
+            texture.texture_descriptor.size.width,
+            texture.texture_descriptor.size.height,
+            texture.data.clone(),
+        )
+        .map(image::DynamicImage::ImageLuma8),
+        TextureFormat::Rg8Unorm => image::ImageBuffer::from_raw(
+            texture.texture_descriptor.size.width,
+            texture.texture_descriptor.size.height,
+            texture.data.clone(),
+        )
+        .map(image::DynamicImage::ImageLumaA8),
+        TextureFormat::Rgba8UnormSrgb => image::ImageBuffer::from_raw(
+            texture.texture_descriptor.size.width,
+            texture.texture_descriptor.size.height,
+            texture.data.clone(),
+        )
+        .map(image::DynamicImage::ImageRgba8),
+        TextureFormat::Bgra8UnormSrgb => image::ImageBuffer::from_raw(
+            texture.texture_descriptor.size.width,
+            texture.texture_descriptor.size.height,
+            texture.data.clone(),
+        )
+        .map(image::DynamicImage::ImageBgra8),
+        _ => None,
+    }
+}
diff --git a/pipelined/bevy_render2/src/texture/image_texture_loader.rs b/pipelined/bevy_render2/src/texture/image_texture_loader.rs
new file mode 100644
index 0000000000..20e6c774cc
--- /dev/null
+++ b/pipelined/bevy_render2/src/texture/image_texture_loader.rs
@@ -0,0 +1,67 @@
+use anyhow::Result;
+use bevy_asset::{AssetLoader, LoadContext, LoadedAsset};
+use bevy_utils::BoxedFuture;
+use thiserror::Error;
+
+use crate::texture::{Image, ImageType, TextureError};
+
+/// Loader for images that can be read by the `image` crate.
+#[derive(Clone, Default)]
+pub struct ImageTextureLoader;
+
+const FILE_EXTENSIONS: &[&str] = &["png", "dds", "tga", "jpg", "jpeg", "bmp"];
+
+impl AssetLoader for ImageTextureLoader {
+    fn load<'a>(
+        &'a self,
+        bytes: &'a [u8],
+        load_context: &'a mut LoadContext,
+    ) -> BoxedFuture<'a, Result<()>> {
+        Box::pin(async move {
+            // use the file extension for the image type
+            let ext = load_context.path().extension().unwrap().to_str().unwrap();
+
+            let dyn_img = Image::from_buffer(bytes, ImageType::Extension(ext)).map_err(|err| {
+                FileTextureError {
+                    error: err,
+                    path: format!("{}", load_context.path().display()),
+                }
+            })?;
+
+            load_context.set_default_asset(LoadedAsset::new(dyn_img));
+            Ok(())
+        })
+    }
+
+    fn extensions(&self) -> &[&str] {
+        FILE_EXTENSIONS
+    }
+}
+
+/// An error that occurs when loading a texture from a file.
+#[derive(Error, Debug)]
+pub struct FileTextureError {
+    error: TextureError,
+    path: String,
+}
+impl std::fmt::Display for FileTextureError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
+        write!(
+            f,
+            "Error reading image file {}: {}, this is an error in `bevy_render`.",
+            self.path, self.error
+        )
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_supported_file_extensions() {
+        for ext in FILE_EXTENSIONS {
+            assert!(image::ImageFormat::from_extension(ext).is_some())
+        }
+    }
+}
diff --git a/pipelined/bevy_render2/src/texture/mod.rs b/pipelined/bevy_render2/src/texture/mod.rs
new file mode 100644
index 0000000000..1b99642a5f
--- /dev/null
+++ b/pipelined/bevy_render2/src/texture/mod.rs
@@ -0,0 +1,53 @@
+#[cfg(feature = "hdr")]
+mod hdr_texture_loader;
+#[allow(clippy::module_inception)]
+mod image;
+mod image_texture_loader;
+mod texture_cache;
+
+pub(crate) mod image_texture_conversion;
+
+pub use self::image::*;
+#[cfg(feature = "hdr")]
+pub use hdr_texture_loader::*;
+pub use image_texture_loader::*;
+pub use texture_cache::*;
+
+use crate::{render_asset::RenderAssetPlugin, RenderApp, RenderStage};
+use bevy_app::{App, Plugin};
+use bevy_asset::AddAsset;
+
+// TODO: replace Texture names with Image names?
+/// Adds the [`Image`] as an asset and makes sure that they are extracted and prepared for the GPU.
+pub struct ImagePlugin;
+
+impl Plugin for ImagePlugin {
+    fn build(&self, app: &mut App) {
+        #[cfg(feature = "png")]
+        {
+            app.init_asset_loader::<ImageTextureLoader>();
+        }
+
+        app.add_plugin(RenderAssetPlugin::<Image>::default())
+            .add_asset::<Image>();
+
+        app.sub_app(RenderApp)
+            .init_resource::<TextureCache>()
+            .add_system_to_stage(RenderStage::Cleanup, update_texture_cache_system);
+    }
+}
+
+pub trait BevyDefault {
+    fn bevy_default() -> Self;
+}
+
+impl BevyDefault for wgpu::TextureFormat {
+    fn bevy_default() -> Self {
+        if cfg!(target_os = "android") || cfg!(target_arch = "wasm32") {
+            // Bgra8UnormSrgb texture missing on some Android devices
+            wgpu::TextureFormat::Rgba8UnormSrgb
+        } else {
+            wgpu::TextureFormat::Bgra8UnormSrgb
+        }
+    }
+}
diff --git a/pipelined/bevy_render2/src/texture/texture_cache.rs b/pipelined/bevy_render2/src/texture/texture_cache.rs
new file mode 100644
index 0000000000..cca353a1d5
--- /dev/null
+++ b/pipelined/bevy_render2/src/texture/texture_cache.rs
@@ -0,0 +1,100 @@
+use crate::{
+    render_resource::{Texture, TextureView},
+    renderer::RenderDevice,
+};
+use bevy_ecs::prelude::ResMut;
+use bevy_utils::HashMap;
+use wgpu::{TextureDescriptor, TextureViewDescriptor};
+
+/// The internal representation of a [`CachedTexture`] used to track whether it was recently used
+/// and is currently taken.
+struct CachedTextureMeta {
+    texture: Texture,
+    default_view: TextureView,
+    taken: bool,
+    frames_since_last_use: usize,
+}
+
+/// A cached GPU [`Texture`] with corresponding [`TextureView`].
+/// This is useful for textures that are created repeatedly (each frame) in the rendering process
+/// to reduce the amount of GPU memory allocations.
+pub struct CachedTexture {
+    pub texture: Texture,
+    pub default_view: TextureView,
+}
+
+/// This resource caches textures that are created repeatedly in the rendering process and
+/// are only required for one frame.
+#[derive(Default)]
+pub struct TextureCache {
+    textures: HashMap<wgpu::TextureDescriptor<'static>, Vec<CachedTextureMeta>>,
+}
+
+impl TextureCache {
+    /// Retrieves a texture that matches the `descriptor`. If no matching one is found a new
+    /// [`CachedTexture`] is created.
+    pub fn get(
+        &mut self,
+        render_device: &RenderDevice,
+        descriptor: TextureDescriptor<'static>,
+    ) -> CachedTexture {
+        match self.textures.entry(descriptor) {
+            std::collections::hash_map::Entry::Occupied(mut entry) => {
+                for texture in entry.get_mut().iter_mut() {
+                    if !texture.taken {
+                        texture.frames_since_last_use = 0;
+                        texture.taken = true;
+                        return CachedTexture {
+                            texture: texture.texture.clone(),
+                            default_view: texture.default_view.clone(),
+                        };
+                    }
+                }
+
+                let texture = render_device.create_texture(&entry.key().clone());
+                let default_view = texture.create_view(&TextureViewDescriptor::default());
+                entry.get_mut().push(CachedTextureMeta {
+                    texture: texture.clone(),
+                    default_view: default_view.clone(),
+                    frames_since_last_use: 0,
+                    taken: true,
+                });
+                CachedTexture {
+                    texture,
+                    default_view,
+                }
+            }
+            std::collections::hash_map::Entry::Vacant(entry) => {
+                let texture = render_device.create_texture(entry.key());
+                let default_view = texture.create_view(&TextureViewDescriptor::default());
+                entry.insert(vec![CachedTextureMeta {
+                    texture: texture.clone(),
+                    default_view: default_view.clone(),
+                    taken: true,
+                    frames_since_last_use: 0,
+                }]);
+                CachedTexture {
+                    texture,
+                    default_view,
+                }
+            }
+        }
+    }
+
+    /// Updates the cache and only retains recently used textures.
+    pub fn update(&mut self) {
+        for textures in self.textures.values_mut() {
+            for texture in textures.iter_mut() {
+                texture.frames_since_last_use += 1;
+                texture.taken = false;
+            }
+
+            textures.retain(|texture| texture.frames_since_last_use < 3);
+        }
+    }
+}
+
+/// Updates the [`TextureCache`] to only retains recently used textures.
+pub fn update_texture_cache_system(mut texture_cache: ResMut<TextureCache>) {
+    texture_cache.update();
+}
diff --git a/pipelined/bevy_render2/src/view/mod.rs b/pipelined/bevy_render2/src/view/mod.rs
new file mode 100644
index 0000000000..2db9a26176
--- /dev/null
+++ b/pipelined/bevy_render2/src/view/mod.rs
@@ -0,0 +1,194 @@
+pub mod visibility;
+pub mod window;
+
+pub use visibility::*;
+use wgpu::{
+    Color, Extent3d, Operations, RenderPassColorAttachment, TextureDescriptor, TextureDimension,
+    TextureFormat, TextureUsages,
+};
+pub use window::*;
+
+use crate::{
+    camera::{ExtractedCamera, ExtractedCameraNames},
+    render_resource::{DynamicUniformVec, Texture, TextureView},
+    renderer::{RenderDevice, RenderQueue},
+    texture::{BevyDefault, TextureCache},
+    RenderApp, RenderStage,
+};
+use bevy_app::{App, Plugin};
+use bevy_ecs::prelude::*;
+use bevy_math::{Mat4, Vec3};
+use bevy_transform::components::GlobalTransform;
+use crevice::std140::AsStd140;
+
+pub struct ViewPlugin;
+
+impl Plugin for ViewPlugin {
+    fn build(&self, app: &mut App) {
+        app.init_resource::<Msaa>().add_plugin(VisibilityPlugin);
+
+        app.sub_app(RenderApp)
+            .init_resource::<ViewUniforms>()
+            .add_system_to_stage(RenderStage::Extract, extract_msaa)
+            .add_system_to_stage(RenderStage::Prepare, prepare_view_uniforms)
+            .add_system_to_stage(
+                RenderStage::Prepare,
+                prepare_view_targets.after(WindowSystem::Prepare),
+            );
+    }
+}
+
+#[derive(Clone)]
+pub struct Msaa {
+    /// The number of samples to run for Multi-Sample Anti-Aliasing. Higher numbers result in
+    /// smoother edges. Note that WGPU currently only supports 1 or 4 samples.
+    /// Ultimately we plan on supporting whatever is natively supported on a given device.
+    /// Check out this issue for more info: https://github.com/gfx-rs/wgpu/issues/1832
+    pub samples: u32,
+}
+
+impl Default for Msaa {
+    fn default() -> Self {
+        Self { samples: 4 }
+    }
+}
+
+pub fn extract_msaa(mut commands: Commands, msaa: Res<Msaa>) {
+    // NOTE: windows.is_changed() handles cases where a window was resized
+    commands.insert_resource(msaa.clone());
+}
+
+#[derive(Component)]
+pub struct ExtractedView {
+    pub projection: Mat4,
+    pub transform: GlobalTransform,
+    pub width: u32,
+    pub height: u32,
+}
+
+#[derive(Clone, AsStd140)]
+pub struct ViewUniform {
+    view_proj: Mat4,
+    projection: Mat4,
+    world_position: Vec3,
+}
+
+#[derive(Default)]
+pub struct ViewUniforms {
+    pub uniforms: DynamicUniformVec<ViewUniform>,
+}
+
+#[derive(Component)]
+pub struct ViewUniformOffset {
+    pub offset: u32,
+}
+
+#[derive(Component)]
+pub struct ViewTarget {
+    pub view: TextureView,
+    pub sampled_target: Option<TextureView>,
+}
+
+impl ViewTarget {
+    pub fn get_color_attachment(&self, ops: Operations<Color>) -> RenderPassColorAttachment {
+        RenderPassColorAttachment {
+            view: if let Some(sampled_target) = &self.sampled_target {
+                sampled_target
+            } else {
+                &self.view
+            },
+            resolve_target: if self.sampled_target.is_some() {
+                Some(&self.view)
+            } else {
+                None
+            },
+            ops,
+        }
+    }
+}
+
+#[derive(Component)]
+pub struct ViewDepthTexture {
+    pub texture: Texture,
+    pub view: TextureView,
+}
+
+fn prepare_view_uniforms(
+    mut commands: Commands,
+    render_device: Res<RenderDevice>,
+    render_queue: Res<RenderQueue>,
+    mut view_uniforms: ResMut<ViewUniforms>,
+    views: Query<(Entity, &ExtractedView)>,
+) {
+    view_uniforms.uniforms.clear();
+    for (entity, camera) in views.iter() {
+        let projection = camera.projection;
+        let view_uniforms = ViewUniformOffset {
+            offset: view_uniforms.uniforms.push(ViewUniform {
+                view_proj: projection * camera.transform.compute_matrix().inverse(),
+                projection,
+                world_position: camera.transform.translation,
+            }),
+        };
+
+        commands.entity(entity).insert(view_uniforms);
+    }
+
+    view_uniforms
+        .uniforms
+        .write_buffer(&render_device, &render_queue);
+}
+
+fn prepare_view_targets(
+    mut commands: Commands,
+    camera_names: Res<ExtractedCameraNames>,
+    windows: Res<ExtractedWindows>,
+    msaa: Res<Msaa>,
+    render_device: Res<RenderDevice>,
+    mut texture_cache: ResMut<TextureCache>,
+    cameras: Query<&ExtractedCamera>,
+) {
+    for entity in camera_names.entities.values().copied() {
+        let camera = if let Ok(camera) = cameras.get(entity) {
+            camera
+        } else {
+            continue;
+        };
+        let window = if let Some(window) = windows.get(&camera.window_id) {
+            window
+        } else {
+            continue;
+        };
+        let swap_chain_texture = if let Some(texture) = &window.swap_chain_texture {
+            texture
+        } else {
+            continue;
+        };
+        let sampled_target = if msaa.samples > 1 {
+            let sampled_texture = texture_cache.get(
+                &render_device,
+                TextureDescriptor {
+                    label: Some("sampled_color_attachment_texture"),
+                    size: Extent3d {
+                        width: window.physical_width,
+                        height: window.physical_height,
+                        depth_or_array_layers: 1,
+                    },
+                    mip_level_count: 1,
+                    sample_count: msaa.samples,
+                    dimension: TextureDimension::D2,
+                    format: TextureFormat::bevy_default(),
+                    usage: TextureUsages::RENDER_ATTACHMENT,
+                },
+            );
+            Some(sampled_texture.default_view.clone())
+        } else {
+            None
+        };
+
+        commands.entity(entity).insert(ViewTarget {
+            view: swap_chain_texture.clone(),
+            sampled_target,
+        });
+    }
+}
diff --git a/pipelined/bevy_render2/src/view/visibility/mod.rs b/pipelined/bevy_render2/src/view/visibility/mod.rs
new file mode 100644
index 0000000000..5fee0293ec
--- /dev/null
+++ b/pipelined/bevy_render2/src/view/visibility/mod.rs
@@ -0,0 +1,187 @@
+mod render_layers;
+
+pub use render_layers::*;
+
+use bevy_app::{CoreStage, Plugin};
+use bevy_asset::{Assets, Handle};
+use bevy_ecs::prelude::*;
+use bevy_reflect::Reflect;
+use bevy_transform::{components::GlobalTransform, TransformSystem};
+
+use crate::{
+    camera::{Camera, CameraProjection, OrthographicProjection, PerspectiveProjection},
+    mesh::Mesh,
+    primitives::{Aabb, Frustum},
+};
+
+/// User indication of whether an entity is visible
+#[derive(Component, Clone, Reflect)]
+#[reflect(Component)]
+pub struct Visibility {
+    pub is_visible: bool,
+}
+
+impl Default for Visibility {
+    fn default() -> Self {
+        Self { is_visible: true }
+    }
+}
+
+/// Algorithmically-computed indication of whether an entity is visible and should be extracted for rendering
+#[derive(Component, Clone, Reflect)]
+#[reflect(Component)]
+pub struct ComputedVisibility {
+    pub is_visible: bool,
+}
+
+impl Default for ComputedVisibility {
+    fn default() -> Self {
+        Self { is_visible: true }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct VisibleEntity {
+    pub entity: Entity,
+}
+
+#[derive(Component, Clone, Default, Debug, Reflect)]
+#[reflect(Component)]
+pub struct VisibleEntities {
+    #[reflect(ignore)]
+    pub entities: Vec<VisibleEntity>,
+}
+
+impl VisibleEntities {
+    pub fn iter(&self) -> impl DoubleEndedIterator<Item = &VisibleEntity> {
+        self.entities.iter()
+    }
+}
+
+#[derive(Debug, Hash, PartialEq, Eq, Clone, SystemLabel)]
+pub enum VisibilitySystems {
+    CalculateBounds,
+    UpdateOrthographicFrusta,
+    UpdatePerspectiveFrusta,
+    CheckVisibility,
+}
+
+pub struct VisibilityPlugin;
+
+impl Plugin for VisibilityPlugin {
+    fn build(&self, app: &mut bevy_app::App) {
+        use VisibilitySystems::*;
+
+        app.add_system_to_stage(
+            CoreStage::PostUpdate,
+            calculate_bounds.label(CalculateBounds),
+        )
+        .add_system_to_stage(
+            CoreStage::PostUpdate,
+            update_frusta::<OrthographicProjection>
+                .label(UpdateOrthographicFrusta)
+                .after(TransformSystem::TransformPropagate),
+        )
+        .add_system_to_stage(
+            CoreStage::PostUpdate,
+            update_frusta::<PerspectiveProjection>
+                .label(UpdatePerspectiveFrusta)
+                .after(TransformSystem::TransformPropagate),
+        )
+        .add_system_to_stage(
+            CoreStage::PostUpdate,
+            check_visibility
+                .label(CheckVisibility)
+                .after(CalculateBounds)
+                .after(UpdateOrthographicFrusta)
+                .after(UpdatePerspectiveFrusta)
+                .after(TransformSystem::TransformPropagate),
+        );
+    }
+}
+
+pub fn calculate_bounds(
+    mut commands: Commands,
+    meshes: Res<Assets<Mesh>>,
+    without_aabb: Query<(Entity, &Handle<Mesh>), Without<Aabb>>,
+) {
+    for (entity, mesh_handle) in without_aabb.iter() {
+        if let Some(mesh) = meshes.get(mesh_handle) {
+            if let Some(aabb) = mesh.compute_aabb() {
+                commands.entity(entity).insert(aabb);
+            }
+        }
+    }
+}
+
+pub fn update_frusta<T: Component + CameraProjection + Send + Sync + 'static>(
+    mut views: Query<(&GlobalTransform, &T, &mut Frustum)>,
+) {
+    for (transform, projection, mut frustum) in views.iter_mut() {
+        let view_projection =
+            projection.get_projection_matrix() * transform.compute_matrix().inverse();
+        *frustum = Frustum::from_view_projection(
+            &view_projection,
+            &transform.translation,
+            &transform.back(),
+            projection.far(),
+        );
+    }
+}
+
+pub fn check_visibility(
+    mut view_query: Query<(&mut VisibleEntities, &Frustum, Option<&RenderLayers>), With<Camera>>,
+    mut visible_entity_query: QuerySet<(
+        QueryState<&mut ComputedVisibility>,
+        QueryState<(
+            Entity,
+            &Visibility,
+            &mut ComputedVisibility,
+            Option<&RenderLayers>,
+            Option<&Aabb>,
+            Option<&GlobalTransform>,
+        )>,
+    )>,
+) {
+    // Reset the computed visibility to false
+    for mut computed_visibility in visible_entity_query.q0().iter_mut() {
+        computed_visibility.is_visible = false;
+    }
+
+    for (mut visible_entities, frustum, maybe_view_mask) in view_query.iter_mut() {
+        visible_entities.entities.clear();
+        let view_mask = maybe_view_mask.copied().unwrap_or_default();
+
+        for (
+            entity,
+            visibility,
+            mut computed_visibility,
+            maybe_entity_mask,
+            maybe_aabb,
+            maybe_transform,
+        ) in visible_entity_query.q1().iter_mut()
+        {
+            if !visibility.is_visible {
+                continue;
+            }
+
+            let entity_mask = maybe_entity_mask.copied().unwrap_or_default();
+            if !view_mask.intersects(&entity_mask) {
+                continue;
+            }
+
+            // If we have an aabb and transform, do frustum culling
+            if let (Some(aabb), Some(transform)) = (maybe_aabb, maybe_transform) {
+                if !frustum.intersects_obb(aabb, &transform.compute_matrix()) {
+                    continue;
+                }
+            }
+
+            computed_visibility.is_visible = true;
+            visible_entities.entities.push(VisibleEntity { entity });
+        }
+
+        // TODO: check for big changes in visible entities len() vs capacity() (ex: 2x) and resize
+        // to prevent holding unneeded memory
+    }
+}
diff --git a/pipelined/bevy_render2/src/view/visibility/render_layers.rs b/pipelined/bevy_render2/src/view/visibility/render_layers.rs
new file mode 100644
index 0000000000..59cc40e41c
--- /dev/null
+++ b/pipelined/bevy_render2/src/view/visibility/render_layers.rs
@@ -0,0 +1,178 @@
+use bevy_ecs::prelude::{Component, ReflectComponent};
+use bevy_reflect::Reflect;
+
+type LayerMask = u32;
+
+/// An identifier for a rendering layer.
+pub type Layer = u8;
+
+/// Describes which rendering layers an entity belongs to.
+///
+/// Cameras with this component will only render entities with intersecting
+/// layers.
+///
+/// There are 32 layers numbered `0` - [`TOTAL_LAYERS`](RenderLayers::TOTAL_LAYERS). Entities may
+/// belong to one or more layers, or no layer at all.
+///
+/// The [`Default`] instance of `RenderLayers` contains layer `0`, the first layer.
+///
+/// An entity with this component without any layers is invisible.
+///
+/// Entities without this component belong to layer `0`.
+#[derive(Component, Copy, Clone, Reflect, PartialEq, Eq, PartialOrd, Ord)]
+#[reflect(Component, PartialEq)]
+pub struct RenderLayers(LayerMask);
+
+impl std::fmt::Debug for RenderLayers {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_tuple("RenderLayers")
+            .field(&self.iter().collect::<Vec<_>>())
+            .finish()
+    }
+}
+
+impl std::iter::FromIterator<Layer> for RenderLayers {
+    fn from_iter<T: IntoIterator<Item = Layer>>(i: T) -> Self {
+        i.into_iter().fold(Self::none(), |mask, g| mask.with(g))
+    }
+}
+
+/// Defaults to containing to layer `0`, the first layer.
+impl Default for RenderLayers {
+    fn default() -> Self {
+        RenderLayers::layer(0)
+    }
+}
+
+impl RenderLayers {
+    /// The total number of layers supported.
+    pub const TOTAL_LAYERS: usize = std::mem::size_of::<LayerMask>() * 8;
+
+    /// Create a new `RenderLayers` belonging to the given layer.
+    pub fn layer(n: Layer) -> Self {
+        RenderLayers(0).with(n)
+    }
+
+    /// Create a new `RenderLayers` that belongs to all layers.
+    pub fn all() -> Self {
+        RenderLayers(u32::MAX)
+    }
+
+    /// Create a new `RenderLayers` that belongs to no layers.
+    pub fn none() -> Self {
+        RenderLayers(0)
+    }
+
+    /// Create a `RenderLayers` from a list of layers.
+    pub fn from_layers(layers: &[Layer]) -> Self {
+        layers.iter().copied().collect()
+    }
+
+    /// Add the given layer.
+    ///
+    /// This may be called multiple times to allow an entity to belong
+    /// to multiple rendering layers. The maximum layer is `TOTAL_LAYERS - 1`.
+    ///
+    /// # Panics
+    /// Panics when called with a layer greater than `TOTAL_LAYERS - 1`.
+    pub fn with(mut self, layer: Layer) -> Self {
+        assert!(usize::from(layer) < Self::TOTAL_LAYERS);
+        self.0 |= 1 << layer;
+        self
+    }
+
+    /// Removes the given rendering layer.
+    ///
+    /// # Panics
+    /// Panics when called with a layer greater than `TOTAL_LAYERS - 1`.
+    pub fn without(mut self, layer: Layer) -> Self {
+        assert!(usize::from(layer) < Self::TOTAL_LAYERS);
+        self.0 &= !(1 << layer);
+        self
+    }
+
+    /// Get an iterator of the layers.
+    pub fn iter(&self) -> impl Iterator<Item = Layer> {
+        let total: Layer = std::convert::TryInto::try_into(Self::TOTAL_LAYERS).unwrap();
+        let mask = *self;
+        (0..total).filter(move |g| RenderLayers::layer(*g).intersects(&mask))
+    }
+
+    /// Determine if a `RenderLayers` intersects another.
+    ///
+    /// `RenderLayers`s intersect if they share any common layers.
+    ///
+    /// A `RenderLayers` with no layers will not match any other
+    /// `RenderLayers`, even another with no layers.
+    pub fn intersects(&self, other: &RenderLayers) -> bool {
+        (self.0 & other.0) > 0
+    }
+}
+
+#[cfg(test)]
+mod rendering_mask_tests {
+    use super::{Layer, RenderLayers};
+
+    #[test]
+    fn rendering_mask_sanity() {
+        assert_eq!(
+            RenderLayers::TOTAL_LAYERS,
+            32,
+            "total layers is what we think it is"
+        );
+        assert_eq!(RenderLayers::layer(0).0, 1, "layer 0 is mask 1");
+        assert_eq!(RenderLayers::layer(1).0, 2, "layer 1 is mask 2");
+        assert_eq!(RenderLayers::layer(0).with(1).0, 3, "layer 0 + 1 is mask 3");
+        assert_eq!(
+            RenderLayers::layer(0).with(1).without(0).0,
+            2,
+            "layer 0 + 1 - 0 is mask 2"
+        );
+        assert!(
+            RenderLayers::layer(1).intersects(&RenderLayers::layer(1)),
+            "layers match like layers"
+        );
+        assert!(
+            RenderLayers::layer(0).intersects(&RenderLayers(1)),
+            "a layer of 0 means the mask is just 1 bit"
+        );
+
+        assert!(
+            RenderLayers::layer(0)
+                .with(3)
+                .intersects(&RenderLayers::layer(3)),
+            "a mask will match another mask containing any similar layers"
+        );
+
+        assert!(
+            RenderLayers::default().intersects(&RenderLayers::default()),
+            "default masks match each other"
+        );
+
+        assert!(
+            !RenderLayers::layer(0).intersects(&RenderLayers::layer(1)),
+            "masks with differing layers do not match"
+        );
+        assert!(
+            !RenderLayers(0).intersects(&RenderLayers(0)),
+            "empty masks don't match"
+        );
+        assert_eq!(
+            RenderLayers::from_layers(&[0, 2, 16, 30])
+                .iter()
+                .collect::<Vec<_>>(),
+            vec![0, 2, 16, 30],
+            "from_layers and get_layers should roundtrip"
+        );
+        assert_eq!(
+            format!("{:?}", RenderLayers::from_layers(&[0, 1, 2, 3])).as_str(),
+            "RenderLayers([0, 1, 2, 3])",
+            "Debug instance shows layers"
+        );
+        assert_eq!(
+            RenderLayers::from_layers(&[0, 1, 2]),
+            <RenderLayers as std::iter::FromIterator<Layer>>::from_iter(vec![0, 1, 2]),
+            "from_layers and from_iter are equivalent"
+        )
+    }
+}
diff --git a/pipelined/bevy_render2/src/view/window.rs b/pipelined/bevy_render2/src/view/window.rs
new file mode 100644
index 0000000000..6bc9dafc2a
--- /dev/null
+++ b/pipelined/bevy_render2/src/view/window.rs
@@ -0,0 +1,164 @@
+use crate::{
+    render_resource::TextureView,
+    renderer::{RenderDevice, RenderInstance},
+    texture::BevyDefault,
+    RenderApp, RenderStage, RenderWorld,
+};
+use bevy_app::{App, Plugin};
+use bevy_ecs::prelude::*;
+use bevy_utils::{tracing::debug, HashMap, HashSet};
+use bevy_window::{RawWindowHandleWrapper, WindowId, Windows};
+use std::ops::{Deref, DerefMut};
+use wgpu::TextureFormat;
+
+/// Token to ensure a system runs on the main thread.
+#[derive(Default)]
+pub struct NonSendMarker;
+
+pub struct WindowRenderPlugin;
+
+#[derive(SystemLabel, Debug, Clone, PartialEq, Eq, Hash)]
+pub enum WindowSystem {
+    Prepare,
+}
+
+impl Plugin for WindowRenderPlugin {
+    fn build(&self, app: &mut App) {
+        app.sub_app(RenderApp)
+            .init_resource::<ExtractedWindows>()
+            .init_resource::<WindowSurfaces>()
+            .init_resource::<NonSendMarker>()
+            .add_system_to_stage(RenderStage::Extract, extract_windows)
+            .add_system_to_stage(
+                RenderStage::Prepare,
+                prepare_windows.label(WindowSystem::Prepare),
+            );
+    }
+}
+
+pub struct ExtractedWindow {
+    pub id: WindowId,
+    pub handle: RawWindowHandleWrapper,
+    pub physical_width: u32,
+    pub physical_height: u32,
+    pub vsync: bool,
+    pub swap_chain_texture: Option<TextureView>,
+    pub size_changed: bool,
+}
+
+#[derive(Default)]
+pub struct ExtractedWindows {
+    pub windows: HashMap<WindowId, ExtractedWindow>,
+}
+
+impl Deref for ExtractedWindows {
+    type Target = HashMap<WindowId, ExtractedWindow>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.windows
+    }
+}
+
+impl DerefMut for ExtractedWindows {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.windows
+    }
+}
+
+fn extract_windows(mut render_world: ResMut<RenderWorld>, windows: Res<Windows>) {
+    let mut extracted_windows = render_world.get_resource_mut::<ExtractedWindows>().unwrap();
+    for window in windows.iter() {
+        let (new_width, new_height) = (
+            window.physical_width().max(1),
+            window.physical_height().max(1),
+        );
+
+        let mut extracted_window =
+            extracted_windows
+                .entry(window.id())
+                .or_insert(ExtractedWindow {
+                    id: window.id(),
+                    handle: window.raw_window_handle(),
+                    physical_width: new_width,
+                    physical_height: new_height,
+                    vsync: window.vsync(),
+                    swap_chain_texture: None,
+                    size_changed: false,
+                });
+
+        // NOTE: Drop the swap chain frame here
+        extracted_window.swap_chain_texture = None;
+        extracted_window.size_changed = new_width != extracted_window.physical_width
+            || new_height != extracted_window.physical_height;
+
+        if extracted_window.size_changed {
+            debug!(
+                "Window size changed from {}x{} to {}x{}",
+                extracted_window.physical_width,
+                extracted_window.physical_height,
+                new_width,
+                new_height
+            );
+            extracted_window.physical_width = new_width;
+            extracted_window.physical_height = new_height;
+        }
+    }
+}
+
+#[derive(Default)]
+pub struct WindowSurfaces {
+    surfaces: HashMap<WindowId, wgpu::Surface>,
+    /// List of windows that we have already called the initial `configure_surface` for
+    configured_windows: HashSet<WindowId>,
+}
+
+pub fn prepare_windows(
+    // By accessing a NonSend resource, we tell the scheduler to put this system on the main thread,
+    // which is necessary for some OS s
+    _marker: NonSend<NonSendMarker>,
+    mut windows: ResMut<ExtractedWindows>,
+    mut window_surfaces: ResMut<WindowSurfaces>,
+    render_device: Res<RenderDevice>,
+    render_instance: Res<RenderInstance>,
+) {
+    let window_surfaces = window_surfaces.deref_mut();
+    for window in windows.windows.values_mut() {
+        let surface = window_surfaces
+            .surfaces
+            .entry(window.id)
+            .or_insert_with(|| unsafe {
+                // NOTE: On some OSes this MUST be called from the main thread.
+                render_instance.create_surface(&window.handle.get_handle())
+            });
+
+        let swap_chain_descriptor = wgpu::SurfaceConfiguration {
+            format: TextureFormat::bevy_default(),
+            width: window.physical_width,
+            height: window.physical_height,
+            usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
+            present_mode: if window.vsync {
+                wgpu::PresentMode::Fifo
+            } else {
+                wgpu::PresentMode::Immediate
+            },
+        };
+
+        // Do the initial surface configuration if it hasn't been configured yet
+        if window_surfaces.configured_windows.insert(window.id) || window.size_changed {
+            render_device.configure_surface(surface, &swap_chain_descriptor);
+        }
+
+        let frame = match surface.get_current_texture() {
+            Ok(swap_chain_frame) => swap_chain_frame,
+            Err(wgpu::SurfaceError::Outdated) => {
+                render_device.configure_surface(surface, &swap_chain_descriptor);
+                surface
+                    .get_current_texture()
+                    .expect("Error reconfiguring surface")
+            }
+            err => err.expect("Failed to acquire next swap chain texture!"),
+        };
+
+        window.swap_chain_texture = Some(TextureView::from(frame));
+    }
+}
diff --git a/pipelined/bevy_sprite2/Cargo.toml b/pipelined/bevy_sprite2/Cargo.toml
new file mode 100644
index 0000000000..9a52e71199
--- /dev/null
+++ b/pipelined/bevy_sprite2/Cargo.toml
@@ -0,0 +1,37 @@
+[package]
+name = "bevy_sprite2"
+version = "0.5.0"
+edition = "2021"
+authors = [
+    "Bevy Contributors <bevyengine@gmail.com>",
+    "Carter Anderson <mcanders1@gmail.com>",
+]
+description = "Provides sprite functionality for Bevy Engine"
+homepage = "https://bevyengine.org"
+repository = "https://github.com/bevyengine/bevy"
+license = "MIT"
+keywords = ["bevy"]
+
+[dependencies]
+# bevy
+bevy_app = { path = "../../crates/bevy_app", version = "0.5.0" }
+bevy_asset = { path = "../../crates/bevy_asset", version = "0.5.0" }
+bevy_core = { path = "../../crates/bevy_core", version = "0.5.0" }
+bevy_core_pipeline = { path = "../bevy_core_pipeline", version = "0.5.0" }
+bevy_ecs = { path = "../../crates/bevy_ecs", version = "0.5.0" }
+bevy_log = { path = "../../crates/bevy_log", version = "0.5.0" }
+bevy_math = { path = "../../crates/bevy_math", version = "0.5.0" }
+bevy_reflect = { path = "../../crates/bevy_reflect", version = "0.5.0", features = [
+    "bevy",
+] }
+bevy_render2 = { path = "../bevy_render2", version = "0.5.0" }
+bevy_transform = { path = "../../crates/bevy_transform", version = "0.5.0" }
+bevy_utils = { path = "../../crates/bevy_utils", version = "0.5.0" }
+
+# other
+bytemuck = { version = "1.5", features = ["derive"] }
+crevice = { path = "../../crates/crevice", version = "0.8.0", features = ["glam"] }
+guillotiere = "0.6.0"
+thiserror = "1.0"
+rectangle-pack = "0.4"
+serde = { version = "1", features = ["derive"] }
diff --git a/pipelined/bevy_sprite2/src/bundle.rs b/pipelined/bevy_sprite2/src/bundle.rs
new file mode 100644
index 0000000000..77c2a5ac15
--- /dev/null
+++ b/pipelined/bevy_sprite2/src/bundle.rs
@@ -0,0 +1,66 @@
+use crate::{
+    texture_atlas::{TextureAtlas, TextureAtlasSprite},
+    Sprite,
+};
+use bevy_asset::Handle;
+use bevy_ecs::bundle::Bundle;
+use bevy_render2::{
+    texture::Image,
+    view::{ComputedVisibility, Visibility},
+};
+use bevy_transform::components::{GlobalTransform, Transform};
+
+#[derive(Bundle, Clone)]
+pub struct PipelinedSpriteBundle {
+    pub sprite: Sprite,
+    pub transform: Transform,
+    pub global_transform: GlobalTransform,
+    pub texture: Handle<Image>,
+    /// User indication of whether an entity is visible
+    pub visibility: Visibility,
+    /// Algorithmically-computed indication of whether an entity is visible and should be extracted for rendering
+    pub computed_visibility: ComputedVisibility,
+}
+
+impl Default for PipelinedSpriteBundle {
+    fn default() -> Self {
+        Self {
+            sprite: Default::default(),
+            transform: Default::default(),
+            global_transform: Default::default(),
+            texture: Default::default(),
+            visibility: Default::default(),
+            computed_visibility: Default::default(),
+        }
+    }
+}
+
+/// A Bundle of components for drawing a single sprite from a sprite sheet (also referred
+/// to as a `TextureAtlas`)
+#[derive(Bundle, Clone)]
+pub struct PipelinedSpriteSheetBundle {
+    /// The specific sprite from the texture atlas to be drawn
+    pub sprite: TextureAtlasSprite,
+    /// A handle to the texture atlas that holds the sprite images
+    pub texture_atlas: Handle<TextureAtlas>,
+    /// Data pertaining to how the sprite is drawn on the screen
+    pub transform: Transform,
+    pub global_transform: GlobalTransform,
+    /// User indication of whether an entity is visible
+    pub visibility: Visibility,
+    /// Algorithmically-computed indication of whether an entity is visible and should be extracted for rendering
+    pub computed_visibility: ComputedVisibility,
+}
+
+impl Default for PipelinedSpriteSheetBundle {
+    fn default() -> Self {
+        Self {
+            sprite: Default::default(),
+            texture_atlas: Default::default(),
+            transform: Default::default(),
+            global_transform: Default::default(),
+            visibility: Default::default(),
+            computed_visibility: Default::default(),
+        }
+    }
+}
diff --git a/pipelined/bevy_sprite2/src/dynamic_texture_atlas_builder.rs b/pipelined/bevy_sprite2/src/dynamic_texture_atlas_builder.rs
new file mode 100644
index 0000000000..21928ed297
--- /dev/null
+++ b/pipelined/bevy_sprite2/src/dynamic_texture_atlas_builder.rs
@@ -0,0 +1,100 @@
+use crate::{Rect, TextureAtlas};
+use bevy_asset::Assets;
+use bevy_math::Vec2;
+use bevy_render2::texture::{Image, TextureFormatPixelInfo};
+use guillotiere::{size2, Allocation, AtlasAllocator};
+
+pub struct DynamicTextureAtlasBuilder {
+    pub atlas_allocator: AtlasAllocator,
+    pub padding: i32,
+}
+
+impl DynamicTextureAtlasBuilder {
+    pub fn new(size: Vec2, padding: i32) -> Self {
+        Self {
+            atlas_allocator: AtlasAllocator::new(to_size2(size)),
+            padding,
+        }
+    }
+
+    pub fn add_texture(
+        &mut self,
+        texture_atlas: &mut TextureAtlas,
+        textures: &mut Assets<Image>,
+        texture: &Image,
+    ) -> Option<usize> {
+        let allocation = self.atlas_allocator.allocate(size2(
+            texture.texture_descriptor.size.width as i32 + self.padding,
+            texture.texture_descriptor.size.height as i32 + self.padding,
+        ));
+        if let Some(allocation) = allocation {
+            let atlas_texture = textures.get_mut(&texture_atlas.texture).unwrap();
+            self.place_texture(atlas_texture, allocation, texture);
+            let mut rect: Rect = allocation.rectangle.into();
+            rect.max.x -= self.padding as f32;
+            rect.max.y -= self.padding as f32;
+            Some(texture_atlas.add_texture(rect))
+        } else {
+            None
+        }
+    }
+
+    // fn resize(
+    //     &mut self,
+    //     texture_atlas: &mut TextureAtlas,
+    //     textures: &mut Assets<Texture>,
+    //     size: Vec2,
+    // ) {
+    //     let new_size2 = to_size2(new_size);
+    //     self.atlas_texture = Texture::new_fill(new_size, &[0,0,0,0]);
+    //     let change_list = self.atlas_allocator.resize_and_rearrange(new_size2);
+
+    //     for change in change_list.changes {
+    //         if let Some(changed_texture_handle) = self.allocation_textures.remove(&change.old.id)
+    // {             let changed_texture = textures.get(&changed_texture_handle).unwrap();
+    //             self.place_texture(change.new, changed_texture_handle, changed_texture);
+    //         }
+    //     }
+
+    //     for failure in change_list.failures {
+    //         let failed_texture = self.allocation_textures.remove(&failure.id).unwrap();
+    //         queued_textures.push(failed_texture);
+    //     }
+    // }
+
+    fn place_texture(
+        &mut self,
+        atlas_texture: &mut Image,
+        allocation: Allocation,
+        texture: &Image,
+    ) {
+        let mut rect = allocation.rectangle;
+        rect.max.x -= self.padding;
+        rect.max.y -= self.padding;
+        let atlas_width = atlas_texture.texture_descriptor.size.width as usize;
+        let rect_width = rect.width() as usize;
+        let format_size = atlas_texture.texture_descriptor.format.pixel_size();
+
+        for (texture_y, bound_y) in (rect.min.y..rect.max.y).map(|i| i as usize).enumerate() {
+            let begin = (bound_y * atlas_width + rect.min.x as usize) * format_size;
+            let end = begin + rect_width * format_size;
+            let texture_begin = texture_y * rect_width * format_size;
+            let texture_end = texture_begin + rect_width * format_size;
+            atlas_texture.data[begin..end]
+                .copy_from_slice(&texture.data[texture_begin..texture_end]);
+        }
+    }
+}
+
+impl From<guillotiere::Rectangle> for Rect {
+    fn from(rectangle: guillotiere::Rectangle) -> Self {
+        Rect {
+            min: Vec2::new(rectangle.min.x as f32, rectangle.min.y as f32),
+            max: Vec2::new(rectangle.max.x as f32, rectangle.max.y as f32),
+        }
+    }
+}
+
+fn to_size2(vec2: Vec2) -> guillotiere::Size {
+    guillotiere::Size::new(vec2.x as i32, vec2.y as i32)
+}
diff --git a/pipelined/bevy_sprite2/src/lib.rs b/pipelined/bevy_sprite2/src/lib.rs
new file mode 100644
index 0000000000..27d36548c8
--- /dev/null
+++ b/pipelined/bevy_sprite2/src/lib.rs
@@ -0,0 +1,58 @@
+mod bundle;
+mod dynamic_texture_atlas_builder;
+mod rect;
+mod render;
+mod sprite;
+mod texture_atlas;
+mod texture_atlas_builder;
+
+pub use bundle::*;
+pub use dynamic_texture_atlas_builder::*;
+pub use rect::*;
+pub use render::*;
+pub use sprite::*;
+pub use texture_atlas::*;
+pub use texture_atlas_builder::*;
+
+use bevy_app::prelude::*;
+use bevy_asset::{AddAsset, Assets, HandleUntyped};
+use bevy_core_pipeline::Transparent2d;
+use bevy_reflect::TypeUuid;
+use bevy_render2::{
+    render_phase::DrawFunctions,
+    render_resource::{Shader, SpecializedPipelines},
+    RenderApp, RenderStage,
+};
+
+#[derive(Default)]
+pub struct SpritePlugin;
+
+pub const SPRITE_SHADER_HANDLE: HandleUntyped =
+    HandleUntyped::weak_from_u64(Shader::TYPE_UUID, 2763343953151597127);
+
+impl Plugin for SpritePlugin {
+    fn build(&self, app: &mut App) {
+        let mut shaders = app.world.get_resource_mut::<Assets<Shader>>().unwrap();
+        let sprite_shader = Shader::from_wgsl(include_str!("render/sprite.wgsl"));
+        shaders.set_untracked(SPRITE_SHADER_HANDLE, sprite_shader);
+        app.add_asset::<TextureAtlas>().register_type::<Sprite>();
+        let render_app = app.sub_app(RenderApp);
+        render_app
+            .init_resource::<ImageBindGroups>()
+            .init_resource::<SpritePipeline>()
+            .init_resource::<SpecializedPipelines<SpritePipeline>>()
+            .init_resource::<SpriteMeta>()
+            .init_resource::<ExtractedSprites>()
+            .add_system_to_stage(RenderStage::Extract, render::extract_sprites)
+            .add_system_to_stage(RenderStage::Prepare, render::prepare_sprites)
+            .add_system_to_stage(RenderStage::Queue, queue_sprites);
+
+        let draw_sprite = DrawSprite::new(&mut render_app.world);
+        render_app
+            .world
+            .get_resource::<DrawFunctions<Transparent2d>>()
+            .unwrap()
+            .write()
+            .add(draw_sprite);
+    }
+}
diff --git a/pipelined/bevy_sprite2/src/rect.rs b/pipelined/bevy_sprite2/src/rect.rs
new file mode 100644
index 0000000000..a90a59d71d
--- /dev/null
+++ b/pipelined/bevy_sprite2/src/rect.rs
@@ -0,0 +1,26 @@
+use bevy_math::Vec2;
+
+/// A rectangle defined by two points. There is no defined origin, so 0,0 could be anywhere
+/// (top-left, bottom-left, etc)
+#[repr(C)]
+#[derive(Default, Clone, Copy, Debug)]
+pub struct Rect {
+    /// The beginning point of the rect
+    pub min: Vec2,
+    /// The ending point of the rect
+    pub max: Vec2,
+}
+
+impl Rect {
+    pub fn width(&self) -> f32 {
+        self.max.x - self.min.x
+    }
+
+    pub fn height(&self) -> f32 {
+        self.max.y - self.min.y
+    }
+
+    pub fn size(&self) -> Vec2 {
+        Vec2::new(self.width(), self.height())
+    }
+}
diff --git a/pipelined/bevy_sprite2/src/render/mod.rs b/pipelined/bevy_sprite2/src/render/mod.rs
new file mode 100644
index 0000000000..eb33090003
--- /dev/null
+++ b/pipelined/bevy_sprite2/src/render/mod.rs
@@ -0,0 +1,566 @@
+use std::{cmp::Ordering, ops::Range};
+
+use crate::{
+    texture_atlas::{TextureAtlas, TextureAtlasSprite},
+    Rect, Sprite, SPRITE_SHADER_HANDLE,
+};
+use bevy_asset::{Assets, Handle};
+use bevy_core::FloatOrd;
+use bevy_core_pipeline::Transparent2d;
+use bevy_ecs::{
+    prelude::*,
+    system::{lifetimeless::*, SystemState},
+};
+use bevy_math::{const_vec3, Mat4, Vec2, Vec3, Vec4Swizzles};
+use bevy_render2::{
+    color::Color,
+    render_asset::RenderAssets,
+    render_phase::{Draw, DrawFunctions, RenderPhase, TrackedRenderPass},
+    render_resource::*,
+    renderer::{RenderDevice, RenderQueue},
+    texture::{BevyDefault, Image},
+    view::{ComputedVisibility, ViewUniform, ViewUniformOffset, ViewUniforms},
+    RenderWorld,
+};
+use bevy_transform::components::GlobalTransform;
+use bevy_utils::HashMap;
+use bytemuck::{Pod, Zeroable};
+use crevice::std140::AsStd140;
+
+pub struct SpritePipeline {
+    view_layout: BindGroupLayout,
+    material_layout: BindGroupLayout,
+}
+
+impl FromWorld for SpritePipeline {
+    fn from_world(world: &mut World) -> Self {
+        let world = world.cell();
+        let render_device = world.get_resource::<RenderDevice>().unwrap();
+
+        let view_layout = render_device.create_bind_group_layout(&BindGroupLayoutDescriptor {
+            entries: &[BindGroupLayoutEntry {
+                binding: 0,
+                visibility: ShaderStages::VERTEX | ShaderStages::FRAGMENT,
+                ty: BindingType::Buffer {
+                    ty: BufferBindingType::Uniform,
+                    has_dynamic_offset: true,
+                    min_binding_size: BufferSize::new(ViewUniform::std140_size_static() as u64),
+                },
+                count: None,
+            }],
+            label: Some("sprite_view_layout"),
+        });
+
+        let material_layout = render_device.create_bind_group_layout(&BindGroupLayoutDescriptor {
+            entries: &[
+                BindGroupLayoutEntry {
+                    binding: 0,
+                    visibility: ShaderStages::FRAGMENT,
+                    ty: BindingType::Texture {
+                        multisampled: false,
+                        sample_type: TextureSampleType::Float { filterable: false },
+                        view_dimension: TextureViewDimension::D2,
+                    },
+                    count: None,
+                },
+                BindGroupLayoutEntry {
+                    binding: 1,
+                    visibility: ShaderStages::FRAGMENT,
+                    ty: BindingType::Sampler {
+                        comparison: false,
+                        filtering: true,
+                    },
+                    count: None,
+                },
+            ],
+            label: Some("sprite_material_layout"),
+        });
+
+        SpritePipeline {
+            view_layout,
+            material_layout,
+        }
+    }
+}
+
+#[derive(Clone, Copy, Hash, PartialEq, Eq)]
+pub struct SpritePipelineKey {
+    colored: bool,
+}
+
+impl SpecializedPipeline for SpritePipeline {
+    type Key = SpritePipelineKey;
+
+    fn specialize(&self, key: Self::Key) -> RenderPipelineDescriptor {
+        let mut vertex_buffer_layout = VertexBufferLayout {
+            array_stride: 20,
+            step_mode: VertexStepMode::Vertex,
+            attributes: vec![
+                VertexAttribute {
+                    format: VertexFormat::Float32x3,
+                    offset: 0,
+                    shader_location: 0,
+                },
+                VertexAttribute {
+                    format: VertexFormat::Float32x2,
+                    offset: 12,
+                    shader_location: 1,
+                },
+            ],
+        };
+        let mut shader_defs = Vec::new();
+        if key.colored {
+            shader_defs.push("COLORED".to_string());
+            vertex_buffer_layout.attributes.push(VertexAttribute {
+                format: VertexFormat::Uint32,
+                offset: 20,
+                shader_location: 2,
+            });
+            vertex_buffer_layout.array_stride += 4;
+        }
+
+        RenderPipelineDescriptor {
+            vertex: VertexState {
+                shader: SPRITE_SHADER_HANDLE.typed::<Shader>(),
+                entry_point: "vertex".into(),
+                shader_defs: shader_defs.clone(),
+                buffers: vec![vertex_buffer_layout],
+            },
+            fragment: Some(FragmentState {
+                shader: SPRITE_SHADER_HANDLE.typed::<Shader>(),
+                shader_defs,
+                entry_point: "fragment".into(),
+                targets: vec![ColorTargetState {
+                    format: TextureFormat::bevy_default(),
+                    blend: Some(BlendState::ALPHA_BLENDING),
+                    write_mask: ColorWrites::ALL,
+                }],
+            }),
+            layout: Some(vec![self.view_layout.clone(), self.material_layout.clone()]),
+            primitive: PrimitiveState {
+                front_face: FrontFace::Ccw,
+                cull_mode: None,
+                polygon_mode: PolygonMode::Fill,
+                clamp_depth: false,
+                conservative: false,
+                topology: PrimitiveTopology::TriangleList,
+                strip_index_format: None,
+            },
+            depth_stencil: None,
+            multisample: MultisampleState {
+                count: 1,
+                mask: !0,
+                alpha_to_coverage_enabled: false,
+            },
+            label: Some("sprite_pipeline".into()),
+        }
+    }
+}
+
+pub struct ExtractedSprite {
+    transform: Mat4,
+    color: Color,
+    rect: Rect,
+    handle: Handle<Image>,
+    atlas_size: Option<Vec2>,
+    flip_x: bool,
+    flip_y: bool,
+}
+
+#[derive(Default)]
+pub struct ExtractedSprites {
+    sprites: Vec<ExtractedSprite>,
+}
+
+pub fn extract_sprites(
+    mut render_world: ResMut<RenderWorld>,
+    images: Res<Assets<Image>>,
+    texture_atlases: Res<Assets<TextureAtlas>>,
+    sprite_query: Query<(
+        &ComputedVisibility,
+        &Sprite,
+        &GlobalTransform,
+        &Handle<Image>,
+    )>,
+    atlas_query: Query<(
+        &ComputedVisibility,
+        &TextureAtlasSprite,
+        &GlobalTransform,
+        &Handle<TextureAtlas>,
+    )>,
+) {
+    let mut extracted_sprites = render_world.get_resource_mut::<ExtractedSprites>().unwrap();
+    extracted_sprites.sprites.clear();
+    for (computed_visibility, sprite, transform, handle) in sprite_query.iter() {
+        if !computed_visibility.is_visible {
+            continue;
+        }
+        if let Some(image) = images.get(handle) {
+            let size = image.texture_descriptor.size;
+
+            extracted_sprites.sprites.push(ExtractedSprite {
+                atlas_size: None,
+                color: sprite.color,
+                transform: transform.compute_matrix(),
+                rect: Rect {
+                    min: Vec2::ZERO,
+                    max: sprite
+                        .custom_size
+                        .unwrap_or_else(|| Vec2::new(size.width as f32, size.height as f32)),
+                },
+                flip_x: sprite.flip_x,
+                flip_y: sprite.flip_y,
+                handle: handle.clone_weak(),
+            });
+        };
+    }
+    for (computed_visibility, atlas_sprite, transform, texture_atlas_handle) in atlas_query.iter() {
+        if !computed_visibility.is_visible {
+            continue;
+        }
+        if let Some(texture_atlas) = texture_atlases.get(texture_atlas_handle) {
+            let rect = texture_atlas.textures[atlas_sprite.index as usize];
+            extracted_sprites.sprites.push(ExtractedSprite {
+                atlas_size: Some(texture_atlas.size),
+                color: atlas_sprite.color,
+                transform: transform.compute_matrix(),
+                rect,
+                flip_x: atlas_sprite.flip_x,
+                flip_y: atlas_sprite.flip_y,
+                handle: texture_atlas.texture.clone_weak(),
+            });
+        }
+    }
+}
+
+#[repr(C)]
+#[derive(Copy, Clone, Pod, Zeroable)]
+struct SpriteVertex {
+    pub position: [f32; 3],
+    pub uv: [f32; 2],
+}
+
+#[repr(C)]
+#[derive(Copy, Clone, Pod, Zeroable)]
+struct ColoredSpriteVertex {
+    pub position: [f32; 3],
+    pub uv: [f32; 2],
+    pub color: u32,
+}
+
+pub struct SpriteMeta {
+    vertices: BufferVec<SpriteVertex>,
+    colored_vertices: BufferVec<ColoredSpriteVertex>,
+    view_bind_group: Option<BindGroup>,
+}
+
+impl Default for SpriteMeta {
+    fn default() -> Self {
+        Self {
+            vertices: BufferVec::new(BufferUsages::VERTEX),
+            colored_vertices: BufferVec::new(BufferUsages::VERTEX),
+            view_bind_group: None,
+        }
+    }
+}
+
+const QUAD_VERTEX_POSITIONS: &[Vec3] = &[
+    const_vec3!([-0.5, -0.5, 0.0]),
+    const_vec3!([0.5, 0.5, 0.0]),
+    const_vec3!([-0.5, 0.5, 0.0]),
+    const_vec3!([-0.5, -0.5, 0.0]),
+    const_vec3!([0.5, -0.5, 0.0]),
+    const_vec3!([0.5, 0.5, 0.0]),
+];
+
+#[derive(Component)]
+pub struct SpriteBatch {
+    range: Range<u32>,
+    handle: Handle<Image>,
+    z: f32,
+    colored: bool,
+}
+
+pub fn prepare_sprites(
+    mut commands: Commands,
+    render_device: Res<RenderDevice>,
+    render_queue: Res<RenderQueue>,
+    mut sprite_meta: ResMut<SpriteMeta>,
+    mut extracted_sprites: ResMut<ExtractedSprites>,
+) {
+    sprite_meta.vertices.clear();
+    sprite_meta.colored_vertices.clear();
+
+    // sort first by z and then by handle. this ensures that, when possible, batches span multiple z layers
+    // batches won't span z-layers if there is another batch between them
+    extracted_sprites.sprites.sort_by(|a, b| {
+        match FloatOrd(a.transform.w_axis[2]).cmp(&FloatOrd(b.transform.w_axis[2])) {
+            Ordering::Equal => a.handle.cmp(&b.handle),
+            other => other,
+        }
+    });
+
+    let mut start = 0;
+    let mut end = 0;
+    let mut colored_start = 0;
+    let mut colored_end = 0;
+    let mut current_batch_handle: Option<Handle<Image>> = None;
+    let mut current_batch_colored = false;
+    let mut last_z = 0.0;
+    for extracted_sprite in extracted_sprites.sprites.iter() {
+        let colored = extracted_sprite.color != Color::WHITE;
+        if let Some(current_batch_handle) = &current_batch_handle {
+            if *current_batch_handle != extracted_sprite.handle || current_batch_colored != colored
+            {
+                if current_batch_colored {
+                    commands.spawn_bundle((SpriteBatch {
+                        range: colored_start..colored_end,
+                        handle: current_batch_handle.clone_weak(),
+                        z: last_z,
+                        colored: true,
+                    },));
+                    colored_start = colored_end;
+                } else {
+                    commands.spawn_bundle((SpriteBatch {
+                        range: start..end,
+                        handle: current_batch_handle.clone_weak(),
+                        z: last_z,
+                        colored: false,
+                    },));
+                    start = end;
+                }
+            }
+        }
+        current_batch_handle = Some(extracted_sprite.handle.clone_weak());
+        current_batch_colored = colored;
+        let sprite_rect = extracted_sprite.rect;
+
+        // Specify the corners of the sprite
+        let mut bottom_left = Vec2::new(sprite_rect.min.x, sprite_rect.max.y);
+        let mut top_left = sprite_rect.min;
+        let mut top_right = Vec2::new(sprite_rect.max.x, sprite_rect.min.y);
+        let mut bottom_right = sprite_rect.max;
+
+        if extracted_sprite.flip_x {
+            bottom_left.x = sprite_rect.max.x;
+            top_left.x = sprite_rect.max.x;
+            bottom_right.x = sprite_rect.min.x;
+            top_right.x = sprite_rect.min.x;
+        }
+
+        if extracted_sprite.flip_y {
+            bottom_left.y = sprite_rect.min.y;
+            bottom_right.y = sprite_rect.min.y;
+            top_left.y = sprite_rect.max.y;
+            top_right.y = sprite_rect.max.y;
+        }
+
+        let atlas_extent = extracted_sprite.atlas_size.unwrap_or(sprite_rect.max);
+        bottom_left /= atlas_extent;
+        bottom_right /= atlas_extent;
+        top_left /= atlas_extent;
+        top_right /= atlas_extent;
+
+        let uvs: [[f32; 2]; 6] = [
+            bottom_left.into(),
+            top_right.into(),
+            top_left.into(),
+            bottom_left.into(),
+            bottom_right.into(),
+            top_right.into(),
+        ];
+
+        let rect_size = extracted_sprite.rect.size().extend(1.0);
+        if current_batch_colored {
+            let color = extracted_sprite.color.as_linear_rgba_f32();
+            // encode color as a single u32 to save space
+            let color = (color[0] * 255.0) as u32
+                | ((color[1] * 255.0) as u32) << 8
+                | ((color[2] * 255.0) as u32) << 16
+                | ((color[3] * 255.0) as u32) << 24;
+            for (index, vertex_position) in QUAD_VERTEX_POSITIONS.iter().enumerate() {
+                let mut final_position = *vertex_position * rect_size;
+                final_position = (extracted_sprite.transform * final_position.extend(1.0)).xyz();
+                sprite_meta.colored_vertices.push(ColoredSpriteVertex {
+                    position: final_position.into(),
+                    uv: uvs[index],
+                    color,
+                });
+            }
+        } else {
+            for (index, vertex_position) in QUAD_VERTEX_POSITIONS.iter().enumerate() {
+                let mut final_position = *vertex_position * rect_size;
+                final_position = (extracted_sprite.transform * final_position.extend(1.0)).xyz();
+                sprite_meta.vertices.push(SpriteVertex {
+                    position: final_position.into(),
+                    uv: uvs[index],
+                });
+            }
+        }
+
+        last_z = extracted_sprite.transform.w_axis[2];
+        if current_batch_colored {
+            colored_end += QUAD_VERTEX_POSITIONS.len() as u32;
+        } else {
+            end += QUAD_VERTEX_POSITIONS.len() as u32;
+        }
+    }
+
+    // if start != end, there is one last batch to process
+    if start != end {
+        if let Some(current_batch_handle) = current_batch_handle {
+            commands.spawn_bundle((SpriteBatch {
+                range: start..end,
+                handle: current_batch_handle,
+                colored: false,
+                z: last_z,
+            },));
+        }
+    } else if colored_start != colored_end {
+        if let Some(current_batch_handle) = current_batch_handle {
+            commands.spawn_bundle((SpriteBatch {
+                range: colored_start..colored_end,
+                handle: current_batch_handle,
+                colored: true,
+                z: last_z,
+            },));
+        }
+    }
+
+    sprite_meta
+        .vertices
+        .write_buffer(&render_device, &render_queue);
+    sprite_meta
+        .colored_vertices
+        .write_buffer(&render_device, &render_queue);
+}
+
+#[derive(Default)]
+pub struct ImageBindGroups {
+    values: HashMap<Handle<Image>, BindGroup>,
+}
+
+#[allow(clippy::too_many_arguments)]
+pub fn queue_sprites(
+    draw_functions: Res<DrawFunctions<Transparent2d>>,
+    render_device: Res<RenderDevice>,
+    mut sprite_meta: ResMut<SpriteMeta>,
+    view_uniforms: Res<ViewUniforms>,
+    sprite_pipeline: Res<SpritePipeline>,
+    mut pipelines: ResMut<SpecializedPipelines<SpritePipeline>>,
+    mut pipeline_cache: ResMut<RenderPipelineCache>,
+    mut image_bind_groups: ResMut<ImageBindGroups>,
+    gpu_images: Res<RenderAssets<Image>>,
+    mut sprite_batches: Query<(Entity, &SpriteBatch)>,
+    mut views: Query<&mut RenderPhase<Transparent2d>>,
+) {
+    if let Some(view_binding) = view_uniforms.uniforms.binding() {
+        sprite_meta.view_bind_group = Some(render_device.create_bind_group(&BindGroupDescriptor {
+            entries: &[BindGroupEntry {
+                binding: 0,
+                resource: view_binding,
+            }],
+            label: Some("sprite_view_bind_group"),
+            layout: &sprite_pipeline.view_layout,
+        }));
+        let draw_sprite_function = draw_functions.read().get_id::<DrawSprite>().unwrap();
+        let pipeline = pipelines.specialize(
+            &mut pipeline_cache,
+            &sprite_pipeline,
+            SpritePipelineKey { colored: false },
+        );
+        let colored_pipeline = pipelines.specialize(
+            &mut pipeline_cache,
+            &sprite_pipeline,
+            SpritePipelineKey { colored: true },
+        );
+        for mut transparent_phase in views.iter_mut() {
+            for (entity, batch) in sprite_batches.iter_mut() {
+                image_bind_groups
+                    .values
+                    .entry(batch.handle.clone_weak())
+                    .or_insert_with(|| {
+                        let gpu_image = gpu_images.get(&batch.handle).unwrap();
+                        render_device.create_bind_group(&BindGroupDescriptor {
+                            entries: &[
+                                BindGroupEntry {
+                                    binding: 0,
+                                    resource: BindingResource::TextureView(&gpu_image.texture_view),
+                                },
+                                BindGroupEntry {
+                                    binding: 1,
+                                    resource: BindingResource::Sampler(&gpu_image.sampler),
+                                },
+                            ],
+                            label: Some("sprite_material_bind_group"),
+                            layout: &sprite_pipeline.material_layout,
+                        })
+                    });
+                transparent_phase.add(Transparent2d {
+                    draw_function: draw_sprite_function,
+                    pipeline: if batch.colored {
+                        colored_pipeline
+                    } else {
+                        pipeline
+                    },
+                    entity,
+                    sort_key: FloatOrd(batch.z),
+                });
+            }
+        }
+    }
+}
+
+pub struct DrawSprite {
+    params: SystemState<(
+        SRes<SpriteMeta>,
+        SRes<ImageBindGroups>,
+        SRes<RenderPipelineCache>,
+        SQuery<Read<ViewUniformOffset>>,
+        SQuery<Read<SpriteBatch>>,
+    )>,
+}
+
+impl DrawSprite {
+    pub fn new(world: &mut World) -> Self {
+        Self {
+            params: SystemState::new(world),
+        }
+    }
+}
+
+impl Draw<Transparent2d> for DrawSprite {
+    fn draw<'w>(
+        &mut self,
+        world: &'w World,
+        pass: &mut TrackedRenderPass<'w>,
+        view: Entity,
+        item: &Transparent2d,
+    ) {
+        let (sprite_meta, image_bind_groups, pipelines, views, sprites) = self.params.get(world);
+        let view_uniform = views.get(view).unwrap();
+        let sprite_meta = sprite_meta.into_inner();
+        let image_bind_groups = image_bind_groups.into_inner();
+        let sprite_batch = sprites.get(item.entity).unwrap();
+        if let Some(pipeline) = pipelines.into_inner().get(item.pipeline) {
+            pass.set_render_pipeline(pipeline);
+            if sprite_batch.colored {
+                pass.set_vertex_buffer(0, sprite_meta.colored_vertices.buffer().unwrap().slice(..));
+            } else {
+                pass.set_vertex_buffer(0, sprite_meta.vertices.buffer().unwrap().slice(..));
+            }
+            pass.set_bind_group(
+                0,
+                sprite_meta.view_bind_group.as_ref().unwrap(),
+                &[view_uniform.offset],
+            );
+            pass.set_bind_group(
+                1,
+                image_bind_groups.values.get(&sprite_batch.handle).unwrap(),
+                &[],
+            );
+
+            pass.draw(sprite_batch.range.clone(), 0..1);
+        }
+    }
+}
diff --git a/pipelined/bevy_sprite2/src/render/sprite.wgsl b/pipelined/bevy_sprite2/src/render/sprite.wgsl
new file mode 100644
index 0000000000..e331817950
--- /dev/null
+++ b/pipelined/bevy_sprite2/src/render/sprite.wgsl
@@ -0,0 +1,46 @@
+[[block]]
+struct View {
+    view_proj: mat4x4<f32>;
+    world_position: vec3<f32>;
+};
+[[group(0), binding(0)]]
+var<uniform> view: View;
+
+struct VertexOutput {
+    [[location(0)]] uv: vec2<f32>;
+#ifdef COLORED
+    [[location(1)]] color: vec4<f32>;
+#endif
+    [[builtin(position)]] position: vec4<f32>;
+};
+
+[[stage(vertex)]]
+fn vertex(
+    [[location(0)]] vertex_position: vec3<f32>,
+    [[location(1)]] vertex_uv: vec2<f32>,
+#ifdef COLORED
+    [[location(2)]] vertex_color: u32,
+#endif
+) -> VertexOutput {
+    var out: VertexOutput;
+    out.uv = vertex_uv;
+    out.position = view.view_proj * vec4<f32>(vertex_position, 1.0);
+#ifdef COLORED
+    out.color = vec4<f32>((vec4<u32>(vertex_color) >> vec4<u32>(0u, 8u, 16u, 24u)) & vec4<u32>(255u)) / 255.0;
+#endif
+    return out;
+} 
+
+[[group(1), binding(0)]]
+var sprite_texture: texture_2d<f32>;
+[[group(1), binding(1)]]
+var sprite_sampler: sampler;
+
+[[stage(fragment)]]
+fn fragment(in: VertexOutput) -> [[location(0)]] vec4<f32> {
+    var color = textureSample(sprite_texture, sprite_sampler, in.uv); 
+#ifdef COLORED
+    color = in.color * color;
+#endif
+    return color;
+}
\ No newline at end of file
diff --git a/pipelined/bevy_sprite2/src/sprite.rs b/pipelined/bevy_sprite2/src/sprite.rs
new file mode 100644
index 0000000000..24b6e58d29
--- /dev/null
+++ b/pipelined/bevy_sprite2/src/sprite.rs
@@ -0,0 +1,19 @@
+use bevy_ecs::component::Component;
+use bevy_math::Vec2;
+use bevy_reflect::{Reflect, TypeUuid};
+use bevy_render2::color::Color;
+
+#[derive(Component, Debug, Default, Clone, TypeUuid, Reflect)]
+#[uuid = "7233c597-ccfa-411f-bd59-9af349432ada"]
+#[repr(C)]
+pub struct Sprite {
+    /// The sprite's color tint
+    pub color: Color,
+    /// Flip the sprite along the X axis
+    pub flip_x: bool,
+    /// Flip the sprite along the Y axis
+    pub flip_y: bool,
+    /// An optional custom size for the sprite that will be used when rendering, instead of the size
+    /// of the sprite's image
+    pub custom_size: Option<Vec2>,
+}
diff --git a/pipelined/bevy_sprite2/src/texture_atlas.rs b/pipelined/bevy_sprite2/src/texture_atlas.rs
new file mode 100644
index 0000000000..78886a279c
--- /dev/null
+++ b/pipelined/bevy_sprite2/src/texture_atlas.rs
@@ -0,0 +1,148 @@
+use crate::Rect;
+use bevy_asset::Handle;
+use bevy_ecs::component::Component;
+use bevy_math::Vec2;
+use bevy_reflect::{Reflect, TypeUuid};
+use bevy_render2::{color::Color, texture::Image};
+use bevy_utils::HashMap;
+
+/// An atlas containing multiple textures (like a spritesheet or a tilemap).
+/// [Example usage animating sprite.](https://github.com/bevyengine/bevy/blob/latest/examples/2d/sprite_sheet.rs)
+/// [Example usage loading sprite sheet.](https://github.com/bevyengine/bevy/blob/latest/examples/2d/texture_atlas.rs)
+#[derive(Debug, Clone, TypeUuid)]
+#[uuid = "7233c597-ccfa-411f-bd59-9af349432ada"]
+pub struct TextureAtlas {
+    /// The handle to the texture in which the sprites are stored
+    pub texture: Handle<Image>,
+    // TODO: add support to Uniforms derive to write dimensions and sprites to the same buffer
+    pub size: Vec2,
+    /// The specific areas of the atlas where each texture can be found
+    pub textures: Vec<Rect>,
+    pub texture_handles: Option<HashMap<Handle<Image>, usize>>,
+}
+
+#[derive(Component, Debug, Clone, TypeUuid, Reflect)]
+#[uuid = "7233c597-ccfa-411f-bd59-9af349432ada"]
+pub struct TextureAtlasSprite {
+    pub color: Color,
+    pub index: usize,
+    pub flip_x: bool,
+    pub flip_y: bool,
+}
+
+impl Default for TextureAtlasSprite {
+    fn default() -> Self {
+        Self {
+            index: 0,
+            color: Color::WHITE,
+            flip_x: false,
+            flip_y: false,
+        }
+    }
+}
+
+impl TextureAtlasSprite {
+    pub fn new(index: usize) -> TextureAtlasSprite {
+        Self {
+            index,
+            ..Default::default()
+        }
+    }
+}
+
+impl TextureAtlas {
+    /// Create a new `TextureAtlas` that has a texture, but does not have
+    /// any individual sprites specified
+    pub fn new_empty(texture: Handle<Image>, dimensions: Vec2) -> Self {
+        Self {
+            texture,
+            size: dimensions,
+            texture_handles: None,
+            textures: Vec::new(),
+        }
+    }
+
+    /// Generate a `TextureAtlas` by splitting a texture into a grid where each
+    /// cell of the grid  of `tile_size` is one of the textures in the atlas
+    pub fn from_grid(
+        texture: Handle<Image>,
+        tile_size: Vec2,
+        columns: usize,
+        rows: usize,
+    ) -> TextureAtlas {
+        Self::from_grid_with_padding(texture, tile_size, columns, rows, Vec2::new(0f32, 0f32))
+    }
+
+    /// Generate a `TextureAtlas` by splitting a texture into a grid where each
+    /// cell of the grid of `tile_size` is one of the textures in the atlas and is separated by
+    /// some `padding` in the texture
+    pub fn from_grid_with_padding(
+        texture: Handle<Image>,
+        tile_size: Vec2,
+        columns: usize,
+        rows: usize,
+        padding: Vec2,
+    ) -> TextureAtlas {
+        let mut sprites = Vec::new();
+        let mut x_padding = 0.0;
+        let mut y_padding = 0.0;
+
+        for y in 0..rows {
+            if y > 0 {
+                y_padding = padding.y;
+            }
+            for x in 0..columns {
+                if x > 0 {
+                    x_padding = padding.x;
+                }
+
+                let rect_min = Vec2::new(
+                    (tile_size.x + x_padding) * x as f32,
+                    (tile_size.y + y_padding) * y as f32,
+                );
+
+                sprites.push(Rect {
+                    min: rect_min,
+                    max: Vec2::new(rect_min.x + tile_size.x, rect_min.y + tile_size.y),
+                })
+            }
+        }
+
+        TextureAtlas {
+            size: Vec2::new(
+                ((tile_size.x + x_padding) * columns as f32) - x_padding,
+                ((tile_size.y + y_padding) * rows as f32) - y_padding,
+            ),
+            textures: sprites,
+            texture,
+            texture_handles: None,
+        }
+    }
+
+    /// Add a sprite to the list of textures in the `TextureAtlas`
+    /// returns an index to the texture which can be used with `TextureAtlasSprite`
+    ///
+    /// # Arguments
+    ///
+    /// * `rect` - The section of the atlas that contains the texture to be added,
+    /// from the top-left corner of the texture to the bottom-right corner
+    pub fn add_texture(&mut self, rect: Rect) -> usize {
+        self.textures.push(rect);
+        self.textures.len() - 1
+    }
+
+    /// How many textures are in the `TextureAtlas`
+    pub fn len(&self) -> usize {
+        self.textures.len()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.textures.is_empty()
+    }
+
+    pub fn get_texture_index(&self, texture: &Handle<Image>) -> Option<usize> {
+        self.texture_handles
+            .as_ref()
+            .and_then(|texture_handles| texture_handles.get(texture).cloned())
+    }
+}
diff --git a/pipelined/bevy_sprite2/src/texture_atlas_builder.rs b/pipelined/bevy_sprite2/src/texture_atlas_builder.rs
new file mode 100644
index 0000000000..d89389e910
--- /dev/null
+++ b/pipelined/bevy_sprite2/src/texture_atlas_builder.rs
@@ -0,0 +1,239 @@
+use bevy_asset::{Assets, Handle};
+use bevy_log::{debug, error, warn};
+use bevy_math::Vec2;
+use bevy_render2::{
+    render_resource::{Extent3d, TextureDimension, TextureFormat},
+    texture::{Image, TextureFormatPixelInfo},
+};
+use bevy_utils::HashMap;
+use rectangle_pack::{
+    contains_smallest_box, pack_rects, volume_heuristic, GroupedRectsToPlace, PackedLocation,
+    RectToInsert, TargetBin,
+};
+use thiserror::Error;
+
+use crate::{texture_atlas::TextureAtlas, Rect};
+
+#[derive(Debug, Error)]
+pub enum TextureAtlasBuilderError {
+    #[error("could not pack textures into an atlas within the given bounds")]
+    NotEnoughSpace,
+    #[error("added a texture with the wrong format in an atlas")]
+    WrongFormat,
+}
+
+#[derive(Debug)]
+/// A builder which is used to create a texture atlas from many individual
+/// sprites.
+pub struct TextureAtlasBuilder {
+    /// The grouped rects which must be placed with a key value pair of a
+    /// texture handle to an index.
+    rects_to_place: GroupedRectsToPlace<Handle<Image>>,
+    /// The initial atlas size in pixels.
+    initial_size: Vec2,
+    /// The absolute maximum size of the texture atlas in pixels.
+    max_size: Vec2,
+    /// The texture format for the textures that will be loaded in the atlas.
+    format: TextureFormat,
+    /// Enable automatic format conversion for textures if they are not in the atlas format.
+    auto_format_conversion: bool,
+}
+
+impl Default for TextureAtlasBuilder {
+    fn default() -> Self {
+        Self {
+            rects_to_place: GroupedRectsToPlace::new(),
+            initial_size: Vec2::new(256., 256.),
+            max_size: Vec2::new(2048., 2048.),
+            format: TextureFormat::Rgba8UnormSrgb,
+            auto_format_conversion: true,
+        }
+    }
+}
+
+pub type TextureAtlasBuilderResult<T> = Result<T, TextureAtlasBuilderError>;
+
+impl TextureAtlasBuilder {
+    /// Sets the initial size of the atlas in pixels.
+    pub fn initial_size(mut self, size: Vec2) -> Self {
+        self.initial_size = size;
+        self
+    }
+
+    /// Sets the max size of the atlas in pixels.
+    pub fn max_size(mut self, size: Vec2) -> Self {
+        self.max_size = size;
+        self
+    }
+
+    /// Sets the texture format for textures in the atlas.
+    pub fn format(mut self, format: TextureFormat) -> Self {
+        self.format = format;
+        self
+    }
+
+    /// Control whether the added texture should be converted to the atlas format, if different.
+    pub fn auto_format_conversion(mut self, auto_format_conversion: bool) -> Self {
+        self.auto_format_conversion = auto_format_conversion;
+        self
+    }
+
+    /// Adds a texture to be copied to the texture atlas.
+    pub fn add_texture(&mut self, texture_handle: Handle<Image>, texture: &Image) {
+        self.rects_to_place.push_rect(
+            texture_handle,
+            None,
+            RectToInsert::new(
+                texture.texture_descriptor.size.width,
+                texture.texture_descriptor.size.height,
+                1,
+            ),
+        )
+    }
+
+    fn copy_texture_to_atlas(
+        atlas_texture: &mut Image,
+        texture: &Image,
+        packed_location: &PackedLocation,
+    ) {
+        let rect_width = packed_location.width() as usize;
+        let rect_height = packed_location.height() as usize;
+        let rect_x = packed_location.x() as usize;
+        let rect_y = packed_location.y() as usize;
+        let atlas_width = atlas_texture.texture_descriptor.size.width as usize;
+        let format_size = atlas_texture.texture_descriptor.format.pixel_size();
+
+        for (texture_y, bound_y) in (rect_y..rect_y + rect_height).enumerate() {
+            let begin = (bound_y * atlas_width + rect_x) * format_size;
+            let end = begin + rect_width * format_size;
+            let texture_begin = texture_y * rect_width * format_size;
+            let texture_end = texture_begin + rect_width * format_size;
+            atlas_texture.data[begin..end]
+                .copy_from_slice(&texture.data[texture_begin..texture_end]);
+        }
+    }
+
+    fn copy_converted_texture(
+        &self,
+        atlas_texture: &mut Image,
+        texture: &Image,
+        packed_location: &PackedLocation,
+    ) {
+        if self.format == texture.texture_descriptor.format {
+            Self::copy_texture_to_atlas(atlas_texture, texture, packed_location);
+        } else if let Some(converted_texture) = texture.convert(self.format) {
+            debug!(
+                "Converting texture from '{:?}' to '{:?}'",
+                texture.texture_descriptor.format, self.format
+            );
+            Self::copy_texture_to_atlas(atlas_texture, &converted_texture, packed_location);
+        } else {
+            error!(
+                "Error converting texture from '{:?}' to '{:?}', ignoring",
+                texture.texture_descriptor.format, self.format
+            );
+        }
+    }
+
+    /// Consumes the builder and returns a result with a new texture atlas.
+    ///
+    /// Internally it copies all rectangles from the textures and copies them
+    /// into a new texture which the texture atlas will use. It is not useful to
+    /// hold a strong handle to the texture afterwards else it will exist twice
+    /// in memory.
+    ///
+    /// # Errors
+    ///
+    /// If there is not enough space in the atlas texture, an error will
+    /// be returned. It is then recommended to make a larger sprite sheet.
+    pub fn finish(
+        self,
+        textures: &mut Assets<Image>,
+    ) -> Result<TextureAtlas, TextureAtlasBuilderError> {
+        let initial_width = self.initial_size.x as u32;
+        let initial_height = self.initial_size.y as u32;
+        let max_width = self.max_size.x as u32;
+        let max_height = self.max_size.y as u32;
+
+        let mut current_width = initial_width;
+        let mut current_height = initial_height;
+        let mut rect_placements = None;
+        let mut atlas_texture = Image::default();
+
+        while rect_placements.is_none() {
+            if current_width > max_width || current_height > max_height {
+                break;
+            }
+
+            let last_attempt = current_height == max_height && current_width == max_width;
+
+            let mut target_bins = std::collections::BTreeMap::new();
+            target_bins.insert(0, TargetBin::new(current_width, current_height, 1));
+            rect_placements = match pack_rects(
+                &self.rects_to_place,
+                &mut target_bins,
+                &volume_heuristic,
+                &contains_smallest_box,
+            ) {
+                Ok(rect_placements) => {
+                    atlas_texture = Image::new(
+                        Extent3d {
+                            width: current_width,
+                            height: current_height,
+                            depth_or_array_layers: 1,
+                        },
+                        TextureDimension::D2,
+                        vec![
+                            0;
+                            self.format.pixel_size() * (current_width * current_height) as usize
+                        ],
+                        self.format,
+                    );
+                    Some(rect_placements)
+                }
+                Err(rectangle_pack::RectanglePackError::NotEnoughBinSpace) => {
+                    current_height = (current_height * 2).clamp(0, max_height);
+                    current_width = (current_width * 2).clamp(0, max_width);
+                    None
+                }
+            };
+
+            if last_attempt {
+                break;
+            }
+        }
+
+        let rect_placements = rect_placements.ok_or(TextureAtlasBuilderError::NotEnoughSpace)?;
+
+        let mut texture_rects = Vec::with_capacity(rect_placements.packed_locations().len());
+        let mut texture_handles = HashMap::default();
+        for (texture_handle, (_, packed_location)) in rect_placements.packed_locations().iter() {
+            let texture = textures.get(texture_handle).unwrap();
+            let min = Vec2::new(packed_location.x() as f32, packed_location.y() as f32);
+            let max = min
+                + Vec2::new(
+                    packed_location.width() as f32,
+                    packed_location.height() as f32,
+                );
+            texture_handles.insert(texture_handle.clone_weak(), texture_rects.len());
+            texture_rects.push(Rect { min, max });
+            if texture.texture_descriptor.format != self.format && !self.auto_format_conversion {
+                warn!(
+                    "Loading a texture of format '{:?}' in an atlas with format '{:?}'",
+                    texture.texture_descriptor.format, self.format
+                );
+                return Err(TextureAtlasBuilderError::WrongFormat);
+            }
+            self.copy_converted_texture(&mut atlas_texture, texture, packed_location);
+        }
+        Ok(TextureAtlas {
+            size: Vec2::new(
+                atlas_texture.texture_descriptor.size.width as f32,
+                atlas_texture.texture_descriptor.size.height as f32,
+            ),
+            texture: textures.add(atlas_texture),
+            textures: texture_rects,
+            texture_handles: Some(texture_handles),
+        })
+    }
+}