diff --git a/Cargo.toml b/Cargo.toml
index f95b76f75a..fc872217a3 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -17,7 +17,7 @@ repository = "https://github.com/bevyengine/bevy"
 
 [workspace]
 exclude = ["benches"]
-members = ["crates/*", "examples/ios", "tools/ci"]
+members = ["crates/*", "pipelined/*", "examples/ios", "tools/ci"]
 
 [features]
 default = [
@@ -26,6 +26,9 @@ default = [
   "bevy_gilrs",
   "bevy_gltf",
   "bevy_wgpu",
+  "bevy_wgpu2",
+  "bevy_sprite2",
+  "bevy_render2",
   "bevy_winit",
   "render",
   "png",
@@ -48,6 +51,10 @@ bevy_gltf = ["bevy_internal/bevy_gltf"]
 bevy_wgpu = ["bevy_internal/bevy_wgpu"]
 bevy_winit = ["bevy_internal/bevy_winit"]
 
+bevy_wgpu2 = ["bevy_internal/bevy_wgpu2"]
+bevy_render2 = ["bevy_internal/bevy_render2"]
+bevy_sprite2 = ["bevy_internal/bevy_sprite2"]
+
 trace_chrome = ["bevy_internal/trace_chrome"]
 trace = ["bevy_internal/trace"]
 wgpu_trace = ["bevy_internal/wgpu_trace"]
@@ -419,6 +426,10 @@ path = "examples/shader/shader_defs.rs"
 name = "bevymark"
 path = "examples/tools/bevymark.rs"
 
+[[example]]
+name = "bevymark_pipelined"
+path = "examples/tools/bevymark_pipelined.rs"
+
 # UI (User Interface)
 [[example]]
 name = "button"
diff --git a/crates/bevy_app/src/app.rs b/crates/bevy_app/src/app.rs
index d30303a4ac..c7a400ad34 100644
--- a/crates/bevy_app/src/app.rs
+++ b/crates/bevy_app/src/app.rs
@@ -1,10 +1,19 @@
-use crate::app_builder::AppBuilder;
+use crate::{CoreStage, Events, Plugin, PluginGroup, PluginGroupBuilder, StartupStage};
 use bevy_ecs::{
-    schedule::{Schedule, Stage},
+    component::{Component, ComponentDescriptor},
+    prelude::{FromWorld, IntoExclusiveSystem, IntoSystem},
+    schedule::{
+        RunOnce, Schedule, Stage, StageLabel, State, SystemDescriptor, SystemSet, SystemStage,
+    },
     world::World,
 };
+use bevy_utils::tracing::debug;
+use std::{fmt::Debug, hash::Hash};
+
 #[cfg(feature = "trace")]
 use bevy_utils::tracing::info_span;
+use std::fmt::Debug;
+use std::hash::Hash;
 
 #[allow(clippy::needless_doctest_main)]
 /// Containers of app logic and data
@@ -20,7 +29,7 @@ use bevy_utils::tracing::info_span;
 /// # use bevy_ecs::prelude::*;
 ///
 /// fn main() {
-///    App::build()
+///    App::new()
 ///        .add_system(hello_world_system.system())
 ///        .run();
 /// }
@@ -33,26 +42,46 @@ pub struct App {
     pub world: World,
     pub runner: Box<dyn Fn(App)>,
     pub schedule: Schedule,
+    sub_apps: Vec<SubApp>,
+}
+
+struct SubApp {
+    app: App,
+    runner: Box<dyn Fn(&mut World, &mut App)>,
 }
 
 impl Default for App {
     fn default() -> Self {
+        let mut app = App::empty();
+        #[cfg(feature = "bevy_reflect")]
+        app.init_resource::<bevy_reflect::TypeRegistryArc>();
+
+        app.add_default_stages()
+            .add_event::<AppExit>()
+            .add_system_to_stage(CoreStage::Last, World::clear_trackers.exclusive_system());
+
+        #[cfg(feature = "bevy_ci_testing")]
+        {
+            crate::ci_testing::setup_app(&mut app);
+        }
+
+        app
+    }
+}
+
+impl App {
+    pub fn new() -> App {
+        App::default()
+    }
+
+    pub fn empty() -> App {
         Self {
             world: Default::default(),
             schedule: Default::default(),
             runner: Box::new(run_once),
+            sub_apps: Vec::new(),
         }
     }
-}
-
-fn run_once(mut app: App) {
-    app.update();
-}
-
-impl App {
-    pub fn build() -> AppBuilder {
-        AppBuilder::default()
-    }
 
     pub fn update(&mut self) {
         #[cfg(feature = "trace")]
@@ -60,17 +89,528 @@ 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.iter_mut() {
+            (sub_app.runner)(&mut self.world, &mut sub_app.app);
+        }
     }
 
-    pub fn run(mut self) {
+    /// Start the application (through main runner)
+    ///
+    /// Runs the application main loop.
+    ///
+    /// Usually the main loop is handled by Bevy integrated plugins (`winit`), but
+    /// but one can also set the runner function through [`App::set_runner`].
+    ///
+    /// ## Example
+    /// ```
+    /// # use bevy_app::prelude::*;
+    /// #
+    /// App::new()
+    ///     // all required plugin insertions, systems, etc inserted here
+    ///     // finally, call:
+    ///     .run();
+    /// ```
+    pub fn run(&mut self) {
         #[cfg(feature = "trace")]
         let bevy_app_run_span = info_span!("bevy_app");
         #[cfg(feature = "trace")]
         let _bevy_app_run_guard = bevy_app_run_span.enter();
 
-        let runner = std::mem::replace(&mut self.runner, Box::new(run_once));
-        (runner)(self);
+        let mut app = std::mem::replace(self, App::empty());
+        let runner = std::mem::replace(&mut app.runner, Box::new(run_once));
+        (runner)(app);
     }
+
+    pub fn add_stage<S: Stage>(&mut self, label: impl StageLabel, stage: S) -> &mut Self {
+        self.schedule.add_stage(label, stage);
+        self
+    }
+
+    pub fn add_stage_after<S: Stage>(
+        &mut self,
+        target: impl StageLabel,
+        label: impl StageLabel,
+        stage: S,
+    ) -> &mut Self {
+        self.schedule.add_stage_after(target, label, stage);
+        self
+    }
+
+    pub fn add_stage_before<S: Stage>(
+        &mut self,
+        target: impl StageLabel,
+        label: impl StageLabel,
+        stage: S,
+    ) -> &mut Self {
+        self.schedule.add_stage_before(target, label, stage);
+        self
+    }
+
+    pub fn add_startup_stage<S: Stage>(&mut self, label: impl StageLabel, stage: S) -> &mut Self {
+        self.schedule
+            .stage(CoreStage::Startup, |schedule: &mut Schedule| {
+                schedule.add_stage(label, stage)
+            });
+        self
+    }
+
+    pub fn add_startup_stage_after<S: Stage>(
+        &mut self,
+        target: impl StageLabel,
+        label: impl StageLabel,
+        stage: S,
+    ) -> &mut Self {
+        self.schedule
+            .stage(CoreStage::Startup, |schedule: &mut Schedule| {
+                schedule.add_stage_after(target, label, stage)
+            });
+        self
+    }
+
+    pub fn add_startup_stage_before<S: Stage>(
+        &mut self,
+        target: impl StageLabel,
+        label: impl StageLabel,
+        stage: S,
+    ) -> &mut Self {
+        self.schedule
+            .stage(CoreStage::Startup, |schedule: &mut Schedule| {
+                schedule.add_stage_before(target, label, stage)
+            });
+        self
+    }
+
+    pub fn stage<T: Stage, F: FnOnce(&mut T) -> &mut T>(
+        &mut self,
+        label: impl StageLabel,
+        func: F,
+    ) -> &mut Self {
+        self.schedule.stage(label, func);
+        self
+    }
+
+    /// Adds a system that runs every time `app.update()` is called by the runner
+    ///
+    /// Systems are the main building block in the Bevy ECS app model. You can define
+    /// normal rust functions, and call `.system()` to make them be Bevy systems.
+    ///
+    /// System functions can have parameters, through which one can query and
+    /// mutate Bevy ECS states.
+    /// See [The Bevy Book](https://bevyengine.org/learn/book/introduction/) for more information.
+    ///
+    /// Systems are run in parallel, and the execution order is not deterministic.
+    /// If you want more fine-grained control for order, see [`App::add_system_to_stage`].
+    ///
+    /// For adding a system that runs only at app startup, see [`App::add_startup_system`].
+    ///
+    /// ## Example
+    /// ```
+    /// # use bevy_app::prelude::*;
+    /// # use bevy_ecs::prelude::*;
+    /// #
+    /// fn my_system(_commands: Commands) {
+    ///     println!("My system, triggered once per frame");
+    /// }
+    ///
+    /// App::new()
+    ///     .add_system(my_system.system());
+    /// ```
+    pub fn add_system<Params>(&mut self, system: impl IntoSystemDescriptor<Params>) -> &mut Self {
+        self.add_system_to_stage(CoreStage::Update, system)
+    }
+
+    pub fn add_system_set(&mut self, system_set: SystemSet) -> &mut Self {
+        self.add_system_set_to_stage(CoreStage::Update, system_set)
+    }
+
+    pub fn add_system_to_stage<Params>(
+        &mut self,
+        stage_label: impl StageLabel,
+        system: impl IntoSystemDescriptor<Params>,
+    ) -> &mut Self {
+        self.schedule.add_system_to_stage(stage_label, system);
+        self
+    }
+
+    pub fn add_system_set_to_stage(
+        &mut self,
+        stage_label: impl StageLabel,
+        system_set: SystemSet,
+    ) -> &mut Self {
+        self.schedule
+            .add_system_set_to_stage(stage_label, system_set);
+        self
+    }
+
+    /// Adds a system that is run once at application startup
+    ///
+    /// Startup systems run exactly once BEFORE all other systems. These are generally used for
+    /// app initialization code (ex: adding entities and resources).
+    ///
+    /// * For adding a system that runs for every frame, see [`App::add_system`].
+    /// * For adding a system to specific stage, see [`App::add_system_to_stage`].
+    ///
+    /// ## Example
+    /// ```
+    /// # use bevy_app::prelude::*;
+    /// # use bevy_ecs::prelude::*;
+    /// #
+    /// fn my_startup_system(_commands: Commands) {
+    ///     println!("My startup system");
+    /// }
+    ///
+    /// App::new()
+    ///     .add_startup_system(my_startup_system.system());
+    /// ```
+    pub fn add_startup_system<Params>(
+        &mut self,
+        system: impl IntoSystemDescriptor<Params>,
+    ) -> &mut Self {
+        self.add_startup_system_to_stage(StartupStage::Startup, system)
+    }
+
+    pub fn add_startup_system_set(&mut self, system_set: SystemSet) -> &mut Self {
+        self.add_startup_system_set_to_stage(StartupStage::Startup, system_set)
+    }
+
+    pub fn add_startup_system_to_stage<Params>(
+        &mut self,
+        stage_label: impl StageLabel,
+        system: impl IntoSystemDescriptor<Params>,
+    ) -> &mut Self {
+        self.app
+            .schedule
+            .stage(CoreStage::Startup, |schedule: &mut Schedule| {
+                schedule.add_system_to_stage(stage_label, system)
+            });
+        self
+    }
+
+    pub fn add_startup_system_set_to_stage(
+        &mut self,
+        stage_label: impl StageLabel,
+        system_set: SystemSet,
+    ) -> &mut Self {
+        self.app
+            .schedule
+            .stage(CoreStage::Startup, |schedule: &mut Schedule| {
+                schedule.add_system_set_to_stage(stage_label, system_set)
+            });
+        self
+    }
+
+    /// Adds a new [State] with the given `initial` value.
+    /// This inserts a new `State<T>` resource and adds a new "driver" to [CoreStage::Update].
+    /// Each stage that uses `State<T>` for system run criteria needs a driver. If you need to use
+    /// your state in a different stage, consider using [Self::add_state_to_stage] or manually
+    /// adding [State::get_driver] to additional stages you need it in.
+    pub fn add_state<T>(&mut self, initial: T) -> &mut Self
+    where
+        T: Component + Debug + Clone + Eq + Hash,
+    {
+        self.add_state_to_stage(CoreStage::Update, initial)
+    }
+
+    /// Adds a new [State] with the given `initial` value.
+    /// This inserts a new `State<T>` resource and adds a new "driver" to the given stage.
+    /// Each stage that uses `State<T>` for system run criteria needs a driver. If you need to use
+    /// your state in more than one stage, consider manually adding [State::get_driver] to the
+    /// stages you need it in.
+    pub fn add_state_to_stage<T>(&mut self, stage: impl StageLabel, initial: T) -> &mut Self
+    where
+        T: Component + Debug + Clone + Eq + Hash,
+    {
+        self.insert_resource(State::new(initial))
+            .add_system_set_to_stage(stage, State::<T>::get_driver())
+    }
+
+    pub fn add_default_stages(&mut self) -> &mut Self {
+        self.add_stage(CoreStage::First, SystemStage::parallel())
+            .add_stage(
+                CoreStage::Startup,
+                Schedule::default()
+                    .with_run_criteria(RunOnce::default())
+                    .with_stage(StartupStage::PreStartup, SystemStage::parallel())
+                    .with_stage(StartupStage::Startup, SystemStage::parallel())
+                    .with_stage(StartupStage::PostStartup, SystemStage::parallel()),
+            )
+            .add_stage(CoreStage::PreUpdate, SystemStage::parallel())
+            .add_stage(CoreStage::Update, SystemStage::parallel())
+            .add_stage(CoreStage::PostUpdate, SystemStage::parallel())
+            .add_stage(CoreStage::Last, SystemStage::parallel())
+    }
+
+    /// Setup the application to manage events of type `T`.
+    ///
+    /// This is done by adding a `Resource` of type `Events::<T>`,
+    /// and inserting a `Events::<T>::update_system` system into `CoreStage::First`.
+    pub fn add_event<T>(&mut self) -> &mut Self
+    where
+        T: Component,
+    {
+        self.insert_resource(Events::<T>::default())
+            .add_system_to_stage(CoreStage::First, Events::<T>::update_system.system())
+    }
+
+    /// Inserts a resource to the current [App] and overwrites any resource previously added of the same type.
+    ///
+    /// A resource in Bevy represents globally unique data. Resources must be added to Bevy Apps
+    /// before using them. This happens with [`App::insert_resource`].
+    ///
+    /// See also `init_resource` for resources that implement `Default` or [`FromResources`].
+    ///
+    /// ## Example
+    /// ```
+    /// # use bevy_app::prelude::*;
+    /// #
+    /// struct MyCounter {
+    ///     counter: usize,
+    /// }
+    ///
+    /// App::new()
+    ///    .insert_resource(MyCounter { counter: 0 });
+    /// ```
+    pub fn insert_resource<T>(&mut self, resource: T) -> &mut Self
+    where
+        T: Component,
+    {
+        self.world.insert_resource(resource);
+        self
+    }
+
+    /// Inserts a non-send resource to the app
+    ///
+    /// You usually want to use `insert_resource`, but there are some special cases when a resource must
+    /// be non-send.
+    ///
+    /// ## Example
+    /// ```
+    /// # use bevy_app::prelude::*;
+    /// #
+    /// struct MyCounter {
+    ///     counter: usize,
+    /// }
+    ///
+    /// App::new()
+    ///     .insert_non_send_resource(MyCounter { counter: 0 });
+    /// ```
+    pub fn insert_non_send_resource<T>(&mut self, resource: T) -> &mut Self
+    where
+        T: 'static,
+    {
+        self.world.insert_non_send(resource);
+        self
+    }
+
+    /// Initialize a resource in the current [App], if it does not exist yet
+    ///
+    /// Adds a resource that implements `Default` or [`FromResources`] trait.
+    /// If the resource already exists, `init_resource` does nothing.
+    ///
+    /// ## Example
+    /// ```
+    /// # use bevy_app::prelude::*;
+    /// #
+    /// struct MyCounter {
+    ///     counter: usize,
+    /// }
+    ///
+    /// impl Default for MyCounter {
+    ///     fn default() -> MyCounter {
+    ///         MyCounter {
+    ///             counter: 100
+    ///         }
+    ///     }
+    /// }
+    ///
+    /// App::new()
+    ///     .init_resource::<MyCounter>();
+    /// ```
+    pub fn init_resource<R>(&mut self) -> &mut Self
+    where
+        R: FromWorld + Send + Sync + 'static,
+    {
+        // PERF: We could avoid double hashing here, since the `from_resources` call is guaranteed
+        // not to modify the map. However, we would need to be borrowing resources both
+        // mutably and immutably, so we would need to be extremely certain this is correct
+        if !self.world.contains_resource::<R>() {
+            let resource = R::from_world(&mut self.world);
+            self.insert_resource(resource);
+        }
+        self
+    }
+
+    pub fn init_non_send_resource<R>(&mut self) -> &mut Self
+    where
+        R: FromWorld + 'static,
+    {
+        // See perf comment in init_resource
+        if self.world.get_non_send_resource::<R>().is_none() {
+            let resource = R::from_world(&mut self.world);
+            self.world.insert_non_send(resource);
+        }
+        self
+    }
+
+    /// Sets the main runner loop function for this Bevy App
+    ///
+    /// Usually the main loop is handled by Bevy integrated plugins ([`WinitPlugin`]), but
+    /// in some cases one might wish to implement their own main loop.
+    ///
+    /// This method sets the main loop function, overwriting a previous runner if any.
+    ///
+    /// ## Example
+    /// ```
+    /// # use bevy_app::prelude::*;
+    /// #
+    /// fn my_runner(mut app: App) {
+    ///     loop {
+    ///         println!("In main loop");
+    ///         app.update();
+    ///     }
+    /// }
+    ///
+    /// App::new()
+    ///     .set_runner(my_runner);
+    /// ```
+    pub fn set_runner(&mut self, run_fn: impl Fn(App) + 'static) -> &mut Self {
+        self.runner = Box::new(run_fn);
+        self
+    }
+
+    /// Adds a single plugin
+    ///
+    /// One of Bevy's core principles is modularity. All Bevy engine features are implemented
+    /// as plugins. This includes internal features like the renderer.
+    ///
+    /// Bevy also provides a few sets of default plugins. See [`App::add_plugins`].
+    ///
+    /// ## Example
+    /// ```
+    /// # use bevy_app::prelude::*;
+    /// #
+    /// App::new().add_plugin(bevy_log::LogPlugin::default());
+    /// ```
+    pub fn add_plugin<T>(&mut self, plugin: T) -> &mut Self
+    where
+        T: Plugin,
+    {
+        debug!("added plugin: {}", plugin.name());
+        plugin.build(self);
+        self
+    }
+
+    /// Adds a group of plugins
+    ///
+    /// Bevy plugins can be grouped into a set of plugins. Bevy provides
+    /// built-in PluginGroups that provide core engine functionality.
+    ///
+    /// The plugin groups available by default are [`DefaultPlugins`] and [`MinimalPlugins`].
+    ///
+    /// ## Example
+    /// ```
+    /// # use bevy_app::{prelude::*, PluginGroupBuilder};
+    /// #
+    /// # // Dummy created to avoid using bevy_internal, which pulls in to many dependencies.
+    /// # struct MinimalPlugins;
+    /// # impl PluginGroup for MinimalPlugins {
+    /// #     fn build(&mut self, group: &mut PluginGroupBuilder){;}
+    /// # }
+    /// #
+    /// App::new()
+    ///     .add_plugins(MinimalPlugins);
+    /// ```
+    pub fn add_plugins<T: PluginGroup>(&mut self, mut group: T) -> &mut Self {
+        let mut plugin_group_builder = PluginGroupBuilder::default();
+        group.build(&mut plugin_group_builder);
+        plugin_group_builder.finish(self);
+        self
+    }
+
+    /// Adds a group of plugins with an initializer method
+    ///
+    /// Can be used to add a group of plugins, where the group is modified
+    /// before insertion into Bevy application. For example, you can add
+    /// extra plugins at a specific place in the plugin group, or deactivate
+    /// specific plugins while keeping the rest.
+    ///
+    /// ## Example
+    /// ```
+    /// # use bevy_app::{prelude::*, PluginGroupBuilder};
+    /// #
+    /// # // Dummies created to avoid using bevy_internal which pulls in to many dependencies.
+    /// # struct DefaultPlugins;
+    /// # impl PluginGroup for DefaultPlugins {
+    /// #     fn build(&mut self, group: &mut PluginGroupBuilder){
+    /// #         group.add(bevy_log::LogPlugin::default());
+    /// #     }
+    /// # }
+    /// #
+    /// # struct MyOwnPlugin;
+    /// # impl Plugin for MyOwnPlugin {
+    /// #     fn build(&self, app: &mut AppBuilder){;}
+    /// # }
+    /// #
+    /// App::new()
+    ///      .add_plugins_with(DefaultPlugins, |group| {
+    ///             group.add_before::<bevy_log::LogPlugin, _>(MyOwnPlugin)
+    ///         });
+    /// ```
+    pub fn add_plugins_with<T, F>(&mut self, mut group: T, func: F) -> &mut Self
+    where
+        T: PluginGroup,
+        F: FnOnce(&mut PluginGroupBuilder) -> &mut PluginGroupBuilder,
+    {
+        let mut plugin_group_builder = PluginGroupBuilder::default();
+        group.build(&mut plugin_group_builder);
+        func(&mut plugin_group_builder);
+        plugin_group_builder.finish(self);
+        self
+    }
+
+    /// Registers a new component using the given [ComponentDescriptor]. Components do not need to
+    /// be manually registered. This just provides a way to override default configuration.
+    /// Attempting to register a component with a type that has already been used by [World]
+    /// will result in an error.
+    ///
+    /// See [World::register_component]
+    pub fn register_component(&mut self, descriptor: ComponentDescriptor) -> &mut Self {
+        self.world.register_component(descriptor).unwrap();
+        self
+    }
+
+    #[cfg(feature = "bevy_reflect")]
+    pub fn register_type<T: bevy_reflect::GetTypeRegistration>(&mut self) -> &mut Self {
+        {
+            let registry = self
+                .world
+                .get_resource_mut::<bevy_reflect::TypeRegistryArc>()
+                .unwrap();
+            registry.write().register::<T>();
+        }
+        self
+    }
+
+    pub fn add_sub_app(
+        &mut self,
+        app: App,
+        f: impl Fn(&mut World, &mut App) + 'static,
+    ) -> &mut Self {
+        self.sub_apps.push(SubApp {
+            app,
+            runner: Box::new(f),
+        });
+        self
+    }
+
+    // TODO: use labels instead of indices
+    pub fn sub_app_mut(&mut self, index: usize) -> &mut App {
+        &mut self.sub_apps[index].app
+    }
+}
+
+fn run_once(mut app: App) {
+    app.update();
 }
 
 /// An event that indicates the app should exit. This will fully exit the app process.
diff --git a/crates/bevy_app/src/app_builder.rs b/crates/bevy_app/src/app_builder.rs
deleted file mode 100644
index 7c454cd704..0000000000
--- a/crates/bevy_app/src/app_builder.rs
+++ /dev/null
@@ -1,559 +0,0 @@
-use crate::{
-    app::{App, AppExit},
-    plugin::Plugin,
-    CoreStage, PluginGroup, PluginGroupBuilder, StartupStage,
-};
-use bevy_ecs::{
-    component::{Component, ComponentDescriptor},
-    event::Events,
-    schedule::{
-        IntoSystemDescriptor, RunOnce, Schedule, Stage, StageLabel, State, SystemSet, SystemStage,
-    },
-    system::{IntoExclusiveSystem, IntoSystem},
-    world::{FromWorld, World},
-};
-use bevy_utils::tracing::debug;
-use std::{fmt::Debug, hash::Hash};
-
-/// Configure [App]s using the builder pattern
-pub struct AppBuilder {
-    pub app: App,
-}
-
-impl Default for AppBuilder {
-    fn default() -> Self {
-        let mut app_builder = AppBuilder {
-            app: App::default(),
-        };
-
-        #[cfg(feature = "bevy_reflect")]
-        app_builder.init_resource::<bevy_reflect::TypeRegistryArc>();
-
-        app_builder
-            .add_default_stages()
-            .add_event::<AppExit>()
-            .add_system_to_stage(CoreStage::Last, World::clear_trackers.exclusive_system());
-
-        #[cfg(feature = "bevy_ci_testing")]
-        {
-            crate::ci_testing::setup_app(&mut app_builder);
-        }
-        app_builder
-    }
-}
-
-impl AppBuilder {
-    pub fn empty() -> AppBuilder {
-        AppBuilder {
-            app: App::default(),
-        }
-    }
-
-    /// Start the application (through main runner)
-    ///
-    /// Runs the application main loop.
-    ///
-    /// Usually the main loop is handled by Bevy integrated plugins (`winit`), but
-    /// but one can also set the runner function through [`AppBuilder::set_runner`].
-    ///
-    /// ## Example
-    /// ```
-    /// # use bevy_app::prelude::*;
-    /// #
-    /// App::build()
-    ///     // all required plugin insertions, systems, etc inserted here
-    ///     // finally, call:
-    ///     .run();
-    /// ```
-    pub fn run(&mut self) {
-        let app = std::mem::take(&mut self.app);
-        app.run();
-    }
-
-    pub fn world(&mut self) -> &World {
-        &self.app.world
-    }
-
-    pub fn world_mut(&mut self) -> &mut World {
-        &mut self.app.world
-    }
-
-    pub fn set_world(&mut self, world: World) -> &mut Self {
-        self.app.world = world;
-        self
-    }
-
-    pub fn add_stage<S: Stage>(&mut self, label: impl StageLabel, stage: S) -> &mut Self {
-        self.app.schedule.add_stage(label, stage);
-        self
-    }
-
-    pub fn add_stage_after<S: Stage>(
-        &mut self,
-        target: impl StageLabel,
-        label: impl StageLabel,
-        stage: S,
-    ) -> &mut Self {
-        self.app.schedule.add_stage_after(target, label, stage);
-        self
-    }
-
-    pub fn add_stage_before<S: Stage>(
-        &mut self,
-        target: impl StageLabel,
-        label: impl StageLabel,
-        stage: S,
-    ) -> &mut Self {
-        self.app.schedule.add_stage_before(target, label, stage);
-        self
-    }
-
-    pub fn add_startup_stage<S: Stage>(&mut self, label: impl StageLabel, stage: S) -> &mut Self {
-        self.app
-            .schedule
-            .stage(CoreStage::Startup, |schedule: &mut Schedule| {
-                schedule.add_stage(label, stage)
-            });
-        self
-    }
-
-    pub fn add_startup_stage_after<S: Stage>(
-        &mut self,
-        target: impl StageLabel,
-        label: impl StageLabel,
-        stage: S,
-    ) -> &mut Self {
-        self.app
-            .schedule
-            .stage(CoreStage::Startup, |schedule: &mut Schedule| {
-                schedule.add_stage_after(target, label, stage)
-            });
-        self
-    }
-
-    pub fn add_startup_stage_before<S: Stage>(
-        &mut self,
-        target: impl StageLabel,
-        label: impl StageLabel,
-        stage: S,
-    ) -> &mut Self {
-        self.app
-            .schedule
-            .stage(CoreStage::Startup, |schedule: &mut Schedule| {
-                schedule.add_stage_before(target, label, stage)
-            });
-        self
-    }
-
-    pub fn stage<T: Stage, F: FnOnce(&mut T) -> &mut T>(
-        &mut self,
-        label: impl StageLabel,
-        func: F,
-    ) -> &mut Self {
-        self.app.schedule.stage(label, func);
-        self
-    }
-
-    /// Adds a system that runs every time `app.update()` is called by the runner
-    ///
-    /// Systems are the main building block in the Bevy ECS app model. You can define
-    /// normal rust functions, and call `.system()` to make them be Bevy systems.
-    ///
-    /// System functions can have parameters, through which one can query and
-    /// mutate Bevy ECS states.
-    /// See [The Bevy Book](https://bevyengine.org/learn/book/introduction/) for more information.
-    ///
-    /// Systems are run in parallel, and the execution order is not deterministic.
-    /// If you want more fine-grained control for order, see [`AppBuilder::add_system_to_stage`].
-    ///
-    /// For adding a system that runs only at app startup, see [`AppBuilder::add_startup_system`].
-    ///
-    /// ## Example
-    /// ```
-    /// # use bevy_app::prelude::*;
-    /// # use bevy_ecs::prelude::*;
-    /// #
-    /// fn my_system(_commands: Commands) {
-    ///     println!("My system, triggered once per frame");
-    /// }
-    ///
-    /// App::build()
-    ///     .add_system(my_system.system());
-    /// ```
-    pub fn add_system<Params>(&mut self, system: impl IntoSystemDescriptor<Params>) -> &mut Self {
-        self.add_system_to_stage(CoreStage::Update, system)
-    }
-
-    pub fn add_system_set(&mut self, system_set: SystemSet) -> &mut Self {
-        self.add_system_set_to_stage(CoreStage::Update, system_set)
-    }
-
-    pub fn add_system_to_stage<Params>(
-        &mut self,
-        stage_label: impl StageLabel,
-        system: impl IntoSystemDescriptor<Params>,
-    ) -> &mut Self {
-        self.app.schedule.add_system_to_stage(stage_label, system);
-        self
-    }
-
-    pub fn add_system_set_to_stage(
-        &mut self,
-        stage_label: impl StageLabel,
-        system_set: SystemSet,
-    ) -> &mut Self {
-        self.app
-            .schedule
-            .add_system_set_to_stage(stage_label, system_set);
-        self
-    }
-
-    /// Adds a system that is run once at application startup
-    ///
-    /// Startup systems run exactly once BEFORE all other systems. These are generally used for
-    /// app initialization code (ex: adding entities and resources).
-    ///
-    /// * For adding a system that runs for every frame, see [`AppBuilder::add_system`].
-    /// * For adding a system to specific stage, see [`AppBuilder::add_system_to_stage`].
-    ///
-    /// ## Example
-    /// ```
-    /// # use bevy_app::prelude::*;
-    /// # use bevy_ecs::prelude::*;
-    /// #
-    /// fn my_startup_system(_commands: Commands) {
-    ///     println!("My startup system");
-    /// }
-    ///
-    /// App::build()
-    ///     .add_startup_system(my_startup_system.system());
-    /// ```
-    pub fn add_startup_system<Params>(
-        &mut self,
-        system: impl IntoSystemDescriptor<Params>,
-    ) -> &mut Self {
-        self.add_startup_system_to_stage(StartupStage::Startup, system)
-    }
-
-    pub fn add_startup_system_set(&mut self, system_set: SystemSet) -> &mut Self {
-        self.add_startup_system_set_to_stage(StartupStage::Startup, system_set)
-    }
-
-    pub fn add_startup_system_to_stage<Params>(
-        &mut self,
-        stage_label: impl StageLabel,
-        system: impl IntoSystemDescriptor<Params>,
-    ) -> &mut Self {
-        self.app
-            .schedule
-            .stage(CoreStage::Startup, |schedule: &mut Schedule| {
-                schedule.add_system_to_stage(stage_label, system)
-            });
-        self
-    }
-
-    pub fn add_startup_system_set_to_stage(
-        &mut self,
-        stage_label: impl StageLabel,
-        system_set: SystemSet,
-    ) -> &mut Self {
-        self.app
-            .schedule
-            .stage(CoreStage::Startup, |schedule: &mut Schedule| {
-                schedule.add_system_set_to_stage(stage_label, system_set)
-            });
-        self
-    }
-
-    /// Adds a new [State] with the given `initial` value.
-    /// This inserts a new `State<T>` resource and adds a new "driver" to [CoreStage::Update].
-    /// Each stage that uses `State<T>` for system run criteria needs a driver. If you need to use
-    /// your state in a different stage, consider using [Self::add_state_to_stage] or manually
-    /// adding [State::get_driver] to additional stages you need it in.
-    pub fn add_state<T>(&mut self, initial: T) -> &mut Self
-    where
-        T: Component + Debug + Clone + Eq + Hash,
-    {
-        self.add_state_to_stage(CoreStage::Update, initial)
-    }
-
-    /// Adds a new [State] with the given `initial` value.
-    /// This inserts a new `State<T>` resource and adds a new "driver" to the given stage.
-    /// Each stage that uses `State<T>` for system run criteria needs a driver. If you need to use
-    /// your state in more than one stage, consider manually adding [State::get_driver] to the
-    /// stages you need it in.
-    pub fn add_state_to_stage<T>(&mut self, stage: impl StageLabel, initial: T) -> &mut Self
-    where
-        T: Component + Debug + Clone + Eq + Hash,
-    {
-        self.insert_resource(State::new(initial))
-            .add_system_set_to_stage(stage, State::<T>::get_driver())
-    }
-
-    pub fn add_default_stages(&mut self) -> &mut Self {
-        self.add_stage(CoreStage::First, SystemStage::parallel())
-            .add_stage(
-                CoreStage::Startup,
-                Schedule::default()
-                    .with_run_criteria(RunOnce::default())
-                    .with_stage(StartupStage::PreStartup, SystemStage::parallel())
-                    .with_stage(StartupStage::Startup, SystemStage::parallel())
-                    .with_stage(StartupStage::PostStartup, SystemStage::parallel()),
-            )
-            .add_stage(CoreStage::PreUpdate, SystemStage::parallel())
-            .add_stage(CoreStage::Update, SystemStage::parallel())
-            .add_stage(CoreStage::PostUpdate, SystemStage::parallel())
-            .add_stage(CoreStage::Last, SystemStage::parallel())
-    }
-
-    /// Setup the application to manage events of type `T`.
-    ///
-    /// This is done by adding a `Resource` of type `Events::<T>`,
-    /// and inserting a `Events::<T>::update_system` system into `CoreStage::First`.
-    pub fn add_event<T>(&mut self) -> &mut Self
-    where
-        T: Component,
-    {
-        self.insert_resource(Events::<T>::default())
-            .add_system_to_stage(CoreStage::First, Events::<T>::update_system.system())
-    }
-
-    /// Inserts a resource to the current [App] and overwrites any resource previously added of the same type.
-    ///
-    /// A resource in Bevy represents globally unique data. Resources must be added to Bevy Apps
-    /// before using them. This happens with [`AppBuilder::insert_resource`].
-    ///
-    /// See also `init_resource` for resources that implement `Default` or [`FromResources`].
-    ///
-    /// ## Example
-    /// ```
-    /// # use bevy_app::prelude::*;
-    /// #
-    /// struct MyCounter {
-    ///     counter: usize,
-    /// }
-    ///
-    /// App::build()
-    ///    .insert_resource(MyCounter { counter: 0 });
-    /// ```
-    pub fn insert_resource<T>(&mut self, resource: T) -> &mut Self
-    where
-        T: Component,
-    {
-        self.app.world.insert_resource(resource);
-        self
-    }
-
-    /// Inserts a non-send resource to the app
-    ///
-    /// You usually want to use `insert_resource`, but there are some special cases when a resource must
-    /// be non-send.
-    ///
-    /// ## Example
-    /// ```
-    /// # use bevy_app::prelude::*;
-    /// #
-    /// struct MyCounter {
-    ///     counter: usize,
-    /// }
-    ///
-    /// App::build()
-    ///     .insert_non_send_resource(MyCounter { counter: 0 });
-    /// ```
-    pub fn insert_non_send_resource<T>(&mut self, resource: T) -> &mut Self
-    where
-        T: 'static,
-    {
-        self.app.world.insert_non_send(resource);
-        self
-    }
-
-    /// Initialize a resource in the current [App], if it does not exist yet
-    ///
-    /// Adds a resource that implements `Default` or [`FromResources`] trait.
-    /// If the resource already exists, `init_resource` does nothing.
-    ///
-    /// ## Example
-    /// ```
-    /// # use bevy_app::prelude::*;
-    /// #
-    /// struct MyCounter {
-    ///     counter: usize,
-    /// }
-    ///
-    /// impl Default for MyCounter {
-    ///     fn default() -> MyCounter {
-    ///         MyCounter {
-    ///             counter: 100
-    ///         }
-    ///     }
-    /// }
-    ///
-    /// App::build()
-    ///     .init_resource::<MyCounter>();
-    /// ```
-    pub fn init_resource<R>(&mut self) -> &mut Self
-    where
-        R: FromWorld + Send + Sync + 'static,
-    {
-        // PERF: We could avoid double hashing here, since the `from_resources` call is guaranteed
-        // not to modify the map. However, we would need to be borrowing resources both
-        // mutably and immutably, so we would need to be extremely certain this is correct
-        if !self.world_mut().contains_resource::<R>() {
-            let resource = R::from_world(self.world_mut());
-            self.insert_resource(resource);
-        }
-        self
-    }
-
-    pub fn init_non_send_resource<R>(&mut self) -> &mut Self
-    where
-        R: FromWorld + 'static,
-    {
-        // See perf comment in init_resource
-        if self.app.world.get_non_send_resource::<R>().is_none() {
-            let resource = R::from_world(self.world_mut());
-            self.app.world.insert_non_send(resource);
-        }
-        self
-    }
-
-    /// Sets the main runner loop function for this Bevy App
-    ///
-    /// Usually the main loop is handled by Bevy integrated plugins ([`WinitPlugin`]), but
-    /// in some cases one might wish to implement their own main loop.
-    ///
-    /// This method sets the main loop function, overwriting a previous runner if any.
-    ///
-    /// ## Example
-    /// ```
-    /// # use bevy_app::prelude::*;
-    /// #
-    /// fn my_runner(mut app: App) {
-    ///     loop {
-    ///         println!("In main loop");
-    ///         app.update();
-    ///     }
-    /// }
-    ///
-    /// App::build()
-    ///     .set_runner(my_runner);
-    /// ```
-    pub fn set_runner(&mut self, run_fn: impl Fn(App) + 'static) -> &mut Self {
-        self.app.runner = Box::new(run_fn);
-        self
-    }
-
-    /// Adds a single plugin
-    ///
-    /// One of Bevy's core principles is modularity. All Bevy engine features are implemented
-    /// as plugins. This includes internal features like the renderer.
-    ///
-    /// Bevy also provides a few sets of default plugins. See [`AppBuilder::add_plugins`].
-    ///
-    /// ## Example
-    /// ```
-    /// # use bevy_app::prelude::*;
-    /// #
-    /// App::build().add_plugin(bevy_log::LogPlugin::default());
-    /// ```
-    pub fn add_plugin<T>(&mut self, plugin: T) -> &mut Self
-    where
-        T: Plugin,
-    {
-        debug!("added plugin: {}", plugin.name());
-        plugin.build(self);
-        self
-    }
-
-    /// Adds a group of plugins
-    ///
-    /// Bevy plugins can be grouped into a set of plugins. Bevy provides
-    /// built-in PluginGroups that provide core engine functionality.
-    ///
-    /// The plugin groups available by default are [`DefaultPlugins`] and [`MinimalPlugins`].
-    ///
-    /// ## Example
-    /// ```
-    /// # use bevy_app::{prelude::*, PluginGroupBuilder};
-    /// #
-    /// # // Dummy created to avoid using bevy_internal, which pulls in to many dependencies.
-    /// # struct MinimalPlugins;
-    /// # impl PluginGroup for MinimalPlugins {
-    /// #     fn build(&mut self, group: &mut PluginGroupBuilder){;}
-    /// # }
-    /// #
-    /// App::build()
-    ///     .add_plugins(MinimalPlugins);
-    /// ```
-    pub fn add_plugins<T: PluginGroup>(&mut self, mut group: T) -> &mut Self {
-        let mut plugin_group_builder = PluginGroupBuilder::default();
-        group.build(&mut plugin_group_builder);
-        plugin_group_builder.finish(self);
-        self
-    }
-
-    /// Adds a group of plugins with an initializer method
-    ///
-    /// Can be used to add a group of plugins, where the group is modified
-    /// before insertion into Bevy application. For example, you can add
-    /// extra plugins at a specific place in the plugin group, or deactivate
-    /// specific plugins while keeping the rest.
-    ///
-    /// ## Example
-    /// ```
-    /// # use bevy_app::{prelude::*, PluginGroupBuilder};
-    /// #
-    /// # // Dummies created to avoid using bevy_internal which pulls in to many dependencies.
-    /// # struct DefaultPlugins;
-    /// # impl PluginGroup for DefaultPlugins {
-    /// #     fn build(&mut self, group: &mut PluginGroupBuilder){
-    /// #         group.add(bevy_log::LogPlugin::default());
-    /// #     }
-    /// # }
-    /// #
-    /// # struct MyOwnPlugin;
-    /// # impl Plugin for MyOwnPlugin {
-    /// #     fn build(&self, app: &mut AppBuilder){;}
-    /// # }
-    /// #
-    /// App::build()
-    ///      .add_plugins_with(DefaultPlugins, |group| {
-    ///             group.add_before::<bevy_log::LogPlugin, _>(MyOwnPlugin)
-    ///         });
-    /// ```
-    pub fn add_plugins_with<T, F>(&mut self, mut group: T, func: F) -> &mut Self
-    where
-        T: PluginGroup,
-        F: FnOnce(&mut PluginGroupBuilder) -> &mut PluginGroupBuilder,
-    {
-        let mut plugin_group_builder = PluginGroupBuilder::default();
-        group.build(&mut plugin_group_builder);
-        func(&mut plugin_group_builder);
-        plugin_group_builder.finish(self);
-        self
-    }
-
-    /// Registers a new component using the given [ComponentDescriptor]. Components do not need to
-    /// be manually registered. This just provides a way to override default configuration.
-    /// Attempting to register a component with a type that has already been used by [World]
-    /// will result in an error.
-    ///
-    /// See [World::register_component]
-    pub fn register_component(&mut self, descriptor: ComponentDescriptor) -> &mut Self {
-        self.world_mut().register_component(descriptor).unwrap();
-        self
-    }
-
-    #[cfg(feature = "bevy_reflect")]
-    pub fn register_type<T: bevy_reflect::GetTypeRegistration>(&mut self) -> &mut Self {
-        {
-            let registry = self
-                .world_mut()
-                .get_resource_mut::<bevy_reflect::TypeRegistryArc>()
-                .unwrap();
-            registry.write().register::<T>();
-        }
-        self
-    }
-}
diff --git a/crates/bevy_app/src/lib.rs b/crates/bevy_app/src/lib.rs
index e5cd52fd6e..04c42b306f 100644
--- a/crates/bevy_app/src/lib.rs
+++ b/crates/bevy_app/src/lib.rs
@@ -1,5 +1,4 @@
 mod app;
-mod app_builder;
 mod plugin;
 mod plugin_group;
 mod schedule_runner;
@@ -8,7 +7,6 @@ mod schedule_runner;
 mod ci_testing;
 
 pub use app::*;
-pub use app_builder::*;
 pub use bevy_derive::DynamicPlugin;
 pub use bevy_ecs::event::*;
 pub use plugin::*;
@@ -18,7 +16,7 @@ pub use schedule_runner::*;
 pub mod prelude {
     #[doc(hidden)]
     pub use crate::{
-        app::App, app_builder::AppBuilder, CoreStage, DynamicPlugin, Plugin, PluginGroup,
+        app::App, CoreStage, DynamicPlugin, Plugin, PluginGroup,
         StartupStage,
     };
 }
diff --git a/crates/bevy_app/src/plugin.rs b/crates/bevy_app/src/plugin.rs
index ea5ef0021a..38115af2ce 100644
--- a/crates/bevy_app/src/plugin.rs
+++ b/crates/bevy_app/src/plugin.rs
@@ -1,12 +1,12 @@
-use crate::AppBuilder;
+use crate::App;
 use std::any::Any;
 
 /// A collection of Bevy App logic and configuration
 ///
-/// Plugins use [AppBuilder] to configure an [App](crate::App). When an [App](crate::App) registers
+/// Plugins configure an [App](crate::App). When an [App](crate::App) registers
 /// a plugin, the plugin's [Plugin::build] function is run.
 pub trait Plugin: Any + Send + Sync {
-    fn build(&self, app: &mut AppBuilder);
+    fn build(&self, app: &mut App);
     fn name(&self) -> &str {
         std::any::type_name::<Self>()
     }
diff --git a/crates/bevy_app/src/plugin_group.rs b/crates/bevy_app/src/plugin_group.rs
index 074a2d3083..6bb41483bb 100644
--- a/crates/bevy_app/src/plugin_group.rs
+++ b/crates/bevy_app/src/plugin_group.rs
@@ -1,4 +1,4 @@
-use crate::{AppBuilder, Plugin};
+use crate::{App, Plugin};
 use bevy_utils::{tracing::debug, HashMap};
 use std::any::TypeId;
 
@@ -96,7 +96,7 @@ impl PluginGroupBuilder {
         self
     }
 
-    pub fn finish(self, app: &mut AppBuilder) {
+    pub fn finish(self, app: &mut App) {
         for ty in self.order.iter() {
             if let Some(entry) = self.plugins.get(ty) {
                 if entry.enabled {
diff --git a/crates/bevy_app/src/schedule_runner.rs b/crates/bevy_app/src/schedule_runner.rs
index 7b27cc43c8..9c80d237e6 100644
--- a/crates/bevy_app/src/schedule_runner.rs
+++ b/crates/bevy_app/src/schedule_runner.rs
@@ -1,5 +1,8 @@
-use super::{App, AppBuilder};
-use crate::{app::AppExit, plugin::Plugin, ManualEventReader};
+use crate::{
+    app::{App, AppExit},
+    plugin::Plugin,
+    ManualEventReader,
+};
 use bevy_ecs::event::Events;
 use bevy_utils::{Duration, Instant};
 
@@ -48,9 +51,9 @@ impl ScheduleRunnerSettings {
 pub struct ScheduleRunnerPlugin {}
 
 impl Plugin for ScheduleRunnerPlugin {
-    fn build(&self, app: &mut AppBuilder) {
+    fn build(&self, app: &mut App) {
         let settings = app
-            .world_mut()
+            .world
             .get_resource_or_insert_with(ScheduleRunnerSettings::default)
             .to_owned();
         app.set_runner(move |mut app: App| {
diff --git a/crates/bevy_asset/src/assets.rs b/crates/bevy_asset/src/assets.rs
index 299be3e3b9..34da94aa50 100644
--- a/crates/bevy_asset/src/assets.rs
+++ b/crates/bevy_asset/src/assets.rs
@@ -2,7 +2,7 @@ use crate::{
     update_asset_storage_system, Asset, AssetLoader, AssetServer, AssetStage, Handle, HandleId,
     RefChange,
 };
-use bevy_app::{AppBuilder, EventWriter, Events};
+use bevy_app::{App, EventWriter, Events};
 use bevy_ecs::{
     system::{IntoSystem, ResMut},
     world::FromWorld,
@@ -206,13 +206,13 @@ pub trait AddAsset {
         T: AssetLoader;
 }
 
-impl AddAsset for AppBuilder {
+impl AddAsset for App {
     fn add_asset<T>(&mut self) -> &mut Self
     where
         T: Asset,
     {
         let assets = {
-            let asset_server = self.world().get_resource::<AssetServer>().unwrap();
+            let asset_server = self.world.get_resource::<AssetServer>().unwrap();
             asset_server.register_asset_type::<T>()
         };
 
@@ -233,7 +233,7 @@ impl AddAsset for AppBuilder {
     where
         T: AssetLoader + FromWorld,
     {
-        let result = T::from_world(self.world_mut());
+        let result = T::from_world(&mut self.world);
         self.add_asset_loader(result)
     }
 
@@ -241,7 +241,7 @@ impl AddAsset for AppBuilder {
     where
         T: AssetLoader,
     {
-        self.world_mut()
+        self.world
             .get_resource_mut::<AssetServer>()
             .expect("AssetServer does not exist. Consider adding it as a resource.")
             .add_loader(loader);
diff --git a/crates/bevy_asset/src/diagnostic/asset_count_diagnostics_plugin.rs b/crates/bevy_asset/src/diagnostic/asset_count_diagnostics_plugin.rs
index 4dae5198d8..a915d8fe88 100644
--- a/crates/bevy_asset/src/diagnostic/asset_count_diagnostics_plugin.rs
+++ b/crates/bevy_asset/src/diagnostic/asset_count_diagnostics_plugin.rs
@@ -17,7 +17,7 @@ impl<T: Asset> Default for AssetCountDiagnosticsPlugin<T> {
 }
 
 impl<T: Asset> Plugin for AssetCountDiagnosticsPlugin<T> {
-    fn build(&self, app: &mut AppBuilder) {
+    fn build(&self, app: &mut App) {
         app.add_startup_system(Self::setup_system.system())
             .add_system(Self::diagnostic_system.system());
     }
diff --git a/crates/bevy_asset/src/lib.rs b/crates/bevy_asset/src/lib.rs
index 62808e38a4..12a3149872 100644
--- a/crates/bevy_asset/src/lib.rs
+++ b/crates/bevy_asset/src/lib.rs
@@ -26,7 +26,7 @@ pub use io::*;
 pub use loader::*;
 pub use path::*;
 
-use bevy_app::{prelude::Plugin, AppBuilder};
+use bevy_app::{prelude::Plugin, App};
 use bevy_ecs::{
     schedule::{StageLabel, SystemStage},
     system::IntoSystem,
@@ -61,9 +61,9 @@ impl Default for AssetServerSettings {
 ///
 /// This is useful when providing a custom `AssetIo` instance that needs to
 /// delegate to the default `AssetIo` for the platform.
-pub fn create_platform_default_asset_io(app: &mut AppBuilder) -> Box<dyn AssetIo> {
+pub fn create_platform_default_asset_io(app: &mut App) -> Box<dyn AssetIo> {
     let settings = app
-        .world_mut()
+        .world
         .get_resource_or_insert_with(AssetServerSettings::default);
 
     #[cfg(all(not(target_arch = "wasm32"), not(target_os = "android")))]
@@ -77,10 +77,10 @@ pub fn create_platform_default_asset_io(app: &mut AppBuilder) -> Box<dyn AssetIo
 }
 
 impl Plugin for AssetPlugin {
-    fn build(&self, app: &mut AppBuilder) {
-        if app.world().get_resource::<AssetServer>().is_none() {
+    fn build(&self, app: &mut App) {
+        if app.world.get_resource::<AssetServer>().is_none() {
             let task_pool = app
-                .world()
+                .world
                 .get_resource::<IoTaskPool>()
                 .expect("`IoTaskPool` resource not found.")
                 .0
diff --git a/crates/bevy_audio/src/lib.rs b/crates/bevy_audio/src/lib.rs
index eb9f148460..5f44d68f9f 100644
--- a/crates/bevy_audio/src/lib.rs
+++ b/crates/bevy_audio/src/lib.rs
@@ -20,7 +20,7 @@ use bevy_ecs::system::IntoExclusiveSystem;
 pub struct AudioPlugin;
 
 impl Plugin for AudioPlugin {
-    fn build(&self, app: &mut AppBuilder) {
+    fn build(&self, app: &mut App) {
         app.init_non_send_resource::<AudioOutput<AudioSource>>()
             .add_asset::<AudioSource>()
             .init_resource::<Audio<AudioSource>>()
diff --git a/crates/bevy_core/src/lib.rs b/crates/bevy_core/src/lib.rs
index 75fd87adb5..50ab218cd6 100644
--- a/crates/bevy_core/src/lib.rs
+++ b/crates/bevy_core/src/lib.rs
@@ -38,13 +38,13 @@ pub enum CoreSystem {
 }
 
 impl Plugin for CorePlugin {
-    fn build(&self, app: &mut AppBuilder) {
+    fn build(&self, app: &mut App) {
         // Setup the default bevy task pools
-        app.world_mut()
+        app.world
             .get_resource::<DefaultTaskPoolOptions>()
             .cloned()
             .unwrap_or_else(DefaultTaskPoolOptions::default)
-            .create_default_pools(app.world_mut());
+            .create_default_pools(&mut app.world);
 
         app.init_resource::<Time>()
             .init_resource::<EntityLabels>()
@@ -70,7 +70,7 @@ impl Plugin for CorePlugin {
     }
 }
 
-fn register_rust_types(app: &mut AppBuilder) {
+fn register_rust_types(app: &mut App) {
     app.register_type::<bool>()
         .register_type::<u8>()
         .register_type::<u16>()
@@ -90,7 +90,7 @@ fn register_rust_types(app: &mut AppBuilder) {
         .register_type::<Option<String>>();
 }
 
-fn register_math_types(app: &mut AppBuilder) {
+fn register_math_types(app: &mut App) {
     app.register_type::<bevy_math::IVec2>()
         .register_type::<bevy_math::IVec3>()
         .register_type::<bevy_math::IVec4>()
diff --git a/crates/bevy_diagnostic/src/entity_count_diagnostics_plugin.rs b/crates/bevy_diagnostic/src/entity_count_diagnostics_plugin.rs
index bdc24a35da..b4741ed168 100644
--- a/crates/bevy_diagnostic/src/entity_count_diagnostics_plugin.rs
+++ b/crates/bevy_diagnostic/src/entity_count_diagnostics_plugin.rs
@@ -1,4 +1,4 @@
-use bevy_app::{AppBuilder, Plugin};
+use bevy_app::{App, Plugin};
 use bevy_ecs::{
     system::{IntoExclusiveSystem, IntoSystem, ResMut},
     world::World,
@@ -11,7 +11,7 @@ use crate::{Diagnostic, DiagnosticId, Diagnostics};
 pub struct EntityCountDiagnosticsPlugin;
 
 impl Plugin for EntityCountDiagnosticsPlugin {
-    fn build(&self, app: &mut AppBuilder) {
+    fn build(&self, app: &mut App) {
         app.add_startup_system(Self::setup_system.system())
             .add_system(Self::diagnostic_system.exclusive_system());
     }
diff --git a/crates/bevy_diagnostic/src/frame_time_diagnostics_plugin.rs b/crates/bevy_diagnostic/src/frame_time_diagnostics_plugin.rs
index 52fb20db05..10065cf6e0 100644
--- a/crates/bevy_diagnostic/src/frame_time_diagnostics_plugin.rs
+++ b/crates/bevy_diagnostic/src/frame_time_diagnostics_plugin.rs
@@ -12,7 +12,7 @@ pub struct FrameTimeDiagnosticsState {
 }
 
 impl Plugin for FrameTimeDiagnosticsPlugin {
-    fn build(&self, app: &mut bevy_app::AppBuilder) {
+    fn build(&self, app: &mut bevy_app::App) {
         app.add_startup_system(Self::setup_system.system())
             .insert_resource(FrameTimeDiagnosticsState { frame_count: 0.0 })
             .add_system(Self::diagnostic_system.system());
diff --git a/crates/bevy_diagnostic/src/lib.rs b/crates/bevy_diagnostic/src/lib.rs
index 5074130753..076618bcde 100644
--- a/crates/bevy_diagnostic/src/lib.rs
+++ b/crates/bevy_diagnostic/src/lib.rs
@@ -14,7 +14,7 @@ use bevy_app::prelude::*;
 pub struct DiagnosticsPlugin;
 
 impl Plugin for DiagnosticsPlugin {
-    fn build(&self, app: &mut AppBuilder) {
+    fn build(&self, app: &mut App) {
         app.init_resource::<Diagnostics>();
     }
 }
diff --git a/crates/bevy_diagnostic/src/log_diagnostics_plugin.rs b/crates/bevy_diagnostic/src/log_diagnostics_plugin.rs
index a02c6991c9..b9172805c3 100644
--- a/crates/bevy_diagnostic/src/log_diagnostics_plugin.rs
+++ b/crates/bevy_diagnostic/src/log_diagnostics_plugin.rs
@@ -29,7 +29,7 @@ impl Default for LogDiagnosticsPlugin {
 }
 
 impl Plugin for LogDiagnosticsPlugin {
-    fn build(&self, app: &mut bevy_app::AppBuilder) {
+    fn build(&self, app: &mut App) {
         app.insert_resource(LogDiagnosticsState {
             timer: Timer::new(self.wait_duration, true),
             filter: self.filter.clone(),
diff --git a/crates/bevy_dynamic_plugin/src/loader.rs b/crates/bevy_dynamic_plugin/src/loader.rs
index 7d42c8faae..20c543944c 100644
--- a/crates/bevy_dynamic_plugin/src/loader.rs
+++ b/crates/bevy_dynamic_plugin/src/loader.rs
@@ -1,6 +1,6 @@
 use libloading::{Library, Symbol};
 
-use bevy_app::{AppBuilder, CreatePlugin, Plugin};
+use bevy_app::{App, CreatePlugin, Plugin};
 
 /// Dynamically links a plugin a the given path. The plugin must export a function with the
 /// [`CreatePlugin`] signature named `_bevy_create_plugin`.
@@ -24,7 +24,7 @@ pub trait DynamicPluginExt {
     unsafe fn load_plugin(&mut self, path: &str) -> &mut Self;
 }
 
-impl DynamicPluginExt for AppBuilder {
+impl DynamicPluginExt for App {
     unsafe fn load_plugin(&mut self, path: &str) -> &mut Self {
         let (lib, plugin) = dynamically_load_plugin(path);
         std::mem::forget(lib); // Ensure that the library is not automatically unloaded
diff --git a/crates/bevy_ecs/src/archetype.rs b/crates/bevy_ecs/src/archetype.rs
index 5a718bd6ba..28d3939460 100644
--- a/crates/bevy_ecs/src/archetype.rs
+++ b/crates/bevy_ecs/src/archetype.rs
@@ -309,6 +309,11 @@ impl Archetype {
             .get(component_id)
             .map(|info| info.archetype_component_id)
     }
+
+    pub(crate) fn clear_entities(&mut self) {
+        self.entities.clear();
+        self.table_info.entity_rows.clear();
+    }
 }
 
 /// A generational id that changes every time the set of archetypes changes
@@ -519,6 +524,12 @@ impl Archetypes {
     pub fn archetype_components_len(&self) -> usize {
         self.archetype_component_count
     }
+
+    pub fn clear_entities(&mut self) {
+        for archetype in self.archetypes.iter_mut() {
+            archetype.clear_entities();
+        }
+    }
 }
 
 impl Index<ArchetypeId> for Archetypes {
diff --git a/crates/bevy_ecs/src/entity/mod.rs b/crates/bevy_ecs/src/entity/mod.rs
index a1fd3e4bf4..0e866e188e 100644
--- a/crates/bevy_ecs/src/entity/mod.rs
+++ b/crates/bevy_ecs/src/entity/mod.rs
@@ -339,6 +339,7 @@ impl Entities {
         self.meta.clear();
         self.pending.clear();
         *self.free_cursor.get_mut() = 0;
+        self.len = 0;
     }
 
     /// Access the location storage of an entity.
diff --git a/crates/bevy_ecs/src/lib.rs b/crates/bevy_ecs/src/lib.rs
index d95a15bd08..6cbe96da14 100644
--- a/crates/bevy_ecs/src/lib.rs
+++ b/crates/bevy_ecs/src/lib.rs
@@ -1226,4 +1226,26 @@ mod tests {
         assert_eq!(dropped1.load(Ordering::Relaxed), 1);
         assert_eq!(dropped2.load(Ordering::Relaxed), 1);
     }
+
+    fn clear_entities() {
+        let mut world = World::default();
+        world.register_component(ComponentDescriptor::new::<f32>(StorageType::SparseSet)).unwrap();
+        world.insert_resource::<i32>(0);
+        world.spawn().insert(1u32);
+        world.spawn().insert(1.0f32);
+
+        let mut q1 = world.query::<&u32>();
+        let mut q2 = world.query::<&f32>();
+
+        assert_eq!(q1.iter(&world).len(), 1);
+        assert_eq!(q2.iter(&world).len(), 1);
+        assert_eq!(world.entities().len(), 2);
+
+        world.clear_entities();
+
+        assert_eq!(q1.iter(&world).len(), 0, "world should not contain table components");
+        assert_eq!(q2.iter(&world).len(), 0, "world should not contain sparse set components");
+        assert_eq!(world.entities().len(), 0, "world should not have any entities");
+        assert_eq!(*world.get_resource::<i32>().unwrap(), 0, "world should still contain resources");
+    }
 }
diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index 8eed39d3aa..10980ccd60 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -83,6 +83,7 @@ pub struct SystemStage {
     uninitialized_parallel: Vec<usize>,
     /// Saves the value of the World change_tick during the last tick check
     last_tick_check: u32,
+    apply_buffers: bool,
 }
 
 impl SystemStage {
@@ -104,6 +105,7 @@ impl SystemStage {
             uninitialized_before_commands: vec![],
             uninitialized_at_end: vec![],
             last_tick_check: Default::default(),
+            apply_buffers: true,
         }
     }
 
@@ -203,6 +205,16 @@ impl SystemStage {
         }
     }
 
+    pub fn apply_buffers(&mut self, world: &mut World) {
+        for container in self.parallel.iter_mut() {
+            container.system_mut().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.
@@ -828,9 +840,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/storage/sparse_set.rs b/crates/bevy_ecs/src/storage/sparse_set.rs
index 6d0b85ffbb..d98b647a0e 100644
--- a/crates/bevy_ecs/src/storage/sparse_set.rs
+++ b/crates/bevy_ecs/src/storage/sparse_set.rs
@@ -82,6 +82,10 @@ impl<I: SparseSetIndex, V> SparseArray<I, V> {
         *value = Some(func());
         value.as_mut().unwrap()
     }
+
+    pub fn clear(&mut self) {
+        self.values.clear();
+    }
 }
 
 #[derive(Debug)]
@@ -102,6 +106,13 @@ impl ComponentSparseSet {
         }
     }
 
+    pub fn clear(&mut self) {
+        self.dense.clear();
+        self.ticks.get_mut().clear();
+        self.entities.clear();
+        self.sparse.clear();
+    }
+
     #[inline]
     pub fn len(&self) -> usize {
         self.dense.len()
@@ -400,6 +411,12 @@ impl SparseSets {
         self.sets.get_mut(component_id)
     }
 
+    pub fn clear(&mut self) {
+        for set in self.sets.values_mut() {
+            set.clear();
+        }
+    }
+
     pub(crate) fn check_change_ticks(&mut self, change_tick: u32) {
         for set in self.sets.values_mut() {
             set.check_change_ticks(change_tick);
diff --git a/crates/bevy_ecs/src/storage/table.rs b/crates/bevy_ecs/src/storage/table.rs
index 8fc334b569..867656172c 100644
--- a/crates/bevy_ecs/src/storage/table.rs
+++ b/crates/bevy_ecs/src/storage/table.rs
@@ -179,6 +179,11 @@ impl Column {
         self.ticks.get_unchecked(row).get()
     }
 
+    pub fn clear(&mut self) {
+        self.data.clear();
+        self.ticks.get_mut().clear();
+    }
+
     #[inline]
     pub(crate) fn check_change_ticks(&mut self, change_tick: u32) {
         for component_ticks in &mut self.ticks {
@@ -396,6 +401,13 @@ impl Table {
     pub fn iter(&self) -> impl Iterator<Item = &Column> {
         self.columns.values()
     }
+
+    pub fn clear(&mut self) {
+        self.entities.clear();
+        for column in self.columns.values_mut() {
+            column.clear();
+        }
+    }
 }
 
 pub struct Tables {
@@ -475,6 +487,16 @@ impl Tables {
         self.tables.iter()
     }
 
+    pub fn iter_mut(&mut self) -> std::slice::IterMut<'_, Table> {
+        self.tables.iter_mut()
+    }
+
+    pub fn clear(&mut self) {
+        for table in self.tables.iter_mut() {
+            table.clear();
+        }
+    }
+
     pub(crate) fn check_change_ticks(&mut self, change_tick: u32) {
         for table in self.tables.iter_mut() {
             table.check_change_ticks(change_tick);
diff --git a/crates/bevy_ecs/src/system/commands/mod.rs b/crates/bevy_ecs/src/system/commands/mod.rs
index 0488b09e4f..2edc4c7a46 100644
--- a/crates/bevy_ecs/src/system/commands/mod.rs
+++ b/crates/bevy_ecs/src/system/commands/mod.rs
@@ -58,6 +58,13 @@ impl<'a> Commands<'a> {
         }
     }
 
+    // TODO: this is a hack to work around the "multiple worlds" limitations:
+    // Right now Commands must allocate entities from their "scheduled" world, but Commands might be applied to other worlds,
+    // such as the "render world"
+    pub fn spawn_and_forget(&mut self, bundle: impl Bundle) {
+        self.queue.push(Spawn { bundle })
+    }
+
     /// Creates a new entity with the components contained in `bundle`.
     ///
     /// This returns an [`EntityCommands`] builder, which enables inserting more components and
diff --git a/crates/bevy_ecs/src/system/function_system.rs b/crates/bevy_ecs/src/system/function_system.rs
index a8de42abf5..e9ea17af1b 100644
--- a/crates/bevy_ecs/src/system/function_system.rs
+++ b/crates/bevy_ecs/src/system/function_system.rs
@@ -24,7 +24,7 @@ pub struct SystemMeta {
 }
 
 impl SystemMeta {
-    fn new<T>() -> Self {
+    pub fn new<T>() -> Self {
         Self {
             name: std::any::type_name::<T>().into(),
             archetype_component_access: Access::default(),
diff --git a/crates/bevy_ecs/src/system/param_state.rs b/crates/bevy_ecs/src/system/param_state.rs
new file mode 100644
index 0000000000..8721edbe1c
--- /dev/null
+++ b/crates/bevy_ecs/src/system/param_state.rs
@@ -0,0 +1,36 @@
+use crate::system::{SystemParam, SystemParamFetch, SystemParamState, SystemState};
+use crate::world::World;
+
+pub struct ParamState<Param: SystemParam> {
+    state: SystemState,
+    param_state: <Param as SystemParam>::Fetch,
+    change_tick: u32,
+}
+
+impl<Param: SystemParam> ParamState<Param> {
+    pub fn new(world: &mut World) -> Self {
+        let mut state = SystemState::new::<Param>();
+        let config = <Param::Fetch as SystemParamState>::default_config();
+        let param_state = <Param::Fetch as SystemParamState>::init(world, &mut state, config);
+        Self {
+            state,
+            param_state,
+            change_tick: 0,
+        }
+    }
+
+    // TODO: THIS IS SUPER UNSAFE PLEASE DON'T MERGE UNTIL IT IS CONSTRAINED TO READ-ONLY PARAMS
+    pub fn get<'a>(&'a mut self, world: &'a World) -> <Param::Fetch as SystemParamFetch<'a>>::Item {
+        let change_tick = world.increment_change_tick();
+        self.change_tick = change_tick;
+        // TODO: add/implement ReadOnlySystemParam and constrain param here
+        unsafe {
+            <Param::Fetch as SystemParamFetch>::get_param(
+                &mut self.param_state,
+                &mut self.state,
+                world,
+                change_tick,
+            )
+        }
+    }
+}
diff --git a/crates/bevy_ecs/src/world/mod.rs b/crates/bevy_ecs/src/world/mod.rs
index 5068fdc4e5..ac3e2c906f 100644
--- a/crates/bevy_ecs/src/world/mod.rs
+++ b/crates/bevy_ecs/src/world/mod.rs
@@ -917,6 +917,13 @@ impl World {
             column.check_change_ticks(change_tick);
         }
     }
+
+    pub fn clear_entities(&mut self) {
+        self.storages.tables.clear();
+        self.storages.sparse_sets.clear();
+        self.archetypes.clear_entities();
+        self.entities.clear();
+    }
 }
 
 impl fmt::Debug for World {
diff --git a/crates/bevy_gilrs/src/lib.rs b/crates/bevy_gilrs/src/lib.rs
index f8c168ec1d..406b947cc2 100644
--- a/crates/bevy_gilrs/src/lib.rs
+++ b/crates/bevy_gilrs/src/lib.rs
@@ -1,7 +1,7 @@
 mod converter;
 mod gilrs_system;
 
-use bevy_app::{AppBuilder, CoreStage, Plugin, StartupStage};
+use bevy_app::{App, CoreStage, Plugin, StartupStage};
 use bevy_ecs::system::IntoExclusiveSystem;
 use bevy_utils::tracing::error;
 use gilrs::GilrsBuilder;
@@ -11,7 +11,7 @@ use gilrs_system::{gilrs_event_startup_system, gilrs_event_system};
 pub struct GilrsPlugin;
 
 impl Plugin for GilrsPlugin {
-    fn build(&self, app: &mut AppBuilder) {
+    fn build(&self, app: &mut App) {
         match GilrsBuilder::new()
             .with_default_filters(false)
             .set_update_state(false)
diff --git a/crates/bevy_gltf/src/lib.rs b/crates/bevy_gltf/src/lib.rs
index 591d6c0701..10669fd79e 100644
--- a/crates/bevy_gltf/src/lib.rs
+++ b/crates/bevy_gltf/src/lib.rs
@@ -15,7 +15,7 @@ use bevy_scene::Scene;
 pub struct GltfPlugin;
 
 impl Plugin for GltfPlugin {
-    fn build(&self, app: &mut AppBuilder) {
+    fn build(&self, app: &mut App) {
         app.init_asset_loader::<GltfLoader>()
             .add_asset::<Gltf>()
             .add_asset::<GltfNode>()
diff --git a/crates/bevy_input/src/lib.rs b/crates/bevy_input/src/lib.rs
index a8e5f6951b..335f8b8033 100644
--- a/crates/bevy_input/src/lib.rs
+++ b/crates/bevy_input/src/lib.rs
@@ -45,7 +45,7 @@ pub struct InputPlugin;
 pub struct InputSystem;
 
 impl Plugin for InputPlugin {
-    fn build(&self, app: &mut AppBuilder) {
+    fn build(&self, app: &mut App) {
         app
             // keyboard
             .add_event::<KeyboardInput>()
diff --git a/crates/bevy_internal/Cargo.toml b/crates/bevy_internal/Cargo.toml
index 64460a5d7e..cfdf643639 100644
--- a/crates/bevy_internal/Cargo.toml
+++ b/crates/bevy_internal/Cargo.toml
@@ -19,12 +19,12 @@ trace = [ "bevy_app/trace", "bevy_ecs/trace" ]
 trace_chrome = [ "bevy_log/tracing-chrome" ]
 
 # Image format support for texture loading (PNG and HDR are enabled by default)
-hdr = ["bevy_render/hdr"]
-png = ["bevy_render/png"]
-dds = ["bevy_render/dds"]
-tga = ["bevy_render/tga"]
-jpeg = ["bevy_render/jpeg"]
-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"]
@@ -69,13 +69,17 @@ bevy_audio = { path = "../bevy_audio", optional = true, version = "0.5.0" }
 bevy_gltf = { path = "../bevy_gltf", optional = true, version = "0.5.0" }
 bevy_pbr = { path = "../bevy_pbr", 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" }
+bevy_wgpu2 = { path = "../../pipelined/bevy_wgpu2", optional = true, version = "0.5.0" }
 bevy_winit = { path = "../bevy_winit", optional = true, version = "0.5.0" }
 bevy_gilrs = { path = "../bevy_gilrs", optional = true, version = "0.5.0" }
 
+
 [target.'cfg(target_os = "android")'.dependencies]
 ndk-glue = {version = "0.2", features = ["logger"]}
diff --git a/crates/bevy_internal/src/default_plugins.rs b/crates/bevy_internal/src/default_plugins.rs
index f42f45c477..9d5d4886a0 100644
--- a/crates/bevy_internal/src/default_plugins.rs
+++ b/crates/bevy_internal/src/default_plugins.rs
@@ -105,3 +105,29 @@ 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());
+
+        #[cfg(feature = "bevy_render2")]
+        group.add(bevy_render2::RenderPlugin::default());
+
+        #[cfg(feature = "bevy_winit")]
+        group.add(bevy_winit::WinitPlugin::default());
+
+        #[cfg(feature = "bevy_wgpu2")]
+        group.add(bevy_wgpu2::WgpuPlugin::default());
+
+        #[cfg(feature = "bevy_sprite2")]
+        group.add(bevy_sprite2::SpritePlugin::default());
+    }
+}
diff --git a/crates/bevy_internal/src/lib.rs b/crates/bevy_internal/src/lib.rs
index 87dc85dd3c..085ee803ad 100644
--- a/crates/bevy_internal/src/lib.rs
+++ b/crates/bevy_internal/src/lib.rs
@@ -105,12 +105,24 @@ pub mod render {
     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.
@@ -134,6 +146,12 @@ pub mod wgpu {
     pub use bevy_wgpu::*;
 }
 
+#[cfg(feature = "bevy_wgpu2")]
+pub mod wgpu2 {
+    //! A render backend utilizing [wgpu](https://github.com/gfx-rs/wgpu-rs).
+    pub use bevy_wgpu2::*;
+}
+
 #[cfg(feature = "bevy_dynamic_plugin")]
 pub mod dynamic_plugin {
     pub use bevy_dynamic_plugin::*;
diff --git a/crates/bevy_log/src/lib.rs b/crates/bevy_log/src/lib.rs
index 722afe2fd4..8336cff5f0 100644
--- a/crates/bevy_log/src/lib.rs
+++ b/crates/bevy_log/src/lib.rs
@@ -12,7 +12,7 @@ pub use bevy_utils::tracing::{
     Level,
 };
 
-use bevy_app::{AppBuilder, Plugin};
+use bevy_app::{App, Plugin};
 #[cfg(feature = "tracing-chrome")]
 use tracing_subscriber::fmt::{format::DefaultFields, FormattedFields};
 use tracing_subscriber::{prelude::*, registry::Registry, EnvFilter};
@@ -81,11 +81,9 @@ impl Default for LogSettings {
 }
 
 impl Plugin for LogPlugin {
-    fn build(&self, app: &mut AppBuilder) {
+    fn build(&self, app: &mut App) {
         let default_filter = {
-            let settings = app
-                .world_mut()
-                .get_resource_or_insert_with(LogSettings::default);
+            let settings = app.world.get_resource_or_insert_with(LogSettings::default);
             format!("{},{}", settings.level, settings.filter)
         };
 
diff --git a/crates/bevy_pbr/src/lib.rs b/crates/bevy_pbr/src/lib.rs
index e279fe8b8d..0b24219d65 100644
--- a/crates/bevy_pbr/src/lib.rs
+++ b/crates/bevy_pbr/src/lib.rs
@@ -29,7 +29,7 @@ use render_graph::add_pbr_graph;
 pub struct PbrPlugin;
 
 impl Plugin for PbrPlugin {
-    fn build(&self, app: &mut AppBuilder) {
+    fn build(&self, app: &mut App) {
         app.add_asset::<StandardMaterial>()
             .register_type::<PointLight>()
             .add_system_to_stage(
@@ -37,11 +37,11 @@ impl Plugin for PbrPlugin {
                 shader::asset_shader_defs_system::<StandardMaterial>.system(),
             )
             .init_resource::<AmbientLight>();
-        add_pbr_graph(app.world_mut());
+        add_pbr_graph(&mut app.world);
 
         // add default StandardMaterial
         let mut materials = app
-            .world_mut()
+            .world
             .get_resource_mut::<Assets<StandardMaterial>>()
             .unwrap();
         materials.set_untracked(
diff --git a/crates/bevy_render/src/lib.rs b/crates/bevy_render/src/lib.rs
index 0bd7c77f58..8eb28cfb02 100644
--- a/crates/bevy_render/src/lib.rs
+++ b/crates/bevy_render/src/lib.rs
@@ -228,8 +228,8 @@ impl Plugin for RenderPlugin {
         );
 
         if let Some(ref config) = self.base_render_graph_config {
-            crate::base::add_base_graph(config, app.world_mut());
-            let mut active_cameras = app.world_mut().get_resource_mut::<ActiveCameras>().unwrap();
+            crate::base::add_base_graph(config, &mut app.world);
+            let mut active_cameras = app.world.get_resource_mut::<ActiveCameras>().unwrap();
             if config.add_3d_camera {
                 active_cameras.add(base::camera::CAMERA_3D);
             }
diff --git a/crates/bevy_render/src/wireframe/mod.rs b/crates/bevy_render/src/wireframe/mod.rs
index a2862d4ee3..c6b918540d 100644
--- a/crates/bevy_render/src/wireframe/mod.rs
+++ b/crates/bevy_render/src/wireframe/mod.rs
@@ -25,10 +25,10 @@ pub const WIREFRAME_PIPELINE_HANDLE: HandleUntyped =
 pub struct WireframePlugin;
 
 impl Plugin for WireframePlugin {
-    fn build(&self, app: &mut AppBuilder) {
+    fn build(&self, app: &mut App) {
         app.init_resource::<WireframeConfig>()
             .add_system_to_stage(crate::RenderStage::Draw, draw_wireframes_system.system());
-        let world = app.world_mut().cell();
+        let world = app.world.cell();
         let mut shaders = world.get_resource_mut::<Assets<Shader>>().unwrap();
         let mut pipelines = world
             .get_resource_mut::<Assets<PipelineDescriptor>>()
diff --git a/crates/bevy_scene/src/lib.rs b/crates/bevy_scene/src/lib.rs
index 3c59044aa6..7c35b9ba11 100644
--- a/crates/bevy_scene/src/lib.rs
+++ b/crates/bevy_scene/src/lib.rs
@@ -26,7 +26,7 @@ use bevy_ecs::{schedule::ExclusiveSystemDescriptorCoercion, system::IntoExclusiv
 pub struct ScenePlugin;
 
 impl Plugin for ScenePlugin {
-    fn build(&self, app: &mut AppBuilder) {
+    fn build(&self, app: &mut App) {
         app.add_asset::<DynamicScene>()
             .add_asset::<Scene>()
             .init_asset_loader::<SceneLoader>()
diff --git a/crates/bevy_sprite/src/lib.rs b/crates/bevy_sprite/src/lib.rs
index eebb2bc252..3dd0b5390b 100644
--- a/crates/bevy_sprite/src/lib.rs
+++ b/crates/bevy_sprite/src/lib.rs
@@ -67,7 +67,7 @@ pub const QUAD_HANDLE: HandleUntyped =
     HandleUntyped::weak_from_u64(Mesh::TYPE_UUID, 14240461981130137526);
 
 impl Plugin for SpritePlugin {
-    fn build(&self, app: &mut AppBuilder) {
+    fn build(&self, app: &mut App) {
         app.add_asset::<ColorMaterial>()
             .add_asset::<TextureAtlas>()
             .register_type::<Sprite>()
@@ -83,7 +83,7 @@ impl Plugin for SpritePlugin {
             );
 
         let sprite_settings = app
-            .world_mut()
+            .world
             .get_resource_or_insert_with(SpriteSettings::default)
             .clone();
         if sprite_settings.frustum_culling_enabled {
@@ -96,14 +96,13 @@ impl Plugin for SpritePlugin {
                 frustum_culling::atlas_frustum_culling_system.system(),
             );
         }
-        let world = app.world_mut();
-        world
+        app.world
             .register_component(ComponentDescriptor::new::<OutsideFrustum>(
                 StorageType::SparseSet,
             ))
             .unwrap();
 
-        let world_cell = world.cell();
+        let world_cell = app.world.cell();
         let mut render_graph = world_cell.get_resource_mut::<RenderGraph>().unwrap();
         let mut pipelines = world_cell
             .get_resource_mut::<Assets<PipelineDescriptor>>()
diff --git a/crates/bevy_text/src/lib.rs b/crates/bevy_text/src/lib.rs
index 60a0fe889b..f69ffb4a29 100644
--- a/crates/bevy_text/src/lib.rs
+++ b/crates/bevy_text/src/lib.rs
@@ -38,7 +38,7 @@ pub type DefaultTextPipeline = TextPipeline<Entity>;
 pub struct TextPlugin;
 
 impl Plugin for TextPlugin {
-    fn build(&self, app: &mut AppBuilder) {
+    fn build(&self, app: &mut App) {
         app.add_asset::<Font>()
             .add_asset::<FontAtlasSet>()
             .init_asset_loader::<FontLoader>()
diff --git a/crates/bevy_transform/src/lib.rs b/crates/bevy_transform/src/lib.rs
index 015da737ed..6dfcc81754 100644
--- a/crates/bevy_transform/src/lib.rs
+++ b/crates/bevy_transform/src/lib.rs
@@ -24,7 +24,7 @@ pub enum TransformSystem {
 }
 
 impl Plugin for TransformPlugin {
-    fn build(&self, app: &mut AppBuilder) {
+    fn build(&self, app: &mut App) {
         app.register_type::<Children>()
             .register_type::<Parent>()
             .register_type::<PreviousParent>()
diff --git a/crates/bevy_ui/src/lib.rs b/crates/bevy_ui/src/lib.rs
index 5efc21537e..862aa66e17 100644
--- a/crates/bevy_ui/src/lib.rs
+++ b/crates/bevy_ui/src/lib.rs
@@ -43,7 +43,7 @@ pub enum UiSystem {
 }
 
 impl Plugin for UiPlugin {
-    fn build(&self, app: &mut AppBuilder) {
+    fn build(&self, app: &mut App) {
         app.init_resource::<FlexSurface>()
             .register_type::<AlignContent>()
             .register_type::<AlignItems>()
@@ -92,6 +92,6 @@ impl Plugin for UiPlugin {
             )
             .add_system_to_stage(RenderStage::Draw, widget::draw_text_system.system());
 
-        crate::render::add_ui_graph(app.world_mut());
+        crate::render::add_ui_graph(&mut app.world);
     }
 }
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 4184966cc0..8dc74d543a 100644
--- a/crates/bevy_wgpu/src/diagnostic/wgpu_resource_diagnostics_plugin.rs
+++ b/crates/bevy_wgpu/src/diagnostic/wgpu_resource_diagnostics_plugin.rs
@@ -8,7 +8,7 @@ use bevy_render::renderer::RenderResourceContext;
 pub struct WgpuResourceDiagnosticsPlugin;
 
 impl Plugin for WgpuResourceDiagnosticsPlugin {
-    fn build(&self, app: &mut AppBuilder) {
+    fn build(&self, app: &mut App) {
         app.add_startup_system(Self::setup_system.system())
             .add_system(Self::diagnostic_system.system());
     }
diff --git a/crates/bevy_wgpu/src/lib.rs b/crates/bevy_wgpu/src/lib.rs
index 35a6fd9afb..75d2567d0c 100644
--- a/crates/bevy_wgpu/src/lib.rs
+++ b/crates/bevy_wgpu/src/lib.rs
@@ -104,8 +104,8 @@ impl Default for WgpuLimits {
 pub struct WgpuPlugin;
 
 impl Plugin for WgpuPlugin {
-    fn build(&self, app: &mut AppBuilder) {
-        let render_system = get_wgpu_render_system(app.world_mut());
+    fn build(&self, app: &mut App) {
+        let render_system = get_wgpu_render_system(&mut app.world);
         app.add_system_to_stage(RenderStage::Render, render_system.exclusive_system())
             .add_system_to_stage(
                 RenderStage::PostRender,
diff --git a/crates/bevy_window/src/lib.rs b/crates/bevy_window/src/lib.rs
index 29b5d8d56b..02aaa3bfa1 100644
--- a/crates/bevy_window/src/lib.rs
+++ b/crates/bevy_window/src/lib.rs
@@ -34,7 +34,7 @@ impl Default for WindowPlugin {
 }
 
 impl Plugin for WindowPlugin {
-    fn build(&self, app: &mut AppBuilder) {
+    fn build(&self, app: &mut App) {
         app.add_event::<WindowResized>()
             .add_event::<CreateWindow>()
             .add_event::<WindowCreated>()
@@ -52,12 +52,15 @@ impl Plugin for WindowPlugin {
             .init_resource::<Windows>();
 
         if self.add_primary_window {
-            let world = app.world_mut();
-            let window_descriptor = world
+            let window_descriptor = app
+                .world
                 .get_resource::<WindowDescriptor>()
                 .map(|descriptor| (*descriptor).clone())
                 .unwrap_or_else(WindowDescriptor::default);
-            let mut create_window_event = world.get_resource_mut::<Events<CreateWindow>>().unwrap();
+            let mut create_window_event = app
+                .world
+                .get_resource_mut::<Events<CreateWindow>>()
+                .unwrap();
             create_window_event.send(CreateWindow {
                 id: WindowId::primary(),
                 descriptor: window_descriptor,
diff --git a/crates/bevy_winit/src/lib.rs b/crates/bevy_winit/src/lib.rs
index a73960890f..af072b7a60 100644
--- a/crates/bevy_winit/src/lib.rs
+++ b/crates/bevy_winit/src/lib.rs
@@ -10,7 +10,7 @@ use bevy_input::{
 pub use winit_config::*;
 pub use winit_windows::*;
 
-use bevy_app::{App, AppBuilder, AppExit, CoreStage, Events, ManualEventReader, Plugin};
+use bevy_app::{App, AppExit, CoreStage, Events, ManualEventReader, Plugin};
 use bevy_ecs::{system::IntoExclusiveSystem, world::World};
 use bevy_math::{ivec2, Vec2};
 use bevy_utils::tracing::{error, trace, warn};
@@ -39,7 +39,7 @@ use winit::platform::unix::EventLoopExtUnix;
 pub struct WinitPlugin;
 
 impl Plugin for WinitPlugin {
-    fn build(&self, app: &mut AppBuilder) {
+    fn build(&self, app: &mut App) {
         app.init_resource::<WinitWindows>()
             .set_runner(winit_runner)
             .add_system_to_stage(CoreStage::PostUpdate, change_window.exclusive_system());
diff --git a/crates/crevice/CHANGELOG.md b/crates/crevice/CHANGELOG.md
new file mode 100644
index 0000000000..4400505fb8
--- /dev/null
+++ b/crates/crevice/CHANGELOG.md
@@ -0,0 +1,39 @@
+# Crevice Changelog
+
+## Unreleased Changes
+
+## [0.6.0][0.6.0] (2021-02-24)
+* Added `std430` support. Most APIs between `std140` and `std430` are the same!
+* Added the `WriteStd140` trait. This trait is more general than `AsStd140` and is automatically implemented for all existing `AsStd140` implementers.
+* Added `Writer::write_std140` to write a type that implements `Std140`.
+* Added `AsStd140::std140_size_static`. This is similar to the old size method, `std140_size`, but no longer requires a value to be passed. For size measurements that depend on a value, use `WriteStd140::std140_size` instead.
+* Deprecated `Writer::write_slice`, as `Writer::write` now accepts slices.
+* Changed bounds of some functions, like `Writer::write` to use `WriteStd140` instead of `AsStd140`. This should affect no existing consumers.
+* Moved `std140_size` from `AsStd140` to `WriteStd140`. Some existing consumers may need to import the other trait to access this m ethod.
+
+[0.6.0]: https://github.com/LPGhatguy/crevice/releases/tag/v0.6.0
+
+## 0.5.0 (2020-10-18)
+* Added f64-based std140 types: `DVec2`, `DVec3`, `DVec4`, `DMat2`, `DMat3`, and `DMat4`.
+* Added support for std140 structs with alignment greater than 16.
+* Fixed padding for std140 matrices; they were previously missing trailing padding.
+
+## 0.4.0 (2020-10-01)
+* Added `AsStd140::std140_size` for easily pre-sizing buffers.
+* `Writer::write` and `Sizer::add` now return the offset the value is or would be written to.
+* Added `std140::DynamicUniform` for aligning dynamic uniform members.
+* Added `Writer::write_slice` for writing multiple values in a row.
+
+## 0.3.0 (2020-09-22)
+* Added `Std140::as_bytes`, reducing the need to work with bytemuck directly.
+* Removed public re-export of bytemuck.
+
+## 0.2.0 (2020-09-22)
+* Added documentation for everything in the crate.
+* Removed `type_layout` being exposed except for internal tests.
+* Fixed alignment offset not taking into account previously added alignment.
+* Added `std140::Writer`, for writing dynamically laid out types to buffers.
+* Added `std140::Sizer`, for pre-calculating buffer sizes.
+
+## 0.1.0 (2020-09-18)
+* Initial MVP release
diff --git a/crates/crevice/Cargo.toml b/crates/crevice/Cargo.toml
new file mode 100644
index 0000000000..b7e3eb05f9
--- /dev/null
+++ b/crates/crevice/Cargo.toml
@@ -0,0 +1,27 @@
+[package]
+name = "crevice"
+description = "Create GLSL-compatible versions of structs with explicitly-initialized padding"
+version = "0.6.0"
+edition = "2018"
+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"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+crevice-derive = "0.6.0"
+
+bytemuck = "1.4.1"
+mint = { version = "0.5.5", optional = true }
+glam = "0.15.1"
+
+[dev-dependencies]
+cgmath = { version = "0.17.0", features = ["mint"] }
+insta = "0.16.1"
+type-layout = { version = "0.2.0", features = ["serde1"] }
+crevice-derive = { version = "0.6.0", features = ["test_type_layout"] }
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..d8a700e6a9
--- /dev/null
+++ b/crates/crevice/README.md
@@ -0,0 +1,135 @@
+# 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 `mint` types
+and explicitly initializes padding to remove one source of undefined behavior.
+
+Examples in this crate use cgmath, but any math crate that works with the mint
+crate will also work. Some other crates include nalgebra, ultraviolet, glam, and
+vek.
+
+### Examples
+
+#### Single Value
+
+Uploading many types can be done by deriving `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};
+use cgmath::prelude::*;
+use cgmath::{Matrix3, Vector3};
+
+#[derive(AsStd140)]
+struct MainUniform {
+    orientation: mint::ColumnMatrix3<f32>,
+    position: mint::Vector3<f32>,
+    scale: f32,
+}
+
+let value = MainUniform {
+    orientation: Matrix3::identity().into(),
+    position: Vector3::new(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` 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();
+
+```
+
+### Minimum Supported Rust Version (MSRV)
+
+Crevice supports Rust 1.46.0 and newer due to use of new `const fn` features.
+
+[glsl-layout]: https://github.com/rustgd/glsl-layout
+[Zeroable]: https://docs.rs/bytemuck/latest/bytemuck/trait.Zeroable.html
+[Pod]: https://docs.rs/bytemuck/latest/bytemuck/trait.Pod.html
+[TypeLayout]: https://docs.rs/type-layout/latest/type_layout/trait.TypeLayout.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.
diff --git a/crates/crevice/README.tpl b/crates/crevice/README.tpl
new file mode 100644
index 0000000000..04934c443b
--- /dev/null
+++ b/crates/crevice/README.tpl
@@ -0,0 +1,15 @@
+# Crevice
+
+{{readme}}
+
+## 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/src/glam.rs b/crates/crevice/src/glam.rs
new file mode 100644
index 0000000000..1c5b604aa2
--- /dev/null
+++ b/crates/crevice/src/glam.rs
@@ -0,0 +1,78 @@
+use bytemuck::Zeroable;
+
+use crate::std140::{self, AsStd140};
+use crate::std430::{self, AsStd430};
+
+macro_rules! glam_vectors {
+    ( $( $glam_ty:ty, $std_name:ident, ( $($field:ident),* ), )* ) => {
+        $(
+            impl AsStd140 for $glam_ty {
+                type Std140Type = std140::$std_name;
+
+                fn as_std140(&self) -> Self::Std140Type {
+                    std140::$std_name {
+                        $(
+                            $field: self.$field,
+                        )*
+                    }
+                }
+            }
+
+            impl AsStd430 for $glam_ty {
+                type Std430Type = std430::$std_name;
+
+                fn as_std430(&self) -> Self::Std430Type {
+                    std430::$std_name {
+                        $(
+                            $field: self.$field,
+                        )*
+                    }
+                }
+            }
+        )*
+    };
+}
+
+glam_vectors! {
+    glam::Vec2, Vec2, (x, y),
+    glam::Vec3, Vec3, (x, y, z),
+    glam::Vec4, Vec4, (x, y, z, w),
+}
+
+macro_rules! glam_matrices {
+    ( $( $glam_ty:ty, $std_name:ident, ( $($glam_field:ident),* ), ( $($field:ident),* ))* ) => {
+        $(
+            impl AsStd140 for $glam_ty {
+                type Std140Type = std140::$std_name;
+
+                fn as_std140(&self) -> Self::Std140Type {
+                    std140::$std_name {
+                        $(
+                            $field: self.$glam_field.as_std140(),
+                        )*
+                        ..Zeroable::zeroed()
+                    }
+                }
+            }
+
+            impl AsStd430 for $glam_ty {
+                type Std430Type = std430::$std_name;
+
+                fn as_std430(&self) -> Self::Std430Type {
+                    std430::$std_name {
+                        $(
+                            $field: self.$glam_field.as_std430(),
+                        )*
+                        ..Zeroable::zeroed()
+                    }
+                }
+            }
+        )*
+    };
+}
+
+glam_matrices! {
+    glam::Mat2, Mat2, (x_axis, y_axis), (x, y)
+    glam::Mat3, Mat3, (x_axis, y_axis, z_axis), (x, y, z)
+    glam::Mat4, Mat4, (x_axis, y_axis, z_axis, w_axis), (x, y, z, w)
+}
diff --git a/crates/crevice/src/internal.rs b/crates/crevice/src/internal.rs
new file mode 100644
index 0000000000..cf5a22f368
--- /dev/null
+++ b/crates/crevice/src/internal.rs
@@ -0,0 +1,23 @@
+//! This module is internal to crevice but used by its derive macro. No
+//! guarantees are made about its contents.
+
+pub use bytemuck;
+
+/// Align the given struct offset up to the given alignment.
+pub const fn align_offset(offset: usize, alignment: usize) -> usize {
+    if 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
+    }
+}
diff --git a/crates/crevice/src/lib.rs b/crates/crevice/src/lib.rs
new file mode 100644
index 0000000000..bef2871cd6
--- /dev/null
+++ b/crates/crevice/src/lib.rs
@@ -0,0 +1,142 @@
+/*!
+[![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 `mint` types
+and explicitly initializes padding to remove one source of undefined behavior.
+
+Examples in this crate use cgmath, but any math crate that works with the mint
+crate will also work. Some other crates include nalgebra, ultraviolet, glam, and
+vek.
+
+## Examples
+
+### Single Value
+
+Uploading many types can be done by deriving `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};
+use cgmath::prelude::*;
+use cgmath::{Matrix3, Vector3};
+
+#[derive(AsStd140)]
+struct MainUniform {
+    orientation: mint::ColumnMatrix3<f32>,
+    position: mint::Vector3<f32>,
+    scale: f32,
+}
+
+let value = MainUniform {
+    orientation: Matrix3::identity().into(),
+    position: Vector3::new(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` 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>(())
+```
+
+## Minimum Supported Rust Version (MSRV)
+
+Crevice supports Rust 1.46.0 and newer due to use of new `const fn` features.
+
+[glsl-layout]: https://github.com/rustgd/glsl-layout
+[Zeroable]: https://docs.rs/bytemuck/latest/bytemuck/trait.Zeroable.html
+[Pod]: https://docs.rs/bytemuck/latest/bytemuck/trait.Pod.html
+[TypeLayout]: https://docs.rs/type-layout/latest/type_layout/trait.TypeLayout.html
+*/
+
+#![deny(missing_docs)]
+
+pub mod std140;
+pub mod std430;
+
+#[doc(hidden)]
+pub mod internal;
+
+#[cfg(feature = "mint")]
+mod mint;
+
+mod glam;
\ No newline at end of file
diff --git a/crates/crevice/src/mint.rs b/crates/crevice/src/mint.rs
new file mode 100644
index 0000000000..f175d349b6
--- /dev/null
+++ b/crates/crevice/src/mint.rs
@@ -0,0 +1,78 @@
+use bytemuck::Zeroable;
+
+use crate::std140::{self, AsStd140};
+use crate::std430::{self, AsStd430};
+
+macro_rules! mint_vectors {
+    ( $( $mint_ty:ty, $std_name:ident, ( $($field:ident),* ), )* ) => {
+        $(
+            impl AsStd140 for $mint_ty {
+                type Std140Type = std140::$std_name;
+
+                fn as_std140(&self) -> Self::Std140Type {
+                    std140::$std_name {
+                        $(
+                            $field: self.$field,
+                        )*
+                    }
+                }
+            }
+
+            impl AsStd430 for $mint_ty {
+                type Std430Type = std430::$std_name;
+
+                fn as_std430(&self) -> Self::Std430Type {
+                    std430::$std_name {
+                        $(
+                            $field: self.$field,
+                        )*
+                    }
+                }
+            }
+        )*
+    };
+}
+
+mint_vectors! {
+    mint::Vector2<f32>, Vec2, (x, y),
+    mint::Vector3<f32>, Vec3, (x, y, z),
+    mint::Vector4<f32>, Vec4, (x, y, z, w),
+}
+
+macro_rules! mint_matrices {
+    ( $( $mint_ty:ty, $std_name:ident, ( $($field:ident),* ), )* ) => {
+        $(
+            impl AsStd140 for $mint_ty {
+                type Std140Type = std140::$std_name;
+
+                fn as_std140(&self) -> Self::Std140Type {
+                    std140::$std_name {
+                        $(
+                            $field: self.$field.as_std140(),
+                        )*
+                        ..Zeroable::zeroed()
+                    }
+                }
+            }
+
+            impl AsStd430 for $mint_ty {
+                type Std430Type = std430::$std_name;
+
+                fn as_std430(&self) -> Self::Std430Type {
+                    std430::$std_name {
+                        $(
+                            $field: self.$field.as_std430(),
+                        )*
+                        ..Zeroable::zeroed()
+                    }
+                }
+            }
+        )*
+    };
+}
+
+mint_matrices! {
+    mint::ColumnMatrix2<f32>, Mat2, (x, y),
+    mint::ColumnMatrix3<f32>, Mat3, (x, y, z),
+    mint::ColumnMatrix4<f32>, Mat4, (x, y, z, w),
+}
diff --git a/crates/crevice/src/std140.rs b/crates/crevice/src/std140.rs
new file mode 100644
index 0000000000..82902f9533
--- /dev/null
+++ b/crates/crevice/src/std140.rs
@@ -0,0 +1,16 @@
+//! Defines traits and types for working with data adhering to GLSL's `std140`
+//! layout specification.
+
+mod dynamic_uniform;
+mod primitives;
+mod sizer;
+mod traits;
+mod writer;
+
+pub use self::dynamic_uniform::*;
+pub use self::primitives::*;
+pub use self::sizer::*;
+pub use self::traits::*;
+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..b64443370e
--- /dev/null
+++ b/crates/crevice/src/std140/dynamic_uniform.rs
@@ -0,0 +1,56 @@
+use bytemuck::{Pod, Zeroable};
+
+use crate::internal::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 Std140Type = DynamicUniformStd140<<T as AsStd140>::Std140Type>;
+
+    fn as_std140(&self) -> Self::Std140Type {
+        DynamicUniformStd140(self.0.as_std140())
+    }
+}
+
+/// 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);
+}
+
+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..18f7a6581c
--- /dev/null
+++ b/crates/crevice/src/std140/primitives.rs
@@ -0,0 +1,151 @@
+use bytemuck::{Pod, Zeroable};
+
+use crate::std140::Std140;
+
+unsafe impl Std140 for f32 {
+    const ALIGNMENT: usize = 4;
+}
+
+unsafe impl Std140 for f64 {
+    const ALIGNMENT: usize = 8;
+}
+
+unsafe impl Std140 for i32 {
+    const ALIGNMENT: usize = 4;
+}
+
+unsafe impl Std140 for u32 {
+    const ALIGNMENT: usize = 4;
+}
+
+macro_rules! vectors {
+    (
+        $(
+            #[$doc:meta] align($align:literal) $name:ident <$prim:ident> ($($field:ident),+)
+        )+
+    ) => {
+        $(
+            #[$doc]
+            #[allow(missing_docs)]
+            #[derive(Debug, Clone, Copy)]
+            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;
+            }
+        )+
+    };
+}
+
+vectors! {
+    #[doc = "Corresponds to a GLSL `vec2` in std140 layout."] align(8) Vec2<f32>(x, y)
+    #[doc = "Corresponds to a GLSL `vec3` in std140 layout."] align(16) Vec3<f32>(x, y, z)
+    #[doc = "Corresponds to a GLSL `vec4` in std140 layout."] align(16) Vec4<f32>(x, y, z, w)
+
+    #[doc = "Corresponds to a GLSL `ivec2` in std140 layout."] align(8) IVec2<i32>(x, y)
+    #[doc = "Corresponds to a GLSL `ivec3` in std140 layout."] align(16) IVec3<i32>(x, y, z)
+    #[doc = "Corresponds to a GLSL `ivec4` in std140 layout."] align(16) IVec4<i32>(x, y, z, w)
+
+    #[doc = "Corresponds to a GLSL `uvec2` in std140 layout."] align(8) UVec2<u32>(x, y)
+    #[doc = "Corresponds to a GLSL `uvec3` in std140 layout."] align(16) UVec3<u32>(x, y, z)
+    #[doc = "Corresponds to a GLSL `uvec4` in std140 layout."] align(16) UVec4<u32>(x, y, z, w)
+
+    #[doc = "Corresponds to a GLSL `bvec2` in std140 layout."] align(8) BVec2<bool>(x, y)
+    #[doc = "Corresponds to a GLSL `bvec3` in std140 layout."] align(16) BVec3<bool>(x, y, z)
+    #[doc = "Corresponds to a GLSL `bvec4` in std140 layout."] align(16) BVec4<bool>(x, y, z, w)
+
+    #[doc = "Corresponds to a GLSL `dvec2` in std140 layout."] align(16) DVec2<f64>(x, y)
+    #[doc = "Corresponds to a GLSL `dvec3` in std140 layout."] align(32) DVec3<f64>(x, y, z)
+    #[doc = "Corresponds to a GLSL `dvec4` in std140 layout."] align(32) DVec4<f64>(x, y, z, w)
+}
+
+macro_rules! matrices {
+    (
+        $(
+            #[$doc:meta]
+            align($align:literal)
+            $name:ident {
+                $($field:ident: $field_ty:ty,)+
+            }
+        )+
+    ) => {
+        $(
+            #[$doc]
+            #[allow(missing_docs)]
+            #[derive(Debug, Clone, Copy)]
+            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! {
+    #[doc = "Corresponds to a GLSL `mat2` in std140 layout."]
+    align(16)
+    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 {
+        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 {
+        x: Vec4,
+        y: Vec4,
+        z: Vec4,
+        w: Vec4,
+    }
+
+    #[doc = "Corresponds to a GLSL `dmat2` in std140 layout."]
+    align(16)
+    DMat2 {
+        x: DVec2,
+        y: DVec2,
+    }
+
+    #[doc = "Corresponds to a GLSL `dmat3` in std140 layout."]
+    align(32)
+    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 {
+        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..452e66922e
--- /dev/null
+++ b/crates/crevice/src/std140/sizer.rs
@@ -0,0 +1,81 @@
+use std::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>::Std140Type>();
+        let alignment = <T as AsStd140>::Std140Type::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..1352264963
--- /dev/null
+++ b/crates/crevice/src/std140/traits.rs
@@ -0,0 +1,160 @@
+use std::io::{self, Write};
+use std::mem::size_of;
+
+use bytemuck::{bytes_of, Pod, Zeroable};
+
+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;
+
+    /// 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 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 geometry crates, like cgmath, nalgebra, and
+ultraviolet support mint.
+
+## Example
+
+```glsl
+uniform CAMERA {
+    mat4 view;
+    mat4 projection;
+} camera;
+```
+
+```
+use cgmath::prelude::*;
+use cgmath::{Matrix4, Deg, perspective};
+use crevice::std140::{AsStd140, Std140};
+
+#[derive(AsStd140)]
+struct CameraUniform {
+    view: mint::ColumnMatrix4<f32>,
+    projection: mint::ColumnMatrix4<f32>,
+}
+
+let camera = CameraUniform {
+    view: Matrix4::identity().into(),
+    projection: perspective(Deg(60.0), 16.0/9.0, 0.01, 100.0).into(),
+};
+
+# 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 Std140Type: Std140;
+
+    /// Convert this value into the `std140` version of itself.
+    fn as_std140(&self) -> Self::Std140Type;
+
+    /// Returns the size of the `std140` version of this type. Useful for
+    /// pre-sizing buffers.
+    fn std140_size_static() -> usize {
+        size_of::<Self::Std140Type>()
+    }
+}
+
+impl<T> AsStd140 for T
+where
+    T: Std140,
+{
+    type Std140Type = Self;
+
+    fn as_std140(&self) -> Self {
+        *self
+    }
+}
+
+/// 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.
+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()
+    }
+}
+
+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>::Std140Type>()
+    }
+}
+
+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..977a75c505
--- /dev/null
+++ b/crates/crevice/src/std430.rs
@@ -0,0 +1,14 @@
+//! Defines traits and types for working with data adhering to GLSL's `std140`
+//! layout specification.
+
+mod primitives;
+mod sizer;
+mod traits;
+mod writer;
+
+pub use self::primitives::*;
+pub use self::sizer::*;
+pub use self::traits::*;
+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..35ae651b7e
--- /dev/null
+++ b/crates/crevice/src/std430/primitives.rs
@@ -0,0 +1,143 @@
+use bytemuck::{Pod, Zeroable};
+
+use crate::std430::Std430;
+
+unsafe impl Std430 for f32 {
+    const ALIGNMENT: usize = 4;
+}
+
+unsafe impl Std430 for f64 {
+    const ALIGNMENT: usize = 8;
+}
+
+unsafe impl Std430 for i32 {
+    const ALIGNMENT: usize = 4;
+}
+
+unsafe impl Std430 for u32 {
+    const ALIGNMENT: usize = 4;
+}
+
+macro_rules! vectors {
+    (
+        $(
+            #[$doc:meta] align($align:literal) $name:ident <$prim:ident> ($($field:ident),+)
+        )+
+    ) => {
+        $(
+            #[$doc]
+            #[allow(missing_docs)]
+            #[derive(Debug, Clone, Copy)]
+            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;
+            }
+        )+
+    };
+}
+
+vectors! {
+    #[doc = "Corresponds to a GLSL `vec2` in std430 layout."] align(8) Vec2<f32>(x, y)
+    #[doc = "Corresponds to a GLSL `vec3` in std430 layout."] align(16) Vec3<f32>(x, y, z)
+    #[doc = "Corresponds to a GLSL `vec4` in std430 layout."] align(16) Vec4<f32>(x, y, z, w)
+
+    #[doc = "Corresponds to a GLSL `ivec2` in std140 layout."] align(8) IVec2<i32>(x, y)
+    #[doc = "Corresponds to a GLSL `ivec3` in std140 layout."] align(16) IVec3<i32>(x, y, z)
+    #[doc = "Corresponds to a GLSL `ivec4` in std140 layout."] align(16) IVec4<i32>(x, y, z, w)
+
+    #[doc = "Corresponds to a GLSL `uvec2` in std140 layout."] align(8) UVec2<u32>(x, y)
+    #[doc = "Corresponds to a GLSL `uvec3` in std140 layout."] align(16) UVec3<u32>(x, y, z)
+    #[doc = "Corresponds to a GLSL `uvec4` in std140 layout."] align(16) UVec4<u32>(x, y, z, w)
+
+    #[doc = "Corresponds to a GLSL `bvec2` in std140 layout."] align(8) BVec2<bool>(x, y)
+    #[doc = "Corresponds to a GLSL `bvec3` in std140 layout."] align(16) BVec3<bool>(x, y, z)
+    #[doc = "Corresponds to a GLSL `bvec4` in std140 layout."] align(16) BVec4<bool>(x, y, z, w)
+
+    #[doc = "Corresponds to a GLSL `dvec2` in std430 layout."] align(16) DVec2<f64>(x, y)
+    #[doc = "Corresponds to a GLSL `dvec3` in std430 layout."] align(32) DVec3<f64>(x, y, z)
+    #[doc = "Corresponds to a GLSL `dvec4` in std430 layout."] align(32) DVec4<f64>(x, y, z, w)
+}
+
+macro_rules! matrices {
+    (
+        $(
+            #[$doc:meta]
+            align($align:literal)
+            $name:ident {
+                $($field:ident: $field_ty:ty,)+
+            }
+        )+
+    ) => {
+        $(
+            #[$doc]
+            #[allow(missing_docs)]
+            #[derive(Debug, Clone, Copy)]
+            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! {
+    #[doc = "Corresponds to a GLSL `mat2` in std430 layout."]
+    align(16)
+    Mat2 {
+        x: Vec2,
+        y: Vec2,
+    }
+
+    #[doc = "Corresponds to a GLSL `mat3` in std430 layout."]
+    align(16)
+    Mat3 {
+        x: Vec3,
+        y: Vec3,
+        z: Vec3,
+    }
+
+    #[doc = "Corresponds to a GLSL `mat4` in std430 layout."]
+    align(16)
+    Mat4 {
+        x: Vec4,
+        y: Vec4,
+        z: Vec4,
+        w: Vec4,
+    }
+
+    #[doc = "Corresponds to a GLSL `dmat2` in std430 layout."]
+    align(16)
+    DMat2 {
+        x: DVec2,
+        y: DVec2,
+    }
+
+    #[doc = "Corresponds to a GLSL `dmat3` in std430 layout."]
+    align(32)
+    DMat3 {
+        x: DVec3,
+        y: DVec3,
+        z: DVec3,
+    }
+
+    #[doc = "Corresponds to a GLSL `dmat3` in std430 layout."]
+    align(32)
+    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..c418ed93fd
--- /dev/null
+++ b/crates/crevice/src/std430/sizer.rs
@@ -0,0 +1,81 @@
+use std::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>::Std430Type>();
+        let alignment = <T as AsStd430>::Std430Type::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..a7785bab01
--- /dev/null
+++ b/crates/crevice/src/std430/traits.rs
@@ -0,0 +1,159 @@
+use std::io::{self, Write};
+use std::mem::size_of;
+
+use bytemuck::{bytes_of, Pod, Zeroable};
+
+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;
+
+    /// 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 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;
+```
+
+```skip
+use cgmath::prelude::*;
+use cgmath::{Matrix4, Deg, perspective};
+use crevice::std430::{AsStd430, Std430};
+
+#[derive(AsStd430)]
+struct CameraUniform {
+    view: mint::ColumnMatrix4<f32>,
+    projection: mint::ColumnMatrix4<f32>,
+}
+
+let camera = CameraUniform {
+    view: Matrix4::identity().into(),
+    projection: perspective(Deg(60.0), 16.0/9.0, 0.01, 100.0).into(),
+};
+
+# 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 Std430Type: Std430;
+
+    /// Convert this value into the `std430` version of itself.
+    fn as_std430(&self) -> Self::Std430Type;
+
+    /// Returns the size of the `std430` version of this type. Useful for
+    /// pre-sizing buffers.
+    fn std430_size_static() -> usize {
+        size_of::<Self::Std430Type>()
+    }
+}
+
+impl<T> AsStd430 for T
+where
+    T: Std430,
+{
+    type Std430Type = Self;
+
+    fn as_std430(&self) -> Self {
+        *self
+    }
+}
+
+/// 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.
+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()
+    }
+}
+
+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>::Std430Type>()
+    }
+}
+
+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/tests/snapshots/std140__more_than_16_alignment.snap b/crates/crevice/tests/snapshots/std140__more_than_16_alignment.snap
new file mode 100644
index 0000000000..99f9a97448
--- /dev/null
+++ b/crates/crevice/tests/snapshots/std140__more_than_16_alignment.snap
@@ -0,0 +1,16 @@
+---
+source: tests/std140.rs
+expression: "<<MoreThan16Alignment as AsStd140>::Std140Type as TypeLayout>::type_layout()"
+---
+name: Std140MoreThan16Alignment
+size: 32
+alignment: 8
+fields:
+  - Field:
+      name: _doubles_align
+      ty: "[u8 ; Std140MoreThan16AlignmentAlignment :: _doubles_align()]"
+      size: 0
+  - Field:
+      name: doubles
+      ty: "< DVec4 as :: crevice :: std140 :: AsStd140 > :: Std140Type"
+      size: 32
diff --git a/crates/crevice/tests/snapshots/std140__point_light.snap b/crates/crevice/tests/snapshots/std140__point_light.snap
new file mode 100644
index 0000000000..d40a1d1b56
--- /dev/null
+++ b/crates/crevice/tests/snapshots/std140__point_light.snap
@@ -0,0 +1,40 @@
+---
+source: tests/std140.rs
+expression: "<<PointLight as AsStd140>::Std140Type as TypeLayout>::type_layout()"
+---
+name: Std140PointLight
+size: 48
+alignment: 4
+fields:
+  - Field:
+      name: _position_align
+      ty: "[u8 ; Std140PointLightAlignment :: _position_align()]"
+      size: 0
+  - Field:
+      name: position
+      ty: "< Vec3 as :: crevice :: std140 :: AsStd140 > :: Std140Type"
+      size: 12
+  - Field:
+      name: _diffuse_align
+      ty: "[u8 ; Std140PointLightAlignment :: _diffuse_align()]"
+      size: 4
+  - Field:
+      name: diffuse
+      ty: "< Vec3 as :: crevice :: std140 :: AsStd140 > :: Std140Type"
+      size: 12
+  - Field:
+      name: _specular_align
+      ty: "[u8 ; Std140PointLightAlignment :: _specular_align()]"
+      size: 4
+  - Field:
+      name: specular
+      ty: "< Vec3 as :: crevice :: std140 :: AsStd140 > :: Std140Type"
+      size: 12
+  - Field:
+      name: _brightness_align
+      ty: "[u8 ; Std140PointLightAlignment :: _brightness_align()]"
+      size: 0
+  - Field:
+      name: brightness
+      ty: "< f32 as :: crevice :: std140 :: AsStd140 > :: Std140Type"
+      size: 4
diff --git a/crates/crevice/tests/snapshots/std140__primitive_f32.snap b/crates/crevice/tests/snapshots/std140__primitive_f32.snap
new file mode 100644
index 0000000000..dc3b93d4eb
--- /dev/null
+++ b/crates/crevice/tests/snapshots/std140__primitive_f32.snap
@@ -0,0 +1,24 @@
+---
+source: tests/std140.rs
+expression: "<<PrimitiveF32 as AsStd140>::Std140Type as TypeLayout>::layout()"
+---
+name: Std140PrimitiveF32
+size: 8
+alignment: 4
+fields:
+  - Field:
+      name: _x_align
+      ty: "[u8 ; Std140PrimitiveF32Alignment :: _x_align()]"
+      size: 0
+  - Field:
+      name: x
+      ty: "< f32 as :: crevice :: std140 :: AsStd140 > :: Std140Type"
+      size: 4
+  - Field:
+      name: _y_align
+      ty: "[u8 ; Std140PrimitiveF32Alignment :: _y_align()]"
+      size: 0
+  - Field:
+      name: y
+      ty: "< f32 as :: crevice :: std140 :: AsStd140 > :: Std140Type"
+      size: 4
diff --git a/crates/crevice/tests/snapshots/std140__using_vec3_padding.snap b/crates/crevice/tests/snapshots/std140__using_vec3_padding.snap
new file mode 100644
index 0000000000..598e6d010a
--- /dev/null
+++ b/crates/crevice/tests/snapshots/std140__using_vec3_padding.snap
@@ -0,0 +1,24 @@
+---
+source: tests/std140.rs
+expression: "<<UsingVec3Padding as AsStd140>::Std140Type as TypeLayout>::layout()"
+---
+name: Std140UsingVec3Padding
+size: 16
+alignment: 4
+fields:
+  - Field:
+      name: _pos_align
+      ty: "[u8 ; Std140UsingVec3PaddingAlignment :: _pos_align()]"
+      size: 0
+  - Field:
+      name: pos
+      ty: "< Vec3 as :: crevice :: std140 :: AsStd140 > :: Std140Type"
+      size: 12
+  - Field:
+      name: _brightness_align
+      ty: "[u8 ; Std140UsingVec3PaddingAlignment :: _brightness_align()]"
+      size: 0
+  - Field:
+      name: brightness
+      ty: "< f32 as :: crevice :: std140 :: AsStd140 > :: Std140Type"
+      size: 4
diff --git a/crates/crevice/tests/snapshots/std140__vec3.snap b/crates/crevice/tests/snapshots/std140__vec3.snap
new file mode 100644
index 0000000000..fbf99885f7
--- /dev/null
+++ b/crates/crevice/tests/snapshots/std140__vec3.snap
@@ -0,0 +1,24 @@
+---
+source: tests/std140.rs
+expression: "<<TestVec3 as AsStd140>::Std140Type as TypeLayout>::layout()"
+---
+name: Std140TestVec3
+size: 28
+alignment: 4
+fields:
+  - Field:
+      name: _pos_align
+      ty: "[u8 ; Std140TestVec3Alignment :: _pos_align()]"
+      size: 0
+  - Field:
+      name: pos
+      ty: "< Vec3 as :: crevice :: std140 :: AsStd140 > :: Std140Type"
+      size: 12
+  - Field:
+      name: _velocity_align
+      ty: "[u8 ; Std140TestVec3Alignment :: _velocity_align()]"
+      size: 4
+  - Field:
+      name: velocity
+      ty: "< Vec3 as :: crevice :: std140 :: AsStd140 > :: Std140Type"
+      size: 12
diff --git a/crates/crevice/tests/std140.rs b/crates/crevice/tests/std140.rs
new file mode 100644
index 0000000000..112849acd8
--- /dev/null
+++ b/crates/crevice/tests/std140.rs
@@ -0,0 +1,121 @@
+use insta::assert_yaml_snapshot;
+use type_layout::TypeLayout;
+
+use crevice::std140::{AsStd140, DVec4, Std140, Vec3};
+
+#[derive(AsStd140)]
+struct PrimitiveF32 {
+    x: f32,
+    y: f32,
+}
+
+#[test]
+fn primitive_f32() {
+    assert_yaml_snapshot!(<<PrimitiveF32 as AsStd140>::Std140Type as TypeLayout>::type_layout());
+
+    assert_eq!(<PrimitiveF32 as AsStd140>::Std140Type::ALIGNMENT, 16);
+
+    let value = PrimitiveF32 { x: 1.0, y: 2.0 };
+    let _value_std140 = value.as_std140();
+}
+
+#[derive(AsStd140)]
+struct TestVec3 {
+    pos: Vec3,
+    velocity: Vec3,
+}
+
+#[test]
+fn test_vec3() {
+    assert_yaml_snapshot!(<<TestVec3 as AsStd140>::Std140Type as TypeLayout>::type_layout());
+
+    assert_eq!(<TestVec3 as AsStd140>::Std140Type::ALIGNMENT, 16);
+
+    let value = TestVec3 {
+        pos: Vec3 {
+            x: 1.0,
+            y: 2.0,
+            z: 3.0,
+        },
+        velocity: Vec3 {
+            x: 4.0,
+            y: 5.0,
+            z: 6.0,
+        },
+    };
+    let _value_std140 = value.as_std140();
+}
+
+#[derive(AsStd140)]
+struct UsingVec3Padding {
+    pos: Vec3,
+    brightness: f32,
+}
+
+#[test]
+fn using_vec3_padding() {
+    assert_yaml_snapshot!(
+        <<UsingVec3Padding as AsStd140>::Std140Type as TypeLayout>::type_layout()
+    );
+
+    assert_eq!(<UsingVec3Padding as AsStd140>::Std140Type::ALIGNMENT, 16);
+
+    let value = UsingVec3Padding {
+        pos: Vec3 {
+            x: 1.0,
+            y: 2.0,
+            z: 3.0,
+        },
+        brightness: 4.0,
+    };
+    let _value_std140 = value.as_std140();
+}
+
+#[derive(AsStd140)]
+struct PointLight {
+    position: Vec3,
+    diffuse: Vec3,
+    specular: Vec3,
+    brightness: f32,
+}
+
+#[test]
+fn point_light() {
+    assert_yaml_snapshot!(<<PointLight as AsStd140>::Std140Type as TypeLayout>::type_layout());
+
+    assert_eq!(<PointLight as AsStd140>::Std140Type::ALIGNMENT, 16);
+
+    let value = PointLight {
+        position: Vec3 {
+            x: 1.0,
+            y: 2.0,
+            z: 3.0,
+        },
+        diffuse: Vec3 {
+            x: 1.0,
+            y: 2.0,
+            z: 3.0,
+        },
+        specular: Vec3 {
+            x: 1.0,
+            y: 2.0,
+            z: 3.0,
+        },
+        brightness: 4.0,
+    };
+    let _value_std140 = value.as_std140();
+}
+
+#[derive(AsStd140)]
+struct MoreThan16Alignment {
+    doubles: DVec4,
+}
+
+#[test]
+fn more_than_16_alignment() {
+    assert_yaml_snapshot!(
+        <<MoreThan16Alignment as AsStd140>::Std140Type as TypeLayout>::type_layout()
+    );
+
+    assert_eq!(<MoreThan16Alignment as AsStd140>::Std140Type::ALIGNMENT, 32);
+}
diff --git a/examples/2d/contributors.rs b/examples/2d/contributors.rs
index 7dd7db7bb9..6186bb78dd 100644
--- a/examples/2d/contributors.rs
+++ b/examples/2d/contributors.rs
@@ -7,7 +7,7 @@ use std::{
 };
 
 fn main() {
-    App::build()
+    App::new()
         .add_plugins(DefaultPlugins)
         .add_startup_system(setup)
         .add_system(velocity_system)
diff --git a/examples/2d/many_sprites.rs b/examples/2d/many_sprites.rs
index fcf10d8332..32e52a24cf 100644
--- a/examples/2d/many_sprites.rs
+++ b/examples/2d/many_sprites.rs
@@ -15,7 +15,7 @@ pub struct Position(Transform);
 /// This example is for performance testing purposes.
 /// See https://github.com/bevyengine/bevy/pull/1492
 fn main() {
-    App::build()
+    App::new()
         .add_plugin(LogDiagnosticsPlugin::default())
         .add_plugin(FrameTimeDiagnosticsPlugin::default())
         .insert_resource(SpriteSettings {
diff --git a/examples/2d/mesh.rs b/examples/2d/mesh.rs
index 9c1c097867..9a89d678a4 100644
--- a/examples/2d/mesh.rs
+++ b/examples/2d/mesh.rs
@@ -7,7 +7,7 @@ use bevy::{
 };
 
 fn main() {
-    App::build()
+    App::new()
         .add_plugins(DefaultPlugins)
         .add_startup_system(star)
         .run();
diff --git a/examples/2d/sprite.rs b/examples/2d/sprite.rs
index 485bbee34b..b55e237133 100644
--- a/examples/2d/sprite.rs
+++ b/examples/2d/sprite.rs
@@ -1,7 +1,7 @@
 use bevy::prelude::*;
 
 fn main() {
-    App::build()
+    App::new()
         .add_plugins(DefaultPlugins)
         .add_startup_system(setup)
         .run();
@@ -10,12 +10,12 @@ fn main() {
 fn setup(
     mut commands: Commands,
     asset_server: Res<AssetServer>,
-    mut materials: ResMut<Assets<ColorMaterial>>,
+    // mut materials: ResMut<Assets<ColorMaterial>>,
 ) {
-    let texture_handle = asset_server.load("branding/icon.png");
+    // let texture_handle = asset_server.load("branding/icon.png");
     commands.spawn_bundle(OrthographicCameraBundle::new_2d());
     commands.spawn_bundle(SpriteBundle {
-        material: materials.add(texture_handle.into()),
+        // material: materials.add(texture_handle.into()),
         ..Default::default()
     });
 }
diff --git a/examples/2d/sprite_flipping.rs b/examples/2d/sprite_flipping.rs
index 8ba1a32bad..e53a49af6e 100644
--- a/examples/2d/sprite_flipping.rs
+++ b/examples/2d/sprite_flipping.rs
@@ -1,7 +1,7 @@
 use bevy::prelude::*;
 
 fn main() {
-    App::build()
+    App::new()
         .add_plugins(DefaultPlugins)
         .add_startup_system(setup)
         .run();
diff --git a/examples/2d/sprite_sheet.rs b/examples/2d/sprite_sheet.rs
index b697a5fb7d..678e4cb6b3 100644
--- a/examples/2d/sprite_sheet.rs
+++ b/examples/2d/sprite_sheet.rs
@@ -1,7 +1,7 @@
 use bevy::prelude::*;
 
 fn main() {
-    App::build()
+    App::new()
         .add_plugins(DefaultPlugins)
         .add_startup_system(setup)
         .add_system(animate_sprite_system)
diff --git a/examples/2d/text2d.rs b/examples/2d/text2d.rs
index 0f5b07a687..7dae1046f5 100644
--- a/examples/2d/text2d.rs
+++ b/examples/2d/text2d.rs
@@ -1,7 +1,7 @@
 use bevy::prelude::*;
 
 fn main() {
-    App::build()
+    App::new()
         .add_plugins(DefaultPlugins)
         .add_startup_system(setup)
         .add_system(animate_translation)
diff --git a/examples/2d/texture_atlas.rs b/examples/2d/texture_atlas.rs
index 9e9f28ca72..5bae1b57fd 100644
--- a/examples/2d/texture_atlas.rs
+++ b/examples/2d/texture_atlas.rs
@@ -3,7 +3,7 @@ use bevy::{asset::LoadState, prelude::*, sprite::TextureAtlasBuilder};
 /// In this example we generate a new texture atlas (sprite sheet) from a folder containing
 /// individual sprites
 fn main() {
-    App::build()
+    App::new()
         .init_resource::<RpgSpriteHandles>()
         .add_plugins(DefaultPlugins)
         .add_state(AppState::Setup)
diff --git a/examples/3d/3d_scene.rs b/examples/3d/3d_scene.rs
index 3aec65a2e8..e328190ba1 100644
--- a/examples/3d/3d_scene.rs
+++ b/examples/3d/3d_scene.rs
@@ -1,7 +1,7 @@
 use bevy::prelude::*;
 
 fn main() {
-    App::build()
+    App::new()
         .insert_resource(Msaa { samples: 4 })
         .add_plugins(DefaultPlugins)
         .add_startup_system(setup.system())
diff --git a/examples/3d/load_gltf.rs b/examples/3d/load_gltf.rs
index b2eae05b26..27ea98d304 100644
--- a/examples/3d/load_gltf.rs
+++ b/examples/3d/load_gltf.rs
@@ -1,7 +1,7 @@
 use bevy::{pbr::AmbientLight, prelude::*};
 
 fn main() {
-    App::build()
+    App::new()
         .insert_resource(AmbientLight {
             color: Color::WHITE,
             brightness: 1.0 / 5.0f32,
diff --git a/examples/3d/msaa.rs b/examples/3d/msaa.rs
index 6036600aa2..fb153e2992 100644
--- a/examples/3d/msaa.rs
+++ b/examples/3d/msaa.rs
@@ -5,7 +5,7 @@ use bevy::prelude::*;
 /// range should generally be somewhere between 1 (no multi sampling, but cheap) to 8 (crisp but
 /// expensive)
 fn main() {
-    App::build()
+    App::new()
         .insert_resource(Msaa { samples: 4 })
         .add_plugins(DefaultPlugins)
         .add_startup_system(setup.system())
diff --git a/examples/3d/orthographic.rs b/examples/3d/orthographic.rs
index 6e0f7ac5fd..4da52ee86b 100644
--- a/examples/3d/orthographic.rs
+++ b/examples/3d/orthographic.rs
@@ -1,7 +1,7 @@
 use bevy::prelude::*;
 
 fn main() {
-    App::build()
+    App::new()
         .insert_resource(Msaa { samples: 4 })
         .add_plugins(DefaultPlugins)
         .add_startup_system(setup.system())
diff --git a/examples/3d/parenting.rs b/examples/3d/parenting.rs
index 9891b12dda..129c2188f8 100644
--- a/examples/3d/parenting.rs
+++ b/examples/3d/parenting.rs
@@ -3,7 +3,7 @@ use bevy::prelude::*;
 /// This example illustrates how to create parent->child relationships between entities how parent
 /// transforms are propagated to their descendants
 fn main() {
-    App::build()
+    App::new()
         .insert_resource(Msaa { samples: 4 })
         .add_plugins(DefaultPlugins)
         .add_startup_system(setup.system())
diff --git a/examples/3d/pbr.rs b/examples/3d/pbr.rs
index 73c14d2cb4..adfd966f98 100644
--- a/examples/3d/pbr.rs
+++ b/examples/3d/pbr.rs
@@ -2,7 +2,7 @@ use bevy::prelude::*;
 
 /// This example shows how to configure Physically Based Rendering (PBR) parameters.
 fn main() {
-    App::build()
+    App::new()
         .insert_resource(Msaa { samples: 4 })
         .add_plugins(DefaultPlugins)
         .add_startup_system(setup.system())
diff --git a/examples/3d/spawner.rs b/examples/3d/spawner.rs
index 4cc9e3b44f..50d4a8fdfc 100644
--- a/examples/3d/spawner.rs
+++ b/examples/3d/spawner.rs
@@ -13,7 +13,7 @@ use rand::{rngs::StdRng, Rng, SeedableRng};
 /// NOTE: Bevy still has a number of optimizations to do in this area. Expect the
 /// performance here to go way up in the future
 fn main() {
-    App::build()
+    App::new()
         .add_plugins(DefaultPlugins)
         .add_plugin(FrameTimeDiagnosticsPlugin::default())
         .add_plugin(LogDiagnosticsPlugin::default())
diff --git a/examples/3d/texture.rs b/examples/3d/texture.rs
index 84fb6a495b..934c35205d 100644
--- a/examples/3d/texture.rs
+++ b/examples/3d/texture.rs
@@ -2,7 +2,7 @@ use bevy::prelude::*;
 
 /// This example shows various ways to configure texture materials in 3D
 fn main() {
-    App::build()
+    App::new()
         .add_plugins(DefaultPlugins)
         .add_startup_system(setup.system())
         .run();
diff --git a/examples/3d/update_gltf_scene.rs b/examples/3d/update_gltf_scene.rs
index c552b82727..5cd93441b8 100644
--- a/examples/3d/update_gltf_scene.rs
+++ b/examples/3d/update_gltf_scene.rs
@@ -1,7 +1,7 @@
 use bevy::{prelude::*, scene::InstanceId};
 
 fn main() {
-    App::build()
+    App::new()
         .insert_resource(Msaa { samples: 4 })
         .add_plugins(DefaultPlugins)
         .insert_resource(SceneInstance::default())
diff --git a/examples/3d/wireframe.rs b/examples/3d/wireframe.rs
index 1b861f91ff..6901f14512 100644
--- a/examples/3d/wireframe.rs
+++ b/examples/3d/wireframe.rs
@@ -5,7 +5,7 @@ use bevy::{
 };
 
 fn main() {
-    App::build()
+    App::new()
         .insert_resource(Msaa { samples: 4 })
         .insert_resource(WgpuOptions {
             features: WgpuFeatures {
diff --git a/examples/3d/z_sort_debug.rs b/examples/3d/z_sort_debug.rs
index 9b094384ec..3ebdfcda1d 100644
--- a/examples/3d/z_sort_debug.rs
+++ b/examples/3d/z_sort_debug.rs
@@ -9,7 +9,7 @@ use bevy::{
 /// This example visualizes camera z-ordering by setting the material of rotating cubes to their
 /// distance from the camera
 fn main() {
-    App::build()
+    App::new()
         .add_plugins(DefaultPlugins)
         .add_startup_system(setup.system())
         .add_system(rotator_system.system())
diff --git a/examples/android/android.rs b/examples/android/android.rs
index 2793b74b24..6e3c6f6962 100644
--- a/examples/android/android.rs
+++ b/examples/android/android.rs
@@ -3,7 +3,7 @@ use bevy::prelude::*;
 // the `bevy_main` proc_macro generates the required android boilerplate
 #[bevy_main]
 fn main() {
-    App::build()
+    App::new()
         .insert_resource(Msaa { samples: 2 })
         .add_plugins(DefaultPlugins)
         .add_startup_system(setup.system())
diff --git a/examples/app/custom_loop.rs b/examples/app/custom_loop.rs
index a210140365..5a191781ad 100644
--- a/examples/app/custom_loop.rs
+++ b/examples/app/custom_loop.rs
@@ -21,7 +21,7 @@ fn print_system(input: Res<Input>) {
 }
 
 fn main() {
-    App::build()
+    App::new()
         .insert_resource(Input(String::new()))
         .set_runner(my_runner)
         .add_system(print_system.system())
diff --git a/examples/app/drag_and_drop.rs b/examples/app/drag_and_drop.rs
index 827f461095..d3f0e54c71 100644
--- a/examples/app/drag_and_drop.rs
+++ b/examples/app/drag_and_drop.rs
@@ -1,7 +1,7 @@
 use bevy::prelude::*;
 
 fn main() {
-    App::build()
+    App::new()
         .add_plugins(DefaultPlugins)
         .add_system(file_drag_and_drop_system.system())
         .run();
diff --git a/examples/app/empty.rs b/examples/app/empty.rs
index 7ee2c99993..032a096968 100644
--- a/examples/app/empty.rs
+++ b/examples/app/empty.rs
@@ -1,5 +1,5 @@
 use bevy::prelude::*;
 
 fn main() {
-    App::build().run();
+    App::new().run();
 }
diff --git a/examples/app/empty_defaults.rs b/examples/app/empty_defaults.rs
index bebb62b615..5aaacce1fc 100644
--- a/examples/app/empty_defaults.rs
+++ b/examples/app/empty_defaults.rs
@@ -1,5 +1,5 @@
 use bevy::prelude::*;
 
 fn main() {
-    App::build().add_plugins(DefaultPlugins).run();
+    App::new().add_plugins(DefaultPlugins).run();
 }
diff --git a/examples/app/headless.rs b/examples/app/headless.rs
index e3e740dbbd..c89f8fea14 100644
--- a/examples/app/headless.rs
+++ b/examples/app/headless.rs
@@ -10,14 +10,14 @@ use bevy::{app::ScheduleRunnerSettings, prelude::*, utils::Duration};
 
 fn main() {
     // this app runs once
-    App::build()
+    App::new()
         .insert_resource(ScheduleRunnerSettings::run_once())
         .add_plugins(MinimalPlugins)
         .add_system(hello_world_system.system())
         .run();
 
     // this app loops forever at 60 fps
-    App::build()
+    App::new()
         .insert_resource(ScheduleRunnerSettings::run_loop(Duration::from_secs_f64(
             1.0 / 60.0,
         )))
diff --git a/examples/app/logs.rs b/examples/app/logs.rs
index 103d34787e..6b0a5c7aba 100644
--- a/examples/app/logs.rs
+++ b/examples/app/logs.rs
@@ -2,7 +2,7 @@ use bevy::prelude::*;
 
 /// This example illustrates how to use logs in bevy
 fn main() {
-    App::build()
+    App::new()
         // Uncomment this to override the default log settings:
         // .insert_resource(bevy::log::LogSettings {
         //     level: bevy::log::Level::TRACE,
diff --git a/examples/app/plugin.rs b/examples/app/plugin.rs
index b766c16e51..6248b3aee8 100644
--- a/examples/app/plugin.rs
+++ b/examples/app/plugin.rs
@@ -4,7 +4,7 @@ use bevy::{prelude::*, utils::Duration};
 /// that provide a specific piece of functionality (generally the smaller the scope, the better).
 /// This example illustrates how to create a simple plugin that prints out a message.
 fn main() {
-    App::build()
+    App::new()
         .add_plugins(DefaultPlugins)
         // plugins are registered as part of the "app building" process
         .add_plugin(PrintMessagePlugin {
@@ -23,7 +23,7 @@ pub struct PrintMessagePlugin {
 
 impl Plugin for PrintMessagePlugin {
     // this is where we set up our plugin
-    fn build(&self, app: &mut AppBuilder) {
+    fn build(&self, app: &mut App) {
         let state = PrintMessageState {
             message: self.message.clone(),
             timer: Timer::new(self.wait_duration, true),
diff --git a/examples/app/plugin_group.rs b/examples/app/plugin_group.rs
index f95225bd7a..0e258105fc 100644
--- a/examples/app/plugin_group.rs
+++ b/examples/app/plugin_group.rs
@@ -2,7 +2,7 @@ use bevy::{app::PluginGroupBuilder, prelude::*};
 
 /// PluginGroups are a way to group sets of plugins that should be registered together.
 fn main() {
-    App::build()
+    App::new()
         // Two PluginGroups that are included with bevy are DefaultPlugins and MinimalPlugins
         .add_plugins(DefaultPlugins)
         // Adding a plugin group adds all plugins in the group by default
@@ -28,7 +28,7 @@ impl PluginGroup for HelloWorldPlugins {
 pub struct PrintHelloPlugin;
 
 impl Plugin for PrintHelloPlugin {
-    fn build(&self, app: &mut AppBuilder) {
+    fn build(&self, app: &mut App) {
         app.add_system(print_hello_system.system());
     }
 }
@@ -40,7 +40,7 @@ fn print_hello_system() {
 pub struct PrintWorldPlugin;
 
 impl Plugin for PrintWorldPlugin {
-    fn build(&self, app: &mut AppBuilder) {
+    fn build(&self, app: &mut App) {
         app.add_system(print_world_system.system());
     }
 }
diff --git a/examples/app/return_after_run.rs b/examples/app/return_after_run.rs
index 983112c699..ced46257d0 100644
--- a/examples/app/return_after_run.rs
+++ b/examples/app/return_after_run.rs
@@ -2,7 +2,7 @@ use bevy::{prelude::*, render::pass::ClearColor, winit::WinitConfig};
 
 fn main() {
     println!("Running first App.");
-    App::build()
+    App::new()
         .insert_resource(WinitConfig {
             return_from_run: true,
         })
@@ -11,7 +11,7 @@ fn main() {
         .add_system(system1.system())
         .run();
     println!("Running another App.");
-    App::build()
+    App::new()
         .insert_resource(WinitConfig {
             return_from_run: true,
         })
diff --git a/examples/app/thread_pool_resources.rs b/examples/app/thread_pool_resources.rs
index 354739fb30..b53273b584 100644
--- a/examples/app/thread_pool_resources.rs
+++ b/examples/app/thread_pool_resources.rs
@@ -3,7 +3,7 @@ use bevy::prelude::*;
 /// This example illustrates how to customize the thread pool used internally (e.g. to only use a
 /// certain number of threads).
 fn main() {
-    App::build()
+    App::new()
         .insert_resource(DefaultTaskPoolOptions::with_num_threads(4))
         .add_plugins(DefaultPlugins)
         .run();
diff --git a/examples/asset/asset_loading.rs b/examples/asset/asset_loading.rs
index 5eee05ace5..f383e0b9fc 100644
--- a/examples/asset/asset_loading.rs
+++ b/examples/asset/asset_loading.rs
@@ -2,7 +2,7 @@ use bevy::prelude::*;
 
 /// This example illustrates various ways to load assets
 fn main() {
-    App::build()
+    App::new()
         .insert_resource(Msaa { samples: 4 })
         .add_plugins(DefaultPlugins)
         .add_startup_system(setup.system())
diff --git a/examples/asset/custom_asset.rs b/examples/asset/custom_asset.rs
index 826e8e817c..d04c104e2e 100644
--- a/examples/asset/custom_asset.rs
+++ b/examples/asset/custom_asset.rs
@@ -34,7 +34,7 @@ impl AssetLoader for CustomAssetLoader {
 }
 
 fn main() {
-    App::build()
+    App::new()
         .add_plugins(DefaultPlugins)
         .init_resource::<State>()
         .add_asset::<CustomAsset>()
diff --git a/examples/asset/custom_asset_io.rs b/examples/asset/custom_asset_io.rs
index 6c2b01126c..9a18fee7ee 100644
--- a/examples/asset/custom_asset_io.rs
+++ b/examples/asset/custom_asset_io.rs
@@ -46,11 +46,11 @@ impl AssetIo for CustomAssetIo {
 struct CustomAssetIoPlugin;
 
 impl Plugin for CustomAssetIoPlugin {
-    fn build(&self, app: &mut AppBuilder) {
+    fn build(&self, app: &mut App) {
         // must get a hold of the task pool in order to create the asset server
 
         let task_pool = app
-            .world()
+            .world
             .get_resource::<bevy::tasks::IoTaskPool>()
             .expect("`IoTaskPool` resource not found.")
             .0
@@ -74,7 +74,7 @@ impl Plugin for CustomAssetIoPlugin {
 }
 
 fn main() {
-    App::build()
+    App::new()
         .add_plugins_with(DefaultPlugins, |group| {
             // the custom asset io plugin must be inserted in-between the
             // `CorePlugin' and `AssetPlugin`. It needs to be after the
diff --git a/examples/asset/hot_asset_reloading.rs b/examples/asset/hot_asset_reloading.rs
index ebe9a52e8a..82d5d50194 100644
--- a/examples/asset/hot_asset_reloading.rs
+++ b/examples/asset/hot_asset_reloading.rs
@@ -4,7 +4,7 @@ use bevy::prelude::*;
 /// game is running. This lets you immediately see the results of your changes without restarting
 /// the game. This example illustrates hot reloading mesh changes.
 fn main() {
-    App::build()
+    App::new()
         .add_plugins(DefaultPlugins)
         .add_startup_system(setup.system())
         .run();
diff --git a/examples/audio/audio.rs b/examples/audio/audio.rs
index a8296ad953..517d66d79a 100644
--- a/examples/audio/audio.rs
+++ b/examples/audio/audio.rs
@@ -2,7 +2,7 @@ use bevy::prelude::*;
 
 /// This example illustrates how to load and play an audio file
 fn main() {
-    App::build()
+    App::new()
         .add_plugins(DefaultPlugins)
         .add_startup_system(setup.system())
         .run();
diff --git a/examples/diagnostics/custom_diagnostic.rs b/examples/diagnostics/custom_diagnostic.rs
index 6169ac9284..83a53629e9 100644
--- a/examples/diagnostics/custom_diagnostic.rs
+++ b/examples/diagnostics/custom_diagnostic.rs
@@ -5,7 +5,7 @@ use bevy::{
 
 /// This example illustrates how to create a custom diagnostic
 fn main() {
-    App::build()
+    App::new()
         .add_plugins(DefaultPlugins)
         // The "print diagnostics" plugin is optional. It just visualizes our diagnostics in the
         // console
diff --git a/examples/diagnostics/log_diagnostics.rs b/examples/diagnostics/log_diagnostics.rs
index a48efde056..359e64086e 100644
--- a/examples/diagnostics/log_diagnostics.rs
+++ b/examples/diagnostics/log_diagnostics.rs
@@ -4,7 +4,7 @@ use bevy::{
 };
 
 fn main() {
-    App::build()
+    App::new()
         .add_plugins(DefaultPlugins)
         // Adds frame time diagnostics
         .add_plugin(FrameTimeDiagnosticsPlugin::default())
diff --git a/examples/ecs/component_change_detection.rs b/examples/ecs/component_change_detection.rs
index 59d5d80591..09b7ca2a86 100644
--- a/examples/ecs/component_change_detection.rs
+++ b/examples/ecs/component_change_detection.rs
@@ -3,7 +3,7 @@ use rand::Rng;
 
 // This example illustrates how to react to component change
 fn main() {
-    App::build()
+    App::new()
         .add_plugins(DefaultPlugins)
         .add_startup_system(setup.system())
         .add_system(change_component.system())
diff --git a/examples/ecs/ecs_guide.rs b/examples/ecs/ecs_guide.rs
index 646ead3a5c..f71fd803c7 100644
--- a/examples/ecs/ecs_guide.rs
+++ b/examples/ecs/ecs_guide.rs
@@ -262,7 +262,7 @@ enum MyLabels {
 fn main() {
     // Bevy apps are created using the builder pattern. We use the builder to add systems,
     // resources, and plugins to our app
-    App::build()
+    App::new()
         // Resources can be added to our app like this
         .insert_resource(State { counter: 0 })
         // Some systems are configured by adding their settings as a resource
diff --git a/examples/ecs/event.rs b/examples/ecs/event.rs
index 0ae4d028c0..878a7074d9 100644
--- a/examples/ecs/event.rs
+++ b/examples/ecs/event.rs
@@ -3,7 +3,7 @@ use bevy::prelude::*;
 /// This example creates a new event, a system that triggers the event once per second,
 /// and a system that prints a message whenever the event is received.
 fn main() {
-    App::build()
+    App::new()
         .add_plugins(DefaultPlugins)
         .add_event::<MyEvent>()
         .init_resource::<EventTriggerState>()
diff --git a/examples/ecs/fixed_timestep.rs b/examples/ecs/fixed_timestep.rs
index e9ac0c036f..6fe66945af 100644
--- a/examples/ecs/fixed_timestep.rs
+++ b/examples/ecs/fixed_timestep.rs
@@ -9,7 +9,7 @@ const LABEL: &str = "my_fixed_timestep";
 struct FixedUpdateStage;
 
 fn main() {
-    App::build()
+    App::new()
         .add_plugins(DefaultPlugins)
         // this system will run once every update (it should match your screen's refresh rate)
         .add_system(frame_update.system())
diff --git a/examples/ecs/hierarchy.rs b/examples/ecs/hierarchy.rs
index fc5b8553d8..a0b27b7ccd 100644
--- a/examples/ecs/hierarchy.rs
+++ b/examples/ecs/hierarchy.rs
@@ -1,7 +1,7 @@
 use bevy::prelude::*;
 
 fn main() {
-    App::build()
+    App::new()
         .add_plugins(DefaultPlugins)
         .add_startup_system(setup.system())
         .add_system(rotate.system())
diff --git a/examples/ecs/parallel_query.rs b/examples/ecs/parallel_query.rs
index 6d4ed06a4b..98b89bf417 100644
--- a/examples/ecs/parallel_query.rs
+++ b/examples/ecs/parallel_query.rs
@@ -68,7 +68,7 @@ fn bounce_system(
 }
 
 fn main() {
-    App::build()
+    App::new()
         .add_plugins(DefaultPlugins)
         .add_startup_system(spawn_system.system())
         .add_system(move_system.system())
diff --git a/examples/ecs/removal_detection.rs b/examples/ecs/removal_detection.rs
index 662c96babf..26902dbd0c 100644
--- a/examples/ecs/removal_detection.rs
+++ b/examples/ecs/removal_detection.rs
@@ -13,7 +13,7 @@ fn main() {
     // With these constraints in mind we make sure to place the system that removes a `Component` on
     // the `CoreStage::Update' stage, and the system that reacts on the removal on the
     // `CoreStage::PostUpdate` stage.
-    App::build()
+    App::new()
         .add_plugins(DefaultPlugins)
         .add_startup_system(setup.system())
         .add_system_to_stage(CoreStage::Update, remove_component.system())
diff --git a/examples/ecs/startup_system.rs b/examples/ecs/startup_system.rs
index 395d69322b..b9c6a2f60e 100644
--- a/examples/ecs/startup_system.rs
+++ b/examples/ecs/startup_system.rs
@@ -1,7 +1,7 @@
 use bevy::prelude::*;
 
 fn main() {
-    App::build()
+    App::new()
         .add_startup_system(startup_system.system())
         .add_system(normal_system.system())
         .run();
diff --git a/examples/ecs/state.rs b/examples/ecs/state.rs
index 57b6e4d622..eca1129310 100644
--- a/examples/ecs/state.rs
+++ b/examples/ecs/state.rs
@@ -3,7 +3,7 @@ use bevy::prelude::*;
 /// This example illustrates how to use States to control transitioning from a Menu state to an
 /// InGame state.
 fn main() {
-    App::build()
+    App::new()
         .add_plugins(DefaultPlugins)
         .init_resource::<ButtonMaterials>()
         .add_state(AppState::Menu)
diff --git a/examples/ecs/system_chaining.rs b/examples/ecs/system_chaining.rs
index 2dd14437e1..ce93548069 100644
--- a/examples/ecs/system_chaining.rs
+++ b/examples/ecs/system_chaining.rs
@@ -2,7 +2,7 @@ use anyhow::Result;
 use bevy::prelude::*;
 
 fn main() {
-    App::build()
+    App::new()
         .insert_resource(Message("42".to_string()))
         .add_system(parse_message_system.system().chain(handler_system.system()))
         .run();
diff --git a/examples/ecs/system_param.rs b/examples/ecs/system_param.rs
index 97baba11f4..4fc6549888 100644
--- a/examples/ecs/system_param.rs
+++ b/examples/ecs/system_param.rs
@@ -2,7 +2,7 @@ use bevy::{ecs::system::SystemParam, prelude::*};
 
 /// This example creates a SystemParam struct that counts the number of players
 fn main() {
-    App::build()
+    App::new()
         .insert_resource(PlayerCount(0))
         .add_startup_system(spawn.system())
         .add_system(count_players.system())
diff --git a/examples/ecs/timers.rs b/examples/ecs/timers.rs
index 6d252b6d41..94b66d6d3e 100644
--- a/examples/ecs/timers.rs
+++ b/examples/ecs/timers.rs
@@ -1,7 +1,7 @@
 use bevy::{log::info, prelude::*};
 
 fn main() {
-    App::build()
+    App::new()
         .add_plugins(DefaultPlugins)
         .insert_resource(Countdown::default())
         .add_startup_system(setup_system.system())
diff --git a/examples/game/alien_cake_addict.rs b/examples/game/alien_cake_addict.rs
index 464d281d95..5300c7e203 100644
--- a/examples/game/alien_cake_addict.rs
+++ b/examples/game/alien_cake_addict.rs
@@ -13,7 +13,7 @@ enum GameState {
 }
 
 fn main() {
-    App::build()
+    App::new()
         .insert_resource(Msaa { samples: 4 })
         .init_resource::<Game>()
         .add_plugins(DefaultPlugins)
diff --git a/examples/game/breakout.rs b/examples/game/breakout.rs
index 549faa64ac..45c1902f9f 100644
--- a/examples/game/breakout.rs
+++ b/examples/game/breakout.rs
@@ -8,7 +8,7 @@ use bevy::{
 /// An implementation of the classic game "Breakout"
 const TIME_STEP: f32 = 1.0 / 60.0;
 fn main() {
-    App::build()
+    App::new()
         .add_plugins(DefaultPlugins)
         .insert_resource(Scoreboard { score: 0 })
         .insert_resource(ClearColor(Color::rgb(0.9, 0.9, 0.9)))
diff --git a/examples/hello_world.rs b/examples/hello_world.rs
index 5078ebb2e2..4afa256a2f 100644
--- a/examples/hello_world.rs
+++ b/examples/hello_world.rs
@@ -1,7 +1,7 @@
 use bevy::prelude::*;
 
 fn main() {
-    App::build().add_system(hello_world_system.system()).run();
+    App::new().add_system(hello_world_system.system()).run();
 }
 
 fn hello_world_system() {
diff --git a/examples/input/char_input_events.rs b/examples/input/char_input_events.rs
index adecead52c..956312e679 100644
--- a/examples/input/char_input_events.rs
+++ b/examples/input/char_input_events.rs
@@ -1,7 +1,7 @@
 use bevy::{prelude::*, window::ReceivedCharacter};
 
 fn main() {
-    App::build()
+    App::new()
         .add_plugins(DefaultPlugins)
         .add_system(print_char_event_system.system())
         .run();
diff --git a/examples/input/gamepad_input.rs b/examples/input/gamepad_input.rs
index 8b9cd9bb7f..b55810c8e1 100644
--- a/examples/input/gamepad_input.rs
+++ b/examples/input/gamepad_input.rs
@@ -5,7 +5,7 @@ use bevy::{
 };
 
 fn main() {
-    App::build()
+    App::new()
         .add_plugins(DefaultPlugins)
         .init_resource::<GamepadLobby>()
         .add_system_to_stage(CoreStage::PreUpdate, connection_system.system())
diff --git a/examples/input/gamepad_input_events.rs b/examples/input/gamepad_input_events.rs
index 5ad3828512..1f02504bbd 100644
--- a/examples/input/gamepad_input_events.rs
+++ b/examples/input/gamepad_input_events.rs
@@ -4,7 +4,7 @@ use bevy::{
 };
 
 fn main() {
-    App::build()
+    App::new()
         .add_plugins(DefaultPlugins)
         .add_system(gamepad_events.system())
         .run();
diff --git a/examples/input/keyboard_input.rs b/examples/input/keyboard_input.rs
index b67287edbd..27e8c6b8c9 100644
--- a/examples/input/keyboard_input.rs
+++ b/examples/input/keyboard_input.rs
@@ -4,7 +4,7 @@ use bevy::{
 };
 
 fn main() {
-    App::build()
+    App::new()
         .add_plugins(DefaultPlugins)
         .add_system(keyboard_input_system.system())
         .run();
diff --git a/examples/input/keyboard_input_events.rs b/examples/input/keyboard_input_events.rs
index d226c5f85e..07629ed26a 100644
--- a/examples/input/keyboard_input_events.rs
+++ b/examples/input/keyboard_input_events.rs
@@ -1,7 +1,7 @@
 use bevy::{input::keyboard::KeyboardInput, prelude::*};
 
 fn main() {
-    App::build()
+    App::new()
         .add_plugins(DefaultPlugins)
         .add_system(print_keyboard_event_system.system())
         .run();
diff --git a/examples/input/keyboard_modifiers.rs b/examples/input/keyboard_modifiers.rs
index 5fe80c2b07..425851d12d 100644
--- a/examples/input/keyboard_modifiers.rs
+++ b/examples/input/keyboard_modifiers.rs
@@ -4,7 +4,7 @@ use bevy::{
 };
 
 fn main() {
-    App::build()
+    App::new()
         .add_plugins(DefaultPlugins)
         .add_system(keyboard_input_system.system())
         .run();
diff --git a/examples/input/mouse_input.rs b/examples/input/mouse_input.rs
index 441ccdd92c..e0e4fbb598 100644
--- a/examples/input/mouse_input.rs
+++ b/examples/input/mouse_input.rs
@@ -1,7 +1,7 @@
 use bevy::prelude::*;
 
 fn main() {
-    App::build()
+    App::new()
         .add_plugins(DefaultPlugins)
         .add_system(mouse_click_system.system())
         .run();
diff --git a/examples/input/mouse_input_events.rs b/examples/input/mouse_input_events.rs
index 78a193150c..b68249c9e6 100644
--- a/examples/input/mouse_input_events.rs
+++ b/examples/input/mouse_input_events.rs
@@ -5,7 +5,7 @@ use bevy::{
 };
 
 fn main() {
-    App::build()
+    App::new()
         .add_plugins(DefaultPlugins)
         .add_system(print_mouse_events_system.system())
         .run();
diff --git a/examples/input/touch_input.rs b/examples/input/touch_input.rs
index c25d9a9fba..08700964b0 100644
--- a/examples/input/touch_input.rs
+++ b/examples/input/touch_input.rs
@@ -1,7 +1,7 @@
 use bevy::{input::touch::*, prelude::*};
 
 fn main() {
-    App::build()
+    App::new()
         .add_plugins(DefaultPlugins)
         .add_system(touch_system.system())
         .run();
diff --git a/examples/input/touch_input_events.rs b/examples/input/touch_input_events.rs
index 78d1b556b9..53f068b9af 100644
--- a/examples/input/touch_input_events.rs
+++ b/examples/input/touch_input_events.rs
@@ -1,7 +1,7 @@
 use bevy::{input::touch::*, prelude::*};
 
 fn main() {
-    App::build()
+    App::new()
         .add_plugins(DefaultPlugins)
         .add_system(touch_event_system.system())
         .run();
diff --git a/examples/ios/src/lib.rs b/examples/ios/src/lib.rs
index c4b370aa02..3e01ca8451 100644
--- a/examples/ios/src/lib.rs
+++ b/examples/ios/src/lib.rs
@@ -3,7 +3,7 @@ use bevy::{prelude::*, window::WindowMode};
 // the `bevy_main` proc_macro generates the required ios boilerplate
 #[bevy_main]
 fn main() {
-    App::build()
+    App::new()
         .insert_resource(WindowDescriptor {
             vsync: true,
             resizable: false,
diff --git a/examples/reflection/generic_reflection.rs b/examples/reflection/generic_reflection.rs
index 02609652de..933ae63c2b 100644
--- a/examples/reflection/generic_reflection.rs
+++ b/examples/reflection/generic_reflection.rs
@@ -3,7 +3,7 @@ use std::any::TypeId;
 
 /// You must manually register each instance of a generic type
 fn main() {
-    App::build()
+    App::new()
         .add_plugins(DefaultPlugins)
         .register_type::<MyType<u32>>()
         .add_startup_system(setup.system())
diff --git a/examples/reflection/reflection.rs b/examples/reflection/reflection.rs
index 73e8fc37a8..2d07383be8 100644
--- a/examples/reflection/reflection.rs
+++ b/examples/reflection/reflection.rs
@@ -11,7 +11,7 @@ use serde::de::DeserializeSeed;
 /// interact with Rust types, such as accessing fields by their string name. Reflection is a core
 /// part of Bevy and enables a number of interesting scenarios (like scenes).
 fn main() {
-    App::build()
+    App::new()
         .add_plugins(DefaultPlugins)
         .register_type::<Foo>()
         .register_type::<Bar>()
diff --git a/examples/reflection/reflection_types.rs b/examples/reflection/reflection_types.rs
index 4ecf800fb2..88ebc6bede 100644
--- a/examples/reflection/reflection_types.rs
+++ b/examples/reflection/reflection_types.rs
@@ -7,7 +7,7 @@ use serde::{Deserialize, Serialize};
 
 /// This example illustrates the various reflection types available
 fn main() {
-    App::build()
+    App::new()
         .add_plugins(DefaultPlugins)
         .add_startup_system(setup.system())
         .run();
diff --git a/examples/reflection/trait_reflection.rs b/examples/reflection/trait_reflection.rs
index 55993cb910..78bd3f5229 100644
--- a/examples/reflection/trait_reflection.rs
+++ b/examples/reflection/trait_reflection.rs
@@ -1,7 +1,7 @@
 use bevy::{prelude::*, reflect::TypeRegistry};
 
 fn main() {
-    App::build()
+    App::new()
         .add_plugins(DefaultPlugins)
         .add_startup_system(setup.system())
         .register_type::<MyType>()
diff --git a/examples/scene/scene.rs b/examples/scene/scene.rs
index 1afeb9c144..188dddcb6a 100644
--- a/examples/scene/scene.rs
+++ b/examples/scene/scene.rs
@@ -2,7 +2,7 @@ use bevy::{prelude::*, reflect::TypeRegistry, utils::Duration};
 
 /// This example illustrates loading and saving scenes from files
 fn main() {
-    App::build()
+    App::new()
         .add_plugins(DefaultPlugins)
         .register_type::<ComponentA>()
         .register_type::<ComponentB>()
diff --git a/examples/shader/animate_shader.rs b/examples/shader/animate_shader.rs
index bcc8a478b4..e4b0232a1e 100644
--- a/examples/shader/animate_shader.rs
+++ b/examples/shader/animate_shader.rs
@@ -13,7 +13,7 @@ use bevy::{
 /// This example shows how to animate a shader, by passing the global `time.seconds_since_startup()`
 /// via a 'TimeComponent` to the shader.
 pub fn main() {
-    App::build()
+    App::new()
         .add_plugins(DefaultPlugins)
         .add_startup_system(setup.system())
         .add_system(animate_shader.system())
diff --git a/examples/shader/array_texture.rs b/examples/shader/array_texture.rs
index 8f42f78a1d..34dde74f53 100644
--- a/examples/shader/array_texture.rs
+++ b/examples/shader/array_texture.rs
@@ -13,7 +13,7 @@ use bevy::{
 /// This example illustrates how to create a texture for use with a texture2DArray shader uniform
 /// variable.
 fn main() {
-    App::build()
+    App::new()
         .add_plugins(DefaultPlugins)
         .add_asset::<MyArrayTexture>()
         .add_startup_system(setup.system())
diff --git a/examples/shader/hot_shader_reloading.rs b/examples/shader/hot_shader_reloading.rs
index 9c9e2bcf2e..22673d33e3 100644
--- a/examples/shader/hot_shader_reloading.rs
+++ b/examples/shader/hot_shader_reloading.rs
@@ -13,7 +13,7 @@ use bevy::{
 /// This example illustrates how to load shaders such that they can be
 /// edited while the example is still running.
 fn main() {
-    App::build()
+    App::new()
         .add_plugins(DefaultPlugins)
         .add_asset::<MyMaterial>()
         .add_startup_system(setup.system())
diff --git a/examples/shader/mesh_custom_attribute.rs b/examples/shader/mesh_custom_attribute.rs
index c8d329d3c5..f8a8530add 100644
--- a/examples/shader/mesh_custom_attribute.rs
+++ b/examples/shader/mesh_custom_attribute.rs
@@ -9,7 +9,7 @@ use bevy::{
 
 /// This example illustrates how to add a custom attribute to a mesh and use it in a custom shader.
 fn main() {
-    App::build()
+    App::new()
         .add_plugins(DefaultPlugins)
         .add_startup_system(setup.system())
         .run();
diff --git a/examples/shader/shader_custom_material.rs b/examples/shader/shader_custom_material.rs
index 76bab39679..feca59fd2e 100644
--- a/examples/shader/shader_custom_material.rs
+++ b/examples/shader/shader_custom_material.rs
@@ -13,7 +13,7 @@ use bevy::{
 /// This example illustrates how to create a custom material asset and a shader that uses that
 /// material
 fn main() {
-    App::build()
+    App::new()
         .add_plugins(DefaultPlugins)
         .add_asset::<MyMaterial>()
         .add_startup_system(setup.system())
diff --git a/examples/shader/shader_defs.rs b/examples/shader/shader_defs.rs
index a8e1089222..385b4d33f3 100644
--- a/examples/shader/shader_defs.rs
+++ b/examples/shader/shader_defs.rs
@@ -14,7 +14,7 @@ use bevy::{
 /// shader that uses that material. In Bevy, "shader defs" are a way to selectively enable parts of
 /// a shader based on values set in a component or asset.
 fn main() {
-    App::build()
+    App::new()
         .add_plugins(DefaultPlugins)
         .add_asset::<MyMaterial>()
         .add_startup_system(setup.system())
diff --git a/examples/tools/bevymark.rs b/examples/tools/bevymark.rs
index 258c471540..4296406bdd 100644
--- a/examples/tools/bevymark.rs
+++ b/examples/tools/bevymark.rs
@@ -31,7 +31,7 @@ impl FromWorld for BirdMaterial {
 }
 
 fn main() {
-    App::build()
+    App::new()
         .insert_resource(WindowDescriptor {
             title: "BevyMark".to_string(),
             width: 800.,
diff --git a/examples/tools/bevymark_pipelined.rs b/examples/tools/bevymark_pipelined.rs
new file mode 100644
index 0000000000..f6ff4074cf
--- /dev/null
+++ b/examples/tools/bevymark_pipelined.rs
@@ -0,0 +1,265 @@
+use bevy::{
+    core::{Time, Timer},
+    diagnostic::{Diagnostics, FrameTimeDiagnosticsPlugin, LogDiagnosticsPlugin},
+    ecs::prelude::*,
+    input::Input,
+    math::{Vec2, Vec3},
+    prelude::{App, AssetServer, Handle, MouseButton, Transform},
+    render2::{camera::OrthographicCameraBundle, color::Color, texture::Texture},
+    sprite2::{PipelinedSpriteBundle, Sprite},
+    wgpu2::diagnostic::WgpuResourceDiagnosticsPlugin,
+    window::WindowDescriptor,
+    PipelinedDefaultPlugins,
+};
+use rand::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,
+}
+
+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 })
+        // .init_resource::<BirdMaterial>()
+        .add_startup_system(setup.system())
+        .add_system(mouse_handler.system())
+        .add_system(movement_system.system())
+        .add_system(collision_system.system())
+        .add_system(counter_system.system())
+        .run();
+}
+
+struct BirdTexture(Handle<Texture>);
+
+fn setup(
+    mut commands: Commands,
+    window: Res<WindowDescriptor>,
+    mut counter: ResMut<BevyCounter>,
+    asset_server: Res<AssetServer>,
+) {
+    // spawn_birds(&mut commands, &window, &mut counter, 10);
+    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(asset_server.load("branding/icon.png")));
+}
+
+#[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.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<Texture>,
+) {
+    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(),
+                sprite: Sprite {
+                    size: Vec2::new(250.0, 250.0),
+                    ..Default::default()
+                },
+                transform: Transform {
+                    translation: Vec3::new(bird_x, bird_y, bird_z),
+                    scale: Vec3::splat(BIRD_SCALE),
+                    ..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() {
+        println!("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/ui/button.rs b/examples/ui/button.rs
index 6fc8e7f7a9..769985de1c 100644
--- a/examples/ui/button.rs
+++ b/examples/ui/button.rs
@@ -3,7 +3,7 @@ use bevy::prelude::*;
 /// This example illustrates how to create a button that changes color and text based on its
 /// interaction state.
 fn main() {
-    App::build()
+    App::new()
         .add_plugins(DefaultPlugins)
         .init_resource::<ButtonMaterials>()
         .add_startup_system(setup.system())
diff --git a/examples/ui/font_atlas_debug.rs b/examples/ui/font_atlas_debug.rs
index ce4f81d427..97bf79e2ba 100644
--- a/examples/ui/font_atlas_debug.rs
+++ b/examples/ui/font_atlas_debug.rs
@@ -4,7 +4,7 @@ use bevy::{prelude::*, text::FontAtlasSet};
 /// This example illustrates how FontAtlases are populated. Bevy uses FontAtlases under the hood to
 /// optimize text rendering.
 fn main() {
-    App::build()
+    App::new()
         .init_resource::<State>()
         .insert_resource(ClearColor(Color::BLACK))
         .add_plugins(DefaultPlugins)
diff --git a/examples/ui/text.rs b/examples/ui/text.rs
index 54ca621cd0..d51cb6aa37 100644
--- a/examples/ui/text.rs
+++ b/examples/ui/text.rs
@@ -7,7 +7,7 @@ use bevy::{
 /// current FPS in the top left corner, as well as text that changes colour in the bottom right.
 /// For text within a scene, please see the text2d example.
 fn main() {
-    App::build()
+    App::new()
         .add_plugins(DefaultPlugins)
         .add_plugin(FrameTimeDiagnosticsPlugin::default())
         .add_startup_system(setup.system())
diff --git a/examples/ui/text_debug.rs b/examples/ui/text_debug.rs
index 418bb608b3..97a0827734 100644
--- a/examples/ui/text_debug.rs
+++ b/examples/ui/text_debug.rs
@@ -5,7 +5,7 @@ use bevy::{
 
 /// This example is for debugging text layout
 fn main() {
-    App::build()
+    App::new()
         .insert_resource(WindowDescriptor {
             vsync: false,
             ..Default::default()
diff --git a/examples/ui/ui.rs b/examples/ui/ui.rs
index 9ef72554ba..38c3a47bfc 100644
--- a/examples/ui/ui.rs
+++ b/examples/ui/ui.rs
@@ -2,7 +2,7 @@ use bevy::prelude::*;
 
 /// This example illustrates the various features of Bevy UI.
 fn main() {
-    App::build()
+    App::new()
         .add_plugins(DefaultPlugins)
         .add_startup_system(setup.system())
         .run();
diff --git a/examples/wasm/assets_wasm.rs b/examples/wasm/assets_wasm.rs
index f3fb2faa35..ed8e7e6007 100644
--- a/examples/wasm/assets_wasm.rs
+++ b/examples/wasm/assets_wasm.rs
@@ -6,7 +6,7 @@ use bevy::{
 };
 
 fn main() {
-    App::build()
+    App::new()
         .insert_resource(AssetServerSettings {
             asset_folder: "/".to_string(),
         })
diff --git a/examples/wasm/headless_wasm.rs b/examples/wasm/headless_wasm.rs
index ce8db7a906..1fc3ca85f9 100644
--- a/examples/wasm/headless_wasm.rs
+++ b/examples/wasm/headless_wasm.rs
@@ -6,7 +6,7 @@ use bevy::{
 };
 
 fn main() {
-    App::build()
+    App::new()
         .insert_resource(ScheduleRunnerSettings::run_loop(Duration::from_secs_f64(
             1.0 / 60.0,
         )))
diff --git a/examples/wasm/hello_wasm.rs b/examples/wasm/hello_wasm.rs
index c3fbef4bda..6699e265ed 100644
--- a/examples/wasm/hello_wasm.rs
+++ b/examples/wasm/hello_wasm.rs
@@ -1,7 +1,7 @@
 use bevy::{log::LogPlugin, prelude::*};
 
 fn main() {
-    App::build()
+    App::new()
         .add_plugin(LogPlugin::default())
         .add_system(hello_wasm_system.system())
         .run();
diff --git a/examples/wasm/winit_wasm.rs b/examples/wasm/winit_wasm.rs
index 6cd8c4dde4..b6c9529d51 100644
--- a/examples/wasm/winit_wasm.rs
+++ b/examples/wasm/winit_wasm.rs
@@ -7,7 +7,7 @@ use bevy::{
 };
 
 fn main() {
-    App::build()
+    App::new()
         .insert_resource(WindowDescriptor {
             width: 300.,
             height: 300.,
diff --git a/examples/window/clear_color.rs b/examples/window/clear_color.rs
index 75891e984d..21e6f92bad 100644
--- a/examples/window/clear_color.rs
+++ b/examples/window/clear_color.rs
@@ -1,7 +1,7 @@
 use bevy::{prelude::*, render::pass::ClearColor};
 
 fn main() {
-    App::build()
+    App::new()
         .insert_resource(ClearColor(Color::rgb(0.5, 0.5, 0.9)))
         .add_plugins(DefaultPlugins)
         .run();
diff --git a/examples/window/multiple_windows.rs b/examples/window/multiple_windows.rs
index 8848ac4cc3..4f134fdbc8 100644
--- a/examples/window/multiple_windows.rs
+++ b/examples/window/multiple_windows.rs
@@ -14,7 +14,7 @@ use bevy::{
 
 /// This example creates a second window and draws a mesh from two different cameras.
 fn main() {
-    App::build()
+    App::new()
         .insert_resource(Msaa { samples: 4 })
         .add_state(AppState::CreateWindow)
         .add_plugins(DefaultPlugins)
diff --git a/examples/window/scale_factor_override.rs b/examples/window/scale_factor_override.rs
index 4865caeff4..18c0ce4ee2 100644
--- a/examples/window/scale_factor_override.rs
+++ b/examples/window/scale_factor_override.rs
@@ -2,7 +2,7 @@ use bevy::prelude::*;
 
 /// This example illustrates how to customize the default window settings
 fn main() {
-    App::build()
+    App::new()
         .insert_resource(WindowDescriptor {
             width: 500.,
             height: 300.,
diff --git a/examples/window/window_settings.rs b/examples/window/window_settings.rs
index 3c7719916a..0792c68f63 100644
--- a/examples/window/window_settings.rs
+++ b/examples/window/window_settings.rs
@@ -2,7 +2,7 @@ use bevy::prelude::*;
 
 /// This example illustrates how to customize the default window settings
 fn main() {
-    App::build()
+    App::new()
         .insert_resource(WindowDescriptor {
             title: "I am a window!".to_string(),
             width: 500.,
diff --git a/pipelined/bevy_render2/Cargo.toml b/pipelined/bevy_render2/Cargo.toml
new file mode 100644
index 0000000000..8c1331c42a
--- /dev/null
+++ b/pipelined/bevy_render2/Cargo.toml
@@ -0,0 +1,60 @@
+[package]
+name = "bevy_render2"
+version = "0.5.0"
+edition = "2018"
+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
+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"
+anyhow = "1.0"
+hex = "0.4.2"
+hexasphere = "3.4"
+parking_lot = "0.11.0"
+raw-window-handle = "0.3.0"
+crevice = { path = "../../crates/crevice" }
+
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+spirv-reflect = "0.2.3"
+
+[target.'cfg(any(all(target_arch="x86_64", target_os="linux", target_env="gnu"), all(target_arch="x86_64", target_os="macos"), all(target_arch="aarch64", target_os="android"), all(target_arch="armv7", target_os="androidabi"), all(target_arch="x86_64", target_os="windows", target_env="msvc")))'.dependencies]
+bevy-glsl-to-spirv = "0.2.0"
+
+[target.'cfg(not(any(target_arch = "wasm32", all(target_arch="x86_64", target_os="linux", target_env="gnu"), all(target_arch="x86_64", target_os="macos"), all(target_arch="aarch64", target_os="android"), all(target_arch="armv7", target_os="androidabi"), all(target_arch="x86_64", target_os="windows", target_env="msvc"))))'.dependencies]
+shaderc = "0.7.0"
+
+[features]
+png = ["image/png"]
+hdr = ["image/hdr"]
+dds = ["image/dds"]
+tga = ["image/tga"]
+jpeg = ["image/jpeg"]
+bmp = ["image/bmp"]
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..12c9fbd9d6
--- /dev/null
+++ b/pipelined/bevy_render2/src/camera/bundle.rs
@@ -0,0 +1,106 @@
+use crate::camera::{CAMERA_2D, CAMERA_3D, Camera, DepthCalculation, OrthographicProjection, PerspectiveProjection, ScalingMode};
+use bevy_ecs::bundle::Bundle;
+use bevy_transform::components::{GlobalTransform, Transform};
+
+/// 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 transform: Transform,
+    pub global_transform: GlobalTransform,
+}
+
+impl PerspectiveCameraBundle {
+    pub fn new_3d() -> Self {
+        Default::default()
+    }
+
+    pub fn with_name(name: &str) -> Self {
+        PerspectiveCameraBundle {
+            camera: Camera {
+                name: Some(name.to_string()),
+                ..Default::default()
+            },
+            perspective_projection: Default::default(),
+            transform: Default::default(),
+            global_transform: Default::default(),
+        }
+    }
+}
+
+impl Default for PerspectiveCameraBundle {
+    fn default() -> Self {
+        PerspectiveCameraBundle {
+            camera: Camera {
+                name: Some(CAMERA_3D.to_string()),
+                ..Default::default()
+            },
+            perspective_projection: Default::default(),
+            transform: Default::default(),
+            global_transform: Default::default(),
+        }
+    }
+}
+
+/// 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 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;
+        OrthographicCameraBundle {
+            camera: Camera {
+                name: Some(CAMERA_2D.to_string()),
+                ..Default::default()
+            },
+            orthographic_projection: OrthographicProjection {
+                far,
+                depth_calculation: DepthCalculation::ZDifference,
+                ..Default::default()
+            },
+            transform: Transform::from_xyz(0.0, 0.0, far - 0.1),
+            global_transform: Default::default(),
+        }
+    }
+
+    pub fn new_3d() -> Self {
+        OrthographicCameraBundle {
+            camera: Camera {
+                name: Some(CAMERA_3D.to_string()),
+                ..Default::default()
+            },
+            orthographic_projection: OrthographicProjection {
+                scaling_mode: ScalingMode::FixedVertical,
+                depth_calculation: DepthCalculation::Distance,
+                ..Default::default()
+            },
+            transform: Default::default(),
+            global_transform: Default::default(),
+        }
+    }
+
+    pub fn with_name(name: &str) -> Self {
+        OrthographicCameraBundle {
+            camera: Camera {
+                name: Some(name.to_string()),
+                ..Default::default()
+            },
+            orthographic_projection: Default::default(),
+            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..df4074001c
--- /dev/null
+++ b/pipelined/bevy_render2/src/camera/camera.rs
@@ -0,0 +1,113 @@
+use super::CameraProjection;
+use bevy_ecs::{
+    component::Component,
+    entity::Entity,
+    event::EventReader,
+    query::Added,
+    reflect::ReflectComponent,
+    system::{Query, 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(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<(
+        Query<(Entity, &mut Camera, &mut T)>,
+        Query<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_mut().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..c30e038b26
--- /dev/null
+++ b/pipelined/bevy_render2/src/camera/mod.rs
@@ -0,0 +1,131 @@
+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;
+pub use bundle::*;
+pub use camera::*;
+pub use projection::*;
+
+use crate::{
+    render_graph::{Node, RenderGraph, ResourceSlots},
+    render_resource::{DynamicUniformVec, RenderResourceBinding},
+    renderer::{RenderContext, RenderResources},
+    RenderStage,
+};
+use bevy_app::{App, CoreStage, Plugin};
+use bevy_ecs::prelude::*;
+use bevy_math::Mat4;
+
+pub const CAMERA_2D: &str = "camera_2d";
+pub const CAMERA_3D: &str = "camera_3d";
+
+#[derive(Default)]
+pub struct CameraPlugin;
+
+impl Plugin for CameraPlugin {
+    fn build(&self, app: &mut App) {
+        let mut active_cameras = ActiveCameras::default();
+        active_cameras.add(CAMERA_2D);
+        active_cameras.add(CAMERA_3D);
+        app.register_type::<Camera>()
+            .insert_resource(active_cameras)
+            .add_system_to_stage(
+                CoreStage::PostUpdate,
+                crate::camera::active_cameras_system.system(),
+            )
+            .add_system_to_stage(
+                CoreStage::PostUpdate,
+                crate::camera::camera_system::<OrthographicProjection>.system(),
+            );
+        let render_app = app.sub_app_mut(0);
+        render_app
+            .init_resource::<Cameras>()
+            .add_system_to_stage(RenderStage::Extract, extract_cameras.system())
+            .add_system_to_stage(RenderStage::Prepare, prepare_cameras.system());
+        let mut graph = render_app.world.get_resource_mut::<RenderGraph>().unwrap();
+        graph.add_node("camera", CameraNode);
+    }
+}
+
+#[derive(Default)]
+pub struct Cameras {
+    pub view_proj_uniforms: DynamicUniformVec<Mat4>,
+    pub entities: HashMap<String, Entity>,
+}
+
+#[derive(Debug)]
+pub struct ExtractedCamera {
+    pub projection: Mat4,
+    pub transform: Mat4,
+    pub name: Option<String>,
+}
+
+pub struct CameraUniforms {
+    pub view_proj: RenderResourceBinding,
+}
+
+fn extract_cameras(
+    mut commands: Commands,
+    active_cameras: Res<ActiveCameras>,
+    query: Query<(&Camera, &GlobalTransform)>,
+) {
+    for camera in active_cameras.iter() {
+        if let Some((camera, transform)) = camera.entity.and_then(|e| query.get(e).ok()) {
+            // TODO: remove "spawn_and_forget" hack in favor of more intelligent multiple world handling
+            commands.spawn_and_forget((ExtractedCamera {
+                projection: camera.projection_matrix,
+                transform: transform.compute_matrix(),
+                name: camera.name.clone(),
+            },));
+        }
+    }
+}
+
+fn prepare_cameras(
+    mut commands: Commands,
+    render_resources: Res<RenderResources>,
+    mut cameras: ResMut<Cameras>,
+    mut extracted_cameras: Query<(Entity, &ExtractedCamera)>,
+) {
+    cameras.entities.clear();
+    cameras
+        .view_proj_uniforms
+        .reserve_and_clear(extracted_cameras.iter_mut().len(), &render_resources);
+    for (entity, camera) in extracted_cameras.iter() {
+        let camera_uniforms = CameraUniforms {
+            view_proj: cameras
+                .view_proj_uniforms
+                .push(camera.projection * camera.transform.inverse()),
+        };
+        commands.entity(entity).insert(camera_uniforms);
+        if let Some(name) = camera.name.as_ref() {
+            cameras.entities.insert(name.to_string(), entity);
+        }
+    }
+
+    cameras
+        .view_proj_uniforms
+        .write_to_staging_buffer(&render_resources);
+}
+
+pub struct CameraNode;
+
+impl Node for CameraNode {
+    fn update(
+        &mut self,
+        world: &World,
+        render_context: &mut dyn RenderContext,
+        _input: &ResourceSlots,
+        _output: &mut ResourceSlots,
+    ) {
+        let camera_uniforms = world.get_resource::<Cameras>().unwrap();
+        camera_uniforms
+            .view_proj_uniforms
+            .write_to_uniform_buffer(render_context);
+    }
+}
diff --git a/pipelined/bevy_render2/src/camera/projection.rs b/pipelined/bevy_render2/src/camera/projection.rs
new file mode 100644
index 0000000000..4e227654f9
--- /dev/null
+++ b/pipelined/bevy_render2/src/camera/projection.rs
@@ -0,0 +1,164 @@
+use super::DepthCalculation;
+use bevy_ecs::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;
+}
+
+#[derive(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_rh(self.fov, self.aspect_ratio, self.near, self.far)
+    }
+
+    fn update(&mut self, width: f32, height: f32) {
+        self.aspect_ratio = width / height;
+    }
+
+    fn depth_calculation(&self) -> DepthCalculation {
+        DepthCalculation::Distance
+    }
+}
+
+impl Default for PerspectiveProjection {
+    fn default() -> Self {
+        PerspectiveProjection {
+            fov: std::f32::consts::PI / 4.0,
+            near: 1.0,
+            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(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,
+            self.near,
+            self.far,
+        )
+    }
+
+    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
+    }
+}
+
+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/color.rs b/pipelined/bevy_render2/src/color/color.rs
new file mode 100644
index 0000000000..223097b8e4
--- /dev/null
+++ b/pipelined/bevy_render2/src/color/color.rs
@@ -0,0 +1,1222 @@
+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
+    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 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/color/colorspace.rs b/pipelined/bevy_render2/src/color/colorspace.rs
new file mode 100644
index 0000000000..677b115276
--- /dev/null
+++ b/pipelined/bevy_render2/src/color/colorspace.rs
@@ -0,0 +1,201 @@
+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 {
+    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
+        }
+    }
+
+    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
+    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
+    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..b151a05e3f
--- /dev/null
+++ b/pipelined/bevy_render2/src/color/mod.rs
@@ -0,0 +1,5 @@
+mod color;
+mod colorspace;
+
+pub use color::*;
+pub use colorspace::*;
\ No newline at end of file
diff --git a/pipelined/bevy_render2/src/lib.rs b/pipelined/bevy_render2/src/lib.rs
new file mode 100644
index 0000000000..371c518ace
--- /dev/null
+++ b/pipelined/bevy_render2/src/lib.rs
@@ -0,0 +1,110 @@
+pub mod camera;
+pub mod color;
+pub mod main_pass;
+pub mod mesh;
+pub mod pass;
+pub mod pipeline;
+pub mod render_command;
+pub mod render_graph;
+pub mod render_resource;
+pub mod renderer;
+pub mod shader;
+pub mod texture;
+
+pub use once_cell;
+
+use crate::{
+    render_command::RenderCommandPlugin, render_graph::RenderGraph, renderer::RenderResources,
+    texture::TexturePlugin,
+};
+use bevy_app::{App, Plugin, StartupStage};
+use bevy_ecs::prelude::*;
+use bevy_utils::tracing::warn;
+
+#[derive(Default)]
+pub struct RenderPlugin;
+
+/// The names of the default App stages
+#[derive(Debug, Hash, PartialEq, Eq, Clone, StageLabel)]
+pub enum RenderStage {
+    /// Extract data from "app world" and insert it into "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 extracted data.
+    Prepare,
+
+    /// Create Bind Groups that depend on Prepare data and queue up draw calls to run during the Render stage.
+    Queue,
+
+    /// Actual rendering happens here. In most cases, only the render backend should insert resources here
+    Render,
+}
+
+impl Plugin for RenderPlugin {
+    fn build(&self, app: &mut App) {
+        app.add_startup_system_to_stage(
+            StartupStage::PreStartup,
+            check_for_render_resource_context.system(),
+        );
+        let mut render_app = App::empty();
+        let mut extract_stage = SystemStage::parallel();
+        // 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::Render, SystemStage::parallel());
+        render_app.insert_resource(RenderGraph::default());
+        app.add_sub_app(render_app, |app_world, render_app| {
+            // extract
+            extract(app_world, render_app);
+
+            // prepare
+            let prepare = render_app
+                .schedule
+                .get_stage_mut::<SystemStage>(&RenderStage::Prepare)
+                .unwrap();
+            prepare.run(&mut render_app.world);
+
+            // queue
+            let queue = render_app
+                .schedule
+                .get_stage_mut::<SystemStage>(&RenderStage::Queue)
+                .unwrap();
+            queue.run(&mut render_app.world);
+
+            // render
+            let render = render_app
+                .schedule
+                .get_stage_mut::<SystemStage>(&RenderStage::Render)
+                .unwrap();
+            render.run(&mut render_app.world);
+
+            render_app.world.clear_entities();
+        });
+
+        app.add_plugin(RenderCommandPlugin)
+            .add_plugin(TexturePlugin);
+    }
+}
+
+fn extract(app_world: &mut World, render_app: &mut App) {
+    let extract = render_app
+        .schedule
+        .get_stage_mut::<SystemStage>(&RenderStage::Extract)
+        .unwrap();
+    extract.run(app_world);
+    extract.apply_buffers(&mut render_app.world);
+}
+
+fn check_for_render_resource_context(context: Option<Res<RenderResources>>) {
+    if context.is_none() {
+        warn!(
+            "bevy_render couldn't find a render backend. Perhaps try adding the bevy_wgpu feature/plugin!"
+        );
+    }
+}
diff --git a/pipelined/bevy_render2/src/main_pass/draw.rs b/pipelined/bevy_render2/src/main_pass/draw.rs
new file mode 100644
index 0000000000..52c7c75f21
--- /dev/null
+++ b/pipelined/bevy_render2/src/main_pass/draw.rs
@@ -0,0 +1,26 @@
+use crate::main_pass::TrackedRenderPass;
+use bevy_ecs::world::World;
+use parking_lot::Mutex;
+
+// TODO: should this be generic on "drawn thing"? would provide more flexibility and  explicitness
+// instead of hard coded draw key and sort key
+pub trait Draw: Send + Sync + 'static {
+    fn draw(
+        &mut self,
+        world: &World,
+        pass: &mut TrackedRenderPass,
+        draw_key: usize,
+        sort_key: usize,
+    );
+}
+
+#[derive(Default)]
+pub struct DrawFunctions {
+    pub draw_function: Mutex<Vec<Box<dyn Draw>>>,
+}
+
+impl DrawFunctions {
+    pub fn add<D: Draw>(&self, draw_function: D) {
+        self.draw_function.lock().push(Box::new(draw_function));
+    }
+}
diff --git a/pipelined/bevy_render2/src/main_pass/draw_state.rs b/pipelined/bevy_render2/src/main_pass/draw_state.rs
new file mode 100644
index 0000000000..356b61ccdc
--- /dev/null
+++ b/pipelined/bevy_render2/src/main_pass/draw_state.rs
@@ -0,0 +1,154 @@
+use crate::{
+    pass::RenderPass,
+    pipeline::{BindGroupDescriptorId, IndexFormat, PipelineId},
+    render_resource::{BindGroupId, BufferId},
+};
+use std::ops::Range;
+
+/// Tracks the current pipeline state to ensure draw calls are valid.
+#[derive(Debug, Default)]
+pub struct DrawState {
+    pipeline: Option<PipelineId>,
+    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: Option<&[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();
+        if let Some(indices) = dynamic_indices {
+            self.bind_groups[index].1.extend(indices);
+        }
+    }
+
+    pub fn is_bind_group_set(
+        &self,
+        index: usize,
+        bind_group: BindGroupId,
+        dynamic_indices: Option<&[u32]>,
+    ) -> bool {
+        if let Some(current_bind_group) = self.bind_groups.get(index) {
+            if let Some(dynamic_indices) = dynamic_indices {
+                current_bind_group.0 == Some(bind_group) && dynamic_indices == current_bind_group.1
+            } else {
+                current_bind_group.0 == Some(bind_group)
+            }
+        } 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: PipelineId) -> bool {
+        self.pipeline == Some(pipeline)
+    }
+
+    pub fn set_pipeline(&mut self, pipeline: PipelineId) {
+        // TODO: do these need to be cleared?
+        // self.bind_groups.clear();
+        // self.vertex_buffers.clear();
+        // self.index_buffer = None;
+        self.pipeline = Some(pipeline);
+    }
+}
+
+pub struct TrackedRenderPass<'a> {
+    pass: &'a mut dyn RenderPass,
+    state: DrawState,
+}
+
+impl<'a> TrackedRenderPass<'a> {
+    pub fn new(pass: &'a mut dyn RenderPass) -> Self {
+        Self {
+            state: DrawState::default(),
+            pass,
+        }
+    }
+    pub fn set_pipeline(&mut self, pipeline: PipelineId) {
+        if self.state.is_pipeline_set(pipeline) {
+            return;
+        }
+        self.pass.set_pipeline(pipeline);
+        self.state.set_pipeline(pipeline);
+    }
+
+    pub fn set_bind_group(
+        &mut self,
+        index: usize,
+        bind_group_descriptor: BindGroupDescriptorId,
+        bind_group: BindGroupId,
+        dynamic_uniform_indices: Option<&[u32]>,
+    ) {
+        if self
+            .state
+            .is_bind_group_set(index as usize, bind_group, dynamic_uniform_indices)
+        {
+            return;
+        }
+        self.pass.set_bind_group(
+            index as u32,
+            bind_group_descriptor,
+            bind_group,
+            dynamic_uniform_indices,
+        );
+        self.state
+            .set_bind_group(index as usize, bind_group, dynamic_uniform_indices);
+    }
+
+    pub fn set_vertex_buffer(&mut self, index: usize, buffer: BufferId, offset: u64) {
+        if self.state.is_vertex_buffer_set(index, buffer, offset) {
+            return;
+        }
+        self.pass.set_vertex_buffer(index as u32, buffer, offset);
+        self.state.set_vertex_buffer(index, buffer, offset);
+    }
+
+    pub fn set_index_buffer(&mut self, buffer: BufferId, offset: u64, index_format: IndexFormat) {
+        if self.state.is_index_buffer_set(buffer, offset, index_format) {
+            return;
+        }
+        self.pass.set_index_buffer(buffer, offset, index_format);
+        self.state.set_index_buffer(buffer, offset, index_format);
+    }
+
+    pub fn draw_indexed(&mut self, indices: Range<u32>, base_vertex: i32, instances: Range<u32>) {
+        self.pass.draw_indexed(indices, base_vertex, instances);
+    }
+}
diff --git a/pipelined/bevy_render2/src/main_pass/mod.rs b/pipelined/bevy_render2/src/main_pass/mod.rs
new file mode 100644
index 0000000000..4bbee2ef33
--- /dev/null
+++ b/pipelined/bevy_render2/src/main_pass/mod.rs
@@ -0,0 +1,136 @@
+mod draw_state;
+mod draw;
+
+pub use draw_state::*;
+pub use draw::*;
+
+use crate::{RenderStage, pass::RenderPassColorAttachment, renderer::RenderContext};
+use crate::{
+    camera::CameraPlugin,
+    color::Color,
+    pass::{
+        LoadOp, Operations, PassDescriptor, RenderPass,
+        TextureAttachment,
+    },
+    render_graph::{Node, RenderGraph, ResourceSlotInfo, ResourceSlots, WindowSwapChainNode},
+    render_resource::RenderResourceType,
+};
+use bevy_app::{App, Plugin};
+use bevy_ecs::prelude::*;
+use bevy_window::WindowId;
+use std::borrow::Cow;
+
+#[derive(Default)]
+pub struct MainPassPlugin;
+
+impl Plugin for MainPassPlugin {
+    fn build(&self, app: &mut App) {
+        // TODO: this should probably just be a dependency
+        app.add_plugin(CameraPlugin);
+        app.sub_app_mut(0)
+            .add_system_to_stage(
+                RenderStage::Prepare,
+                clear_transparent_phase.exclusive_system().at_start(),
+            )
+            .init_resource::<RenderPhase>()
+            .init_resource::<DrawFunctions>();
+        let render_world = app.sub_app_mut(0).world.cell();
+        let mut graph = render_world.get_resource_mut::<RenderGraph>().unwrap();
+        graph.add_node("main_pass", MainPassNode);
+        graph.add_node_edge("camera", "main_pass").unwrap();
+        graph.add_node(
+            "primary_swap_chain",
+            WindowSwapChainNode::new(WindowId::primary()),
+        );
+        graph
+            .add_slot_edge(
+                "primary_swap_chain",
+                WindowSwapChainNode::OUT_TEXTURE,
+                "main_pass",
+                MainPassNode::IN_COLOR_ATTACHMENT,
+            )
+            .unwrap();
+    }
+}
+
+// TODO: sort out the best place for this
+fn clear_transparent_phase(mut transparent_phase: ResMut<RenderPhase>) {
+    // TODO: TRANSPARENT PHASE SHOULD NOT BE CLEARED HERE!
+    transparent_phase.drawn_things.clear();
+}
+
+pub struct Drawable {
+    pub draw_function: usize,
+    pub draw_key: usize,
+    pub sort_key: usize,
+}
+
+#[derive(Default)]
+pub struct RenderPhase {
+    drawn_things: Vec<Drawable>,
+}
+
+impl RenderPhase {
+    #[inline]
+    pub fn add(&mut self, drawable: Drawable) {
+        self.drawn_things.push(drawable);
+    }
+
+    pub fn sort(&mut self) {
+        self.drawn_things.sort_by_key(|d| d.sort_key);
+    }
+}
+
+pub struct MainPassNode;
+
+impl MainPassNode {
+    pub const IN_COLOR_ATTACHMENT: &'static str = "color_attachment";
+}
+
+impl Node for MainPassNode {
+    fn input(&self) -> &[ResourceSlotInfo] {
+        static INPUT: &[ResourceSlotInfo] = &[ResourceSlotInfo {
+            name: Cow::Borrowed(MainPassNode::IN_COLOR_ATTACHMENT),
+            resource_type: RenderResourceType::Texture,
+        }];
+        INPUT
+    }
+    fn update(
+        &mut self,
+        world: &World,
+        render_context: &mut dyn RenderContext,
+        input: &ResourceSlots,
+        _output: &mut ResourceSlots,
+    ) {
+        // TODO: consider adding shorthand like `get_texture(0)`
+        let color_attachment_texture = input.get(0).unwrap().get_texture().unwrap();
+        let pass_descriptor = PassDescriptor {
+            color_attachments: vec![RenderPassColorAttachment {
+                attachment: TextureAttachment::Id(color_attachment_texture),
+                resolve_target: None,
+                ops: Operations {
+                    load: LoadOp::Clear(Color::rgb(0.4, 0.4, 0.4)),
+                    store: true,
+                },
+            }],
+            depth_stencil_attachment: None,
+            sample_count: 1,
+        };
+
+        let transparent_phase = world.get_resource::<RenderPhase>().unwrap();
+        let draw_functions = world.get_resource::<DrawFunctions>().unwrap();
+
+        render_context.begin_pass(&pass_descriptor, &mut |render_pass: &mut dyn RenderPass| {
+            let mut draw_functions = draw_functions.draw_function.lock();
+            let mut tracked_pass = TrackedRenderPass::new(render_pass);
+            for drawable in transparent_phase.drawn_things.iter() {
+                draw_functions[drawable.draw_function].draw(
+                    world,
+                    &mut tracked_pass,
+                    drawable.draw_key,
+                    drawable.sort_key,
+                );
+            }
+        })
+    }
+}
diff --git a/pipelined/bevy_render2/src/mesh/mesh.rs b/pipelined/bevy_render2/src/mesh/mesh.rs
new file mode 100644
index 0000000000..a7e9c36154
--- /dev/null
+++ b/pipelined/bevy_render2/src/mesh/mesh.rs
@@ -0,0 +1,462 @@
+mod conversions;
+
+use crate::pipeline::{IndexFormat, InputStepMode, PrimitiveTopology, VertexAttribute, VertexBufferLayout, VertexFormat};
+use bevy_core::cast_slice;
+use bevy_math::*;
+use bevy_reflect::TypeUuid;
+use bevy_utils::EnumVariantMeta;
+use std::{borrow::Cow, collections::BTreeMap};
+
+pub const INDEX_BUFFER_ASSET_INDEX: u64 = 0;
+pub const VERTEX_ATTRIBUTE_BUFFER_ID: u64 = 10;
+
+/// An array where each entry describes a property of a single vertex.
+#[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
+    }
+
+    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 {
+    fn iter(&self) -> impl Iterator<Item = usize> + '_ {
+        match self {
+            Indices::U16(vec) => IndicesIter::U16(vec.iter()),
+            Indices::U32(vec) => IndicesIter::U32(vec.iter()),
+        }
+    }
+}
+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,
+        }
+    }
+}
+
+// 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_render::mesh::{Mesh, Indices};
+/// # use bevy_render::pipeline::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,
+        }
+    }
+
+    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);
+    }
+
+    /// Retrieve the data currently set behind a vertex attribute.
+    pub fn attribute(&self, name: impl Into<Cow<'static, str>>) -> Option<&VertexAttributeValues> {
+        self.attributes.get(&name.into())
+    }
+
+    pub fn attribute_mut(
+        &mut self,
+        name: impl Into<Cow<'static, str>>,
+    ) -> Option<&mut VertexAttributeValues> {
+        self.attributes.get_mut(&name.into())
+    }
+
+    /// Indices describe how triangles are constructed out of the vertex attributes.
+    /// They are only useful for the [`crate::pipeline::PrimitiveTopology`] variants that use
+    /// triangles
+    pub fn set_indices(&mut self, indices: Option<Indices>) {
+        self.indices = indices;
+    }
+
+    pub fn indices(&self) -> Option<&Indices> {
+        self.indices.as_ref()
+    }
+
+    pub fn indices_mut(&mut self) -> Option<&mut Indices> {
+        self.indices.as_mut()
+    }
+
+    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,
+        }
+    }
+
+    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)
+    }
+
+    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.
+    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 if [`Indices`] are set.
+    /// 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);
+    }
+}
+
+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()
+}
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..51170afc2b
--- /dev/null
+++ b/pipelined/bevy_render2/src/mesh/mesh/conversions.rs
@@ -0,0 +1,521 @@
+//! These implementations allow you to
+//! convert std::vec::Vec<T> to VertexAttributeValues::T and back.
+//!
+//! # Examples
+//!
+//! ```rust
+//! use bevy_render::mesh::VertexAttributeValues;
+//! use std::convert::{ TryInto, TryFrom };
+//!
+//! // creating std::vec::Vec
+//! let buffer = vec![[0_u32; 4]; 10];
+//!
+//! // converting std::vec::Vec to bevy_render::mesh::VertexAttributeValues
+//! let values = VertexAttributeValues::from(buffer.clone());
+//!
+//! // converting bevy_render::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 std::convert::TryFrom;
+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;
+    use std::convert::{TryFrom, TryInto};
+    #[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/mod.rs b/pipelined/bevy_render2/src/mesh/mod.rs
new file mode 100644
index 0000000000..4ed2fc54ef
--- /dev/null
+++ b/pipelined/bevy_render2/src/mesh/mod.rs
@@ -0,0 +1,6 @@
+#[allow(clippy::module_inception)]
+mod mesh;
+/// Generation for some primitive shape meshes.
+pub mod shape;
+
+pub use mesh::*;
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..aaba621cc7
--- /dev/null
+++ b/pipelined/bevy_render2/src/mesh/shape/capsule.rs
@@ -0,0 +1,381 @@
+use crate::{
+    mesh::{Indices, Mesh},
+    pipeline::PrimitiveTopology,
+};
+use bevy_math::{Vec2, Vec3};
+
+/// 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..f1e07a0ecf
--- /dev/null
+++ b/pipelined/bevy_render2/src/mesh/shape/icosphere.rs
@@ -0,0 +1,106 @@
+use hexasphere::shapes::IcoSphere;
+
+use crate::{
+    mesh::{Indices, Mesh},
+    pipeline::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..85c61e9ab9
--- /dev/null
+++ b/pipelined/bevy_render2/src/mesh/shape/mod.rs
@@ -0,0 +1,276 @@
+use super::{Indices, Mesh};
+use crate::pipeline::PrimitiveTopology;
+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()
+    }
+}
+
+#[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 {
+    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.
+#[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.
+#[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;
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..56039f3d18
--- /dev/null
+++ b/pipelined/bevy_render2/src/mesh/shape/torus.rs
@@ -0,0 +1,94 @@
+use crate::{
+    mesh::{Indices, Mesh},
+    pipeline::PrimitiveTopology,
+};
+use bevy_math::Vec3;
+
+/// 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..5addc973ff
--- /dev/null
+++ b/pipelined/bevy_render2/src/mesh/shape/uvsphere.rs
@@ -0,0 +1,91 @@
+use crate::{
+    mesh::{Indices, Mesh},
+    pipeline::PrimitiveTopology,
+};
+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/pass/mod.rs b/pipelined/bevy_render2/src/pass/mod.rs
new file mode 100644
index 0000000000..26342576ec
--- /dev/null
+++ b/pipelined/bevy_render2/src/pass/mod.rs
@@ -0,0 +1,8 @@
+mod ops;
+#[allow(clippy::module_inception)]
+mod pass;
+mod render_pass;
+
+pub use ops::*;
+pub use pass::*;
+pub use render_pass::*;
diff --git a/pipelined/bevy_render2/src/pass/ops.rs b/pipelined/bevy_render2/src/pass/ops.rs
new file mode 100644
index 0000000000..68a698541d
--- /dev/null
+++ b/pipelined/bevy_render2/src/pass/ops.rs
@@ -0,0 +1,17 @@
+/// Operation to perform to the output attachment at the start of a renderpass.
+#[derive(Clone, Copy, Debug, Hash, PartialEq)]
+pub enum LoadOp<V> {
+    /// Clear with a specified value.
+    Clear(V),
+    /// Load from memory.
+    Load,
+}
+
+/// Pair of load and store operations for an attachment aspect.
+#[derive(Clone, Debug, Hash, PartialEq)]
+pub struct Operations<V> {
+    /// How data should be read through this attachment.
+    pub load: LoadOp<V>,
+    /// Whether data will be written to through this attachment.
+    pub store: bool,
+}
diff --git a/pipelined/bevy_render2/src/pass/pass.rs b/pipelined/bevy_render2/src/pass/pass.rs
new file mode 100644
index 0000000000..1ba7bba95f
--- /dev/null
+++ b/pipelined/bevy_render2/src/pass/pass.rs
@@ -0,0 +1,56 @@
+use crate::{color::Color, pass::Operations, render_resource::TextureId};
+
+
+#[derive(Debug, Clone)]
+pub enum TextureAttachment {
+    Id(TextureId),
+    Input(String),
+}
+
+impl TextureAttachment {
+    pub fn get_texture_id(&self) -> Option<TextureId> {
+        if let TextureAttachment::Id(texture_id) = self {
+            Some(*texture_id)
+        } else {
+            None
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct ClearColor(pub Color);
+
+impl Default for ClearColor {
+    fn default() -> Self {
+        Self(Color::rgb(0.4, 0.4, 0.4))
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct RenderPassColorAttachment {
+    /// The actual color attachment.
+    pub attachment: TextureAttachment,
+
+    /// The resolve target for this color attachment, if any.
+    pub resolve_target: Option<TextureAttachment>,
+
+    /// What operations will be performed on this color attachment.
+    pub ops: Operations<Color>,
+}
+
+#[derive(Debug, Clone)]
+pub struct RenderPassDepthStencilAttachment {
+    pub attachment: TextureAttachment,
+    /// What operations will be performed on the depth part of the attachment.
+    pub depth_ops: Option<Operations<f32>>,
+    /// What operations will be performed on the stencil part of the attachment.
+    pub stencil_ops: Option<Operations<u32>>,
+}
+
+// A set of pipeline bindings and draw calls with color and depth outputs
+#[derive(Debug, Clone)]
+pub struct PassDescriptor {
+    pub color_attachments: Vec<RenderPassColorAttachment>,
+    pub depth_stencil_attachment: Option<RenderPassDepthStencilAttachment>,
+    pub sample_count: u32,
+}
diff --git a/pipelined/bevy_render2/src/pass/render_pass.rs b/pipelined/bevy_render2/src/pass/render_pass.rs
new file mode 100644
index 0000000000..541f50066d
--- /dev/null
+++ b/pipelined/bevy_render2/src/pass/render_pass.rs
@@ -0,0 +1,25 @@
+use crate::{
+    pipeline::{BindGroupDescriptorId, IndexFormat, PipelineId},
+    render_resource::{BindGroupId, BufferId},
+    renderer::RenderContext,
+};
+use std::ops::Range;
+
+pub trait RenderPass {
+    fn get_render_context(&self) -> &dyn RenderContext;
+    fn set_index_buffer(&mut self, buffer: BufferId, offset: u64, index_format: IndexFormat);
+    fn set_vertex_buffer(&mut self, start_slot: u32, buffer: BufferId, offset: u64);
+    fn set_pipeline(&mut self, pipeline: PipelineId);
+    fn set_viewport(&mut self, x: f32, y: f32, w: f32, h: f32, min_depth: f32, max_depth: f32);
+    fn set_scissor_rect(&mut self, x: u32, y: u32, w: u32, h: u32);
+    fn set_stencil_reference(&mut self, reference: u32);
+    fn draw(&mut self, vertices: Range<u32>, instances: Range<u32>);
+    fn draw_indexed(&mut self, indices: Range<u32>, base_vertex: i32, instances: Range<u32>);
+    fn set_bind_group(
+        &mut self,
+        index: u32,
+        bind_group_descriptor_id: BindGroupDescriptorId,
+        bind_group: BindGroupId,
+        dynamic_uniform_indices: Option<&[u32]>,
+    );
+}
diff --git a/pipelined/bevy_render2/src/pipeline/bind_group.rs b/pipelined/bevy_render2/src/pipeline/bind_group.rs
new file mode 100644
index 0000000000..8f244d9322
--- /dev/null
+++ b/pipelined/bevy_render2/src/pipeline/bind_group.rs
@@ -0,0 +1,49 @@
+use super::BindingDescriptor;
+use bevy_utils::AHasher;
+use std::hash::{Hash, Hasher};
+
+#[derive(Clone, Debug, Eq)]
+pub struct BindGroupDescriptor {
+    pub index: u32,
+    pub bindings: Vec<BindingDescriptor>,
+    pub id: BindGroupDescriptorId,
+}
+
+#[derive(Hash, Copy, Clone, Eq, PartialEq, Debug)]
+pub struct BindGroupDescriptorId(u64);
+
+impl BindGroupDescriptor {
+    pub fn new(index: u32, bindings: Vec<BindingDescriptor>) -> Self {
+        let mut descriptor = BindGroupDescriptor {
+            index,
+            bindings,
+            id: BindGroupDescriptorId(0),
+        };
+
+        descriptor.update_id();
+        descriptor
+    }
+
+    pub fn update_id(&mut self) {
+        let mut hasher = AHasher::default();
+        self.hash(&mut hasher);
+        self.id = BindGroupDescriptorId(hasher.finish());
+    }
+}
+
+impl Hash for BindGroupDescriptor {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        // TODO: remove index from hash state (or at least id), and update the PartialEq implem.
+        // index is not considered a part of a bind group on the gpu.
+        // bind groups are bound to indices in pipelines.
+        self.index.hash(state);
+        self.bindings.hash(state);
+    }
+}
+
+impl PartialEq for BindGroupDescriptor {
+    fn eq(&self, other: &Self) -> bool {
+        // This MUST be kept in sync with the hash implementation above
+        self.index == other.index && self.bindings == other.bindings
+    }
+}
diff --git a/pipelined/bevy_render2/src/pipeline/binding.rs b/pipelined/bevy_render2/src/pipeline/binding.rs
new file mode 100644
index 0000000000..c4b2188bd0
--- /dev/null
+++ b/pipelined/bevy_render2/src/pipeline/binding.rs
@@ -0,0 +1,82 @@
+use super::UniformProperty;
+use crate::texture::{
+    StorageTextureAccess, TextureFormat, TextureSampleType, TextureViewDimension,
+};
+
+bitflags::bitflags! {
+    pub struct BindingShaderStage: u32 {
+        const VERTEX = 1;
+        const FRAGMENT = 2;
+        const COMPUTE = 4;
+    }
+}
+
+#[derive(Hash, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
+pub struct BindingDescriptor {
+    pub name: String,
+    pub index: u32,
+    pub bind_type: BindType,
+    pub shader_stage: BindingShaderStage,
+}
+
+impl BindingDescriptor {
+    pub fn set_dynamic(&mut self, is_dynamic: bool) -> bool {
+        self.bind_type.set_dynamic(is_dynamic)
+    }
+}
+
+#[derive(Hash, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
+pub enum BindType {
+    Uniform {
+        has_dynamic_offset: bool,
+        property: UniformProperty,
+    },
+    StorageBuffer {
+        has_dynamic_offset: bool,
+        readonly: bool,
+    },
+    Sampler {
+        /// The sampling result is produced based on more than a single color sample from a
+        /// texture, e.g. when bilinear interpolation is enabled.
+        ///
+        /// A filtering sampler can only be used with a filterable texture.
+        filtering: bool,
+        /// Use as a comparison sampler instead of a normal sampler.
+        /// For more info take a look at the analogous functionality in OpenGL: <https://www.khronos.org/opengl/wiki/Sampler_Object#Comparison_mode>.
+        comparison: bool,
+    },
+    Texture {
+        multisampled: bool,
+        view_dimension: TextureViewDimension,
+        sample_type: TextureSampleType,
+    },
+    StorageTexture {
+        /// Allowed access to this texture.
+        access: StorageTextureAccess,
+        /// Format of the texture.
+        format: TextureFormat,
+        /// Dimension of the texture view that is going to be sampled.
+        view_dimension: TextureViewDimension,
+    },
+}
+
+impl BindType {
+    pub fn get_uniform_size(&self) -> Option<u64> {
+        match self {
+            BindType::Uniform { property, .. } => Some(property.get_size()),
+            _ => None,
+        }
+    }
+
+    pub fn set_dynamic(&mut self, is_dynamic: bool) -> bool {
+        match self {
+            BindType::Uniform {
+                has_dynamic_offset, ..
+            } => {
+                *has_dynamic_offset = is_dynamic;
+                true
+            }
+            _ => false,
+        }
+    }
+}
diff --git a/pipelined/bevy_render2/src/pipeline/mod.rs b/pipelined/bevy_render2/src/pipeline/mod.rs
new file mode 100644
index 0000000000..16a03e2e02
--- /dev/null
+++ b/pipelined/bevy_render2/src/pipeline/mod.rs
@@ -0,0 +1,16 @@
+mod bind_group;
+mod binding;
+#[allow(clippy::module_inception)]
+mod pipeline;
+mod pipeline_layout;
+mod state_descriptors;
+mod vertex_buffer_descriptor;
+mod vertex_format;
+
+pub use bind_group::*;
+pub use binding::*;
+pub use pipeline::*;
+pub use pipeline_layout::*;
+pub use state_descriptors::*;
+pub use vertex_buffer_descriptor::*;
+pub use vertex_format::*;
diff --git a/pipelined/bevy_render2/src/pipeline/pipeline.rs b/pipelined/bevy_render2/src/pipeline/pipeline.rs
new file mode 100644
index 0000000000..5b0a2402da
--- /dev/null
+++ b/pipelined/bevy_render2/src/pipeline/pipeline.rs
@@ -0,0 +1,120 @@
+use super::{
+    state_descriptors::{
+        BlendFactor, BlendOperation, ColorWrite, CompareFunction, Face, FrontFace,
+        PrimitiveTopology,
+    },
+    PipelineLayout,
+};
+use crate::{
+    pipeline::{
+        BlendComponent, BlendState, ColorTargetState, DepthBiasState, DepthStencilState,
+        MultisampleState, PolygonMode, PrimitiveState, StencilFaceState, StencilState,
+    },
+    shader::{ShaderStages},
+    texture::TextureFormat,
+};
+use bevy_reflect::{TypeUuid, Uuid};
+
+#[derive(Copy, Clone, Hash, Eq, PartialEq, Debug)]
+pub struct PipelineId(Uuid);
+
+impl PipelineId {
+    #[allow(clippy::new_without_default)]
+    pub fn new() -> Self {
+        PipelineId(Uuid::new_v4())
+    }
+}
+
+#[derive(Clone, Debug, TypeUuid)]
+#[uuid = "ebfc1d11-a2a4-44cb-8f12-c49cc631146c"]
+pub struct PipelineDescriptor {
+    pub name: Option<String>,
+    pub layout: PipelineLayout,
+    pub shader_stages: ShaderStages,
+    pub primitive: PrimitiveState,
+    pub depth_stencil: Option<DepthStencilState>,
+    pub multisample: MultisampleState,
+
+    /// The effect of draw calls on the color aspect of the output target.
+    pub color_target_states: Vec<ColorTargetState>,
+}
+
+impl PipelineDescriptor {
+    pub fn new(shader_stages: ShaderStages, layout: PipelineLayout) -> Self {
+        PipelineDescriptor {
+            name: None,
+            layout,
+            color_target_states: Vec::new(),
+            depth_stencil: None,
+            shader_stages,
+            primitive: PrimitiveState {
+                topology: PrimitiveTopology::TriangleList,
+                strip_index_format: None,
+                front_face: FrontFace::Ccw,
+                cull_mode: Some(Face::Back),
+                polygon_mode: PolygonMode::Fill,
+                clamp_depth: false,
+                conservative: false,
+            },
+            multisample: MultisampleState {
+                count: 1,
+                mask: !0,
+                alpha_to_coverage_enabled: false,
+            },
+        }
+    }
+
+    pub fn default_config(shader_stages: ShaderStages, layout: PipelineLayout) -> Self {
+        PipelineDescriptor {
+            name: None,
+            primitive: PrimitiveState {
+                topology: PrimitiveTopology::TriangleList,
+                strip_index_format: None,
+                front_face: FrontFace::Ccw,
+                cull_mode: Some(Face::Back),
+                polygon_mode: PolygonMode::Fill,
+                clamp_depth: false,
+                conservative: false,
+            },
+            layout,
+            depth_stencil: Some(DepthStencilState {
+                format: TextureFormat::Depth32Float,
+                depth_write_enabled: true,
+                depth_compare: CompareFunction::Less,
+                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,
+                },
+            }),
+            color_target_states: vec![ColorTargetState {
+                format: TextureFormat::default(),
+                blend: Some(BlendState {
+                    color: BlendComponent {
+                        src_factor: BlendFactor::SrcAlpha,
+                        dst_factor: BlendFactor::OneMinusSrcAlpha,
+                        operation: BlendOperation::Add,
+                    },
+                    alpha: BlendComponent {
+                        src_factor: BlendFactor::One,
+                        dst_factor: BlendFactor::One,
+                        operation: BlendOperation::Add,
+                    },
+                }),
+                write_mask: ColorWrite::ALL,
+            }],
+            multisample: MultisampleState {
+                count: 1,
+                mask: !0,
+                alpha_to_coverage_enabled: false,
+            },
+            shader_stages,
+        }
+    }
+}
diff --git a/pipelined/bevy_render2/src/pipeline/pipeline_layout.rs b/pipelined/bevy_render2/src/pipeline/pipeline_layout.rs
new file mode 100644
index 0000000000..46c25b1e88
--- /dev/null
+++ b/pipelined/bevy_render2/src/pipeline/pipeline_layout.rs
@@ -0,0 +1,106 @@
+use super::{BindGroupDescriptor, VertexBufferLayout};
+use crate::shader::ShaderLayout;
+use bevy_utils::HashMap;
+use std::hash::Hash;
+
+#[derive(Clone, Debug, Default)]
+pub struct PipelineLayout {
+    pub bind_groups: Vec<BindGroupDescriptor>,
+    // TODO: rename me
+    pub vertex_buffer_descriptors: Vec<VertexBufferLayout>,
+}
+
+impl PipelineLayout {
+    pub fn get_bind_group(&self, index: u32) -> Option<&BindGroupDescriptor> {
+        self.bind_groups
+            .iter()
+            .find(|bind_group| bind_group.index == index)
+    }
+
+    pub fn from_shader_layouts(shader_layouts: &mut [ShaderLayout]) -> Self {
+        let mut bind_groups = HashMap::<u32, BindGroupDescriptor>::default();
+        let mut vertex_buffer_descriptors = Vec::new();
+        for shader_layout in shader_layouts.iter_mut() {
+            for shader_bind_group in shader_layout.bind_groups.iter_mut() {
+                match bind_groups.get_mut(&shader_bind_group.index) {
+                    Some(bind_group) => {
+                        for shader_binding in shader_bind_group.bindings.iter() {
+                            if let Some(binding) = bind_group
+                                .bindings
+                                .iter_mut()
+                                .find(|binding| binding.index == shader_binding.index)
+                            {
+                                binding.shader_stage |= shader_binding.shader_stage;
+                                if binding.bind_type != shader_binding.bind_type
+                                    || binding.name != shader_binding.name
+                                    || binding.index != shader_binding.index
+                                {
+                                    panic!("Binding {} in BindGroup {} does not match across all shader types: {:?} {:?}.", binding.index, bind_group.index, binding, shader_binding);
+                                }
+                            } else {
+                                bind_group.bindings.push(shader_binding.clone());
+                            }
+                        }
+                        bind_group.update_id();
+                    }
+                    None => {
+                        bind_groups.insert(shader_bind_group.index, shader_bind_group.clone());
+                    }
+                }
+            }
+        }
+
+        for vertex_buffer_descriptor in shader_layouts[0].vertex_buffer_layout.iter() {
+            vertex_buffer_descriptors.push(vertex_buffer_descriptor.clone());
+        }
+
+        let mut bind_groups_result = bind_groups
+            .drain()
+            .map(|(_, value)| value)
+            .collect::<Vec<BindGroupDescriptor>>();
+
+        // NOTE: for some reason bind groups need to be sorted by index. this is likely an issue
+        // with bevy and not with wgpu TODO: try removing this
+        bind_groups_result.sort_by(|a, b| a.index.partial_cmp(&b.index).unwrap());
+
+        PipelineLayout {
+            bind_groups: bind_groups_result,
+            vertex_buffer_descriptors,
+        }
+    }
+}
+
+#[derive(Hash, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
+pub enum UniformProperty {
+    UInt,
+    Int,
+    IVec2,
+    Float,
+    UVec4,
+    Vec2,
+    Vec3,
+    Vec4,
+    Mat3,
+    Mat4,
+    Struct(Vec<UniformProperty>),
+    Array(Box<UniformProperty>, usize),
+}
+
+impl UniformProperty {
+    pub fn get_size(&self) -> u64 {
+        match self {
+            UniformProperty::UInt => 4,
+            UniformProperty::Int => 4,
+            UniformProperty::IVec2 => 4 * 2,
+            UniformProperty::Float => 4,
+            UniformProperty::UVec4 => 4 * 4,
+            UniformProperty::Vec2 => 4 * 2,
+            UniformProperty::Vec3 => 4 * 3,
+            UniformProperty::Vec4 => 4 * 4,
+            UniformProperty::Mat3 => 4 * 4 * 3,
+            UniformProperty::Mat4 => 4 * 4 * 4,
+            UniformProperty::Struct(properties) => properties.iter().map(|p| p.get_size()).sum(),
+            UniformProperty::Array(property, length) => property.get_size() * *length as u64,
+        }
+    }
+}
diff --git a/pipelined/bevy_render2/src/pipeline/state_descriptors.rs b/pipelined/bevy_render2/src/pipeline/state_descriptors.rs
new file mode 100644
index 0000000000..5196d50df1
--- /dev/null
+++ b/pipelined/bevy_render2/src/pipeline/state_descriptors.rs
@@ -0,0 +1,232 @@
+use crate::texture::TextureFormat;
+use bevy_reflect::{Reflect, ReflectDeserialize};
+use serde::{Deserialize, Serialize};
+
+#[derive(Clone, Debug)]
+pub struct DepthStencilState {
+    pub format: TextureFormat,
+    pub depth_write_enabled: bool,
+    pub depth_compare: CompareFunction,
+    pub stencil: StencilState,
+    pub bias: DepthBiasState,
+}
+
+#[derive(Clone, Debug)]
+pub struct StencilState {
+    pub front: StencilFaceState,
+    pub back: StencilFaceState,
+    pub read_mask: u32,
+    pub write_mask: u32,
+}
+#[derive(Clone, Debug)]
+pub struct MultisampleState {
+    /// The number of samples calculated per pixel (for MSAA). For non-multisampled textures,
+    /// this should be `1`
+    pub count: u32,
+    /// Bitmask that restricts the samples of a pixel modified by this pipeline. All samples
+    /// can be enabled using the value `!0`
+    pub mask: u64,
+    /// When enabled, produces another sample mask per pixel based on the alpha output value, that
+    /// is ANDed with the sample_mask and the primitive coverage to restrict the set of samples
+    /// affected by a primitive.
+    ///
+    /// The implicit mask produced for alpha of zero is guaranteed to be zero, and for alpha of one
+    /// is guaranteed to be all 1-s.
+    pub alpha_to_coverage_enabled: bool,
+}
+
+#[derive(Clone, Debug)]
+pub struct DepthBiasState {
+    /// Constant depth biasing factor, in basic units of the depth format.
+    pub constant: i32,
+    /// Slope depth biasing factor.
+    pub slope_scale: f32,
+    /// Depth bias clamp value (absolute).
+    pub clamp: f32,
+}
+
+#[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
+pub enum StencilOperation {
+    Keep = 0,
+    Zero = 1,
+    Replace = 2,
+    Invert = 3,
+    IncrementClamp = 4,
+    DecrementClamp = 5,
+    IncrementWrap = 6,
+    DecrementWrap = 7,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct StencilFaceState {
+    pub compare: CompareFunction,
+    pub fail_op: StencilOperation,
+    pub depth_fail_op: StencilOperation,
+    pub pass_op: StencilOperation,
+}
+
+impl StencilFaceState {
+    pub const IGNORE: Self = StencilFaceState {
+        compare: CompareFunction::Always,
+        fail_op: StencilOperation::Keep,
+        depth_fail_op: StencilOperation::Keep,
+        pass_op: StencilOperation::Keep,
+    };
+}
+
+#[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
+pub enum CompareFunction {
+    Never = 0,
+    Less = 1,
+    Equal = 2,
+    LessEqual = 3,
+    Greater = 4,
+    NotEqual = 5,
+    GreaterEqual = 6,
+    Always = 7,
+}
+
+/// Describes how the VertexAttributes should be interpreted while rendering
+#[derive(Copy, Clone, Debug, Hash, Eq, PartialEq, Serialize, Deserialize, Reflect)]
+#[reflect_value(Serialize, Deserialize, PartialEq, Hash)]
+pub enum PrimitiveTopology {
+    PointList = 0,
+    LineList = 1,
+    LineStrip = 2,
+    TriangleList = 3,
+    TriangleStrip = 4,
+}
+
+impl Default for PrimitiveTopology {
+    fn default() -> Self {
+        PrimitiveTopology::TriangleList
+    }
+}
+
+#[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
+pub enum FrontFace {
+    Ccw = 0,
+    Cw = 1,
+}
+
+impl Default for FrontFace {
+    fn default() -> Self {
+        FrontFace::Ccw
+    }
+}
+
+#[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
+pub enum Face {
+    Front = 0,
+    Back = 1,
+}
+
+#[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
+pub enum PolygonMode {
+    /// Polygons are filled
+    Fill = 0,
+    /// Polygons are draw as line segments
+    Line = 1,
+    /// Polygons are draw as points
+    Point = 2,
+}
+
+impl Default for PolygonMode {
+    fn default() -> Self {
+        PolygonMode::Fill
+    }
+}
+
+#[derive(Clone, Debug, Default)]
+pub struct PrimitiveState {
+    pub topology: PrimitiveTopology,
+    pub strip_index_format: Option<IndexFormat>,
+    pub front_face: FrontFace,
+    pub cull_mode: Option<Face>,
+    pub polygon_mode: PolygonMode,
+    pub clamp_depth: bool,
+    pub conservative: bool,
+}
+
+#[derive(Clone, Debug)]
+pub struct ColorTargetState {
+    pub format: TextureFormat,
+    pub blend: Option<BlendState>,
+    pub write_mask: ColorWrite,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct BlendComponent {
+    pub src_factor: BlendFactor,
+    pub dst_factor: BlendFactor,
+    pub operation: BlendOperation,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct BlendState {
+    pub alpha: BlendComponent,
+    pub color: BlendComponent,
+}
+
+bitflags::bitflags! {
+    #[repr(transparent)]
+    pub struct ColorWrite: u32 {
+        const RED = 1;
+        const GREEN = 2;
+        const BLUE = 4;
+        const ALPHA = 8;
+        const COLOR = 7;
+        const ALL = 15;
+    }
+}
+
+impl Default for ColorWrite {
+    fn default() -> Self {
+        ColorWrite::ALL
+    }
+}
+
+#[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
+pub enum BlendFactor {
+    Zero = 0,
+    One = 1,
+    Src = 2,
+    OneMinusSrc = 3,
+    SrcAlpha = 4,
+    OneMinusSrcAlpha = 5,
+    Dst = 6,
+    OneMinusDst = 7,
+    DstAlpha = 8,
+    OneMinusDstAlpha = 9,
+    SrcAlphaSaturated = 10,
+    Constant = 11,
+    OneMinusConstant = 12,
+}
+
+#[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
+pub enum BlendOperation {
+    Add = 0,
+    Subtract = 1,
+    ReverseSubtract = 2,
+    Min = 3,
+    Max = 4,
+}
+
+impl Default for BlendOperation {
+    fn default() -> Self {
+        BlendOperation::Add
+    }
+}
+
+#[derive(Copy, Clone, Debug, Hash, Eq, PartialEq, Serialize, Deserialize, Reflect)]
+#[reflect_value(Hash, PartialEq, Serialize, Deserialize)]
+pub enum IndexFormat {
+    Uint16 = 0,
+    Uint32 = 1,
+}
+
+impl Default for IndexFormat {
+    fn default() -> Self {
+        IndexFormat::Uint32
+    }
+}
diff --git a/pipelined/bevy_render2/src/pipeline/vertex_buffer_descriptor.rs b/pipelined/bevy_render2/src/pipeline/vertex_buffer_descriptor.rs
new file mode 100644
index 0000000000..a891cb3720
--- /dev/null
+++ b/pipelined/bevy_render2/src/pipeline/vertex_buffer_descriptor.rs
@@ -0,0 +1,56 @@
+use super::VertexFormat;
+use bevy_reflect::{Reflect, ReflectDeserialize};
+use serde::{Deserialize, Serialize};
+use std::{
+    borrow::Cow,
+    hash::{Hash, Hasher},
+};
+
+#[derive(Clone, Debug, Eq, PartialEq, Default, Reflect, Serialize, Deserialize)]
+#[reflect_value(Serialize, Deserialize, PartialEq)]
+pub struct VertexBufferLayout {
+    pub name: Cow<'static, str>,
+    pub stride: u64,
+    pub step_mode: InputStepMode,
+    pub attributes: Vec<VertexAttribute>,
+}
+
+impl VertexBufferLayout {
+    pub fn new_from_attribute(
+        attribute: VertexAttribute,
+        step_mode: InputStepMode,
+    ) -> VertexBufferLayout {
+        VertexBufferLayout {
+            name: attribute.name.clone(),
+            stride: attribute.format.get_size(),
+            step_mode,
+            attributes: vec![attribute],
+        }
+    }
+}
+#[derive(Copy, Clone, Debug, Hash, Eq, PartialEq, Serialize, Deserialize)]
+pub enum InputStepMode {
+    Vertex = 0,
+    Instance = 1,
+}
+
+impl Default for InputStepMode {
+    fn default() -> Self {
+        InputStepMode::Vertex
+    }
+}
+
+#[derive(Clone, Debug, Hash, Eq, PartialEq, Serialize, Deserialize)]
+pub struct VertexAttribute {
+    pub name: Cow<'static, str>,
+    pub format: VertexFormat,
+    pub offset: u64,
+    pub shader_location: u32,
+}
+
+/// Internally, `bevy_render` uses hashes to identify vertex attribute names.
+pub fn get_vertex_attribute_name_id(name: &str) -> u64 {
+    let mut hasher = bevy_utils::AHasher::default();
+    hasher.write(&name.as_bytes());
+    hasher.finish()
+}
diff --git a/pipelined/bevy_render2/src/pipeline/vertex_format.rs b/pipelined/bevy_render2/src/pipeline/vertex_format.rs
new file mode 100644
index 0000000000..3662e1046e
--- /dev/null
+++ b/pipelined/bevy_render2/src/pipeline/vertex_format.rs
@@ -0,0 +1,136 @@
+use crate::color::Color;
+use bevy_math::{Mat4, Vec2, Vec3, Vec4};
+use serde::{Deserialize, Serialize};
+#[derive(Copy, Clone, Debug, Hash, Eq, PartialEq, Serialize, Deserialize)]
+pub enum VertexFormat {
+    Uint8x2 = 1,
+    Uint8x4 = 3,
+    Sint8x2 = 5,
+    Sint8x4 = 7,
+    Unorm8x2 = 9,
+    Unorm8x4 = 11,
+    Snorm8x2 = 14,
+    Snorm8x4 = 16,
+    Uint16x2 = 18,
+    Uint16x4 = 20,
+    Sint16x2 = 22,
+    Sint16x4 = 24,
+    Unorm16x2 = 26,
+    Unorm16x4 = 28,
+    Snorm16x2 = 30,
+    Snorm16x4 = 32,
+    Float16x2 = 34,
+    Float16x4 = 36,
+    Float32 = 37,
+    Float32x2 = 38,
+    Float32x3 = 39,
+    Float32x4 = 40,
+    Uint32 = 41,
+    Uint32x2 = 42,
+    Uint32x3 = 43,
+    Uint32x4 = 44,
+    Sint32 = 45,
+    Sint32x2 = 46,
+    Sint32x3 = 47,
+    Sint32x4 = 48,
+}
+
+impl VertexFormat {
+    pub 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,
+        }
+    }
+}
+
+pub trait AsVertexFormats {
+    fn as_vertex_formats() -> &'static [VertexFormat];
+}
+
+impl AsVertexFormats for f32 {
+    fn as_vertex_formats() -> &'static [VertexFormat] {
+        &[VertexFormat::Float32]
+    }
+}
+
+impl AsVertexFormats for Vec2 {
+    fn as_vertex_formats() -> &'static [VertexFormat] {
+        &[VertexFormat::Float32x2]
+    }
+}
+
+impl AsVertexFormats for Vec3 {
+    fn as_vertex_formats() -> &'static [VertexFormat] {
+        &[VertexFormat::Float32x3]
+    }
+}
+
+impl AsVertexFormats for Vec4 {
+    fn as_vertex_formats() -> &'static [VertexFormat] {
+        &[VertexFormat::Float32x4]
+    }
+}
+
+impl AsVertexFormats for Mat4 {
+    fn as_vertex_formats() -> &'static [VertexFormat] {
+        &[
+            VertexFormat::Float32x4,
+            VertexFormat::Float32x4,
+            VertexFormat::Float32x4,
+            VertexFormat::Float32x4,
+        ]
+    }
+}
+
+impl AsVertexFormats for Color {
+    fn as_vertex_formats() -> &'static [VertexFormat] {
+        &[VertexFormat::Float32x4]
+    }
+}
+
+impl AsVertexFormats for [f32; 2] {
+    fn as_vertex_formats() -> &'static [VertexFormat] {
+        &[VertexFormat::Float32x2]
+    }
+}
+
+impl AsVertexFormats for [f32; 3] {
+    fn as_vertex_formats() -> &'static [VertexFormat] {
+        &[VertexFormat::Float32x3]
+    }
+}
+
+impl AsVertexFormats for [f32; 4] {
+    fn as_vertex_formats() -> &'static [VertexFormat] {
+        &[VertexFormat::Float32x4]
+    }
+}
diff --git a/pipelined/bevy_render2/src/render_command/mod.rs b/pipelined/bevy_render2/src/render_command/mod.rs
new file mode 100644
index 0000000000..b40a269ef7
--- /dev/null
+++ b/pipelined/bevy_render2/src/render_command/mod.rs
@@ -0,0 +1,47 @@
+mod render_command_queue;
+pub use render_command_queue::*;
+
+use crate::{
+    render_graph::{Node, RenderGraph, ResourceSlots},
+    renderer::RenderContext,
+    RenderStage,
+};
+use bevy_app::{App, Plugin};
+use bevy_ecs::prelude::*;
+
+#[derive(Default)]
+pub struct RenderCommandPlugin;
+
+impl Plugin for RenderCommandPlugin {
+    fn build(&self, app: &mut App) {
+        app.init_resource::<RenderCommandQueue>();
+        let render_app = app.sub_app_mut(0);
+        render_app.add_system_to_stage(RenderStage::Extract, extract_render_commands.system());
+        let mut graph = render_app.world.get_resource_mut::<RenderGraph>().unwrap();
+        graph.add_node("render_command_queue", RenderCommandQueueNode);
+    }
+}
+
+fn extract_render_commands(
+    mut commands: Commands,
+    mut render_command_queue: ResMut<RenderCommandQueue>,
+) {
+    let mut queue = RenderCommandQueue::default();
+    queue.extend(&mut render_command_queue);
+    commands.insert_resource(queue);
+}
+
+pub struct RenderCommandQueueNode;
+
+impl Node for RenderCommandQueueNode {
+    fn update(
+        &mut self,
+        world: &World,
+        render_context: &mut dyn RenderContext,
+        _input: &ResourceSlots,
+        _output: &mut ResourceSlots,
+    ) {
+        let queue = world.get_resource::<RenderCommandQueue>().unwrap();
+        queue.execute(render_context);
+    }
+}
diff --git a/pipelined/bevy_render2/src/render_command/render_command_queue.rs b/pipelined/bevy_render2/src/render_command/render_command_queue.rs
new file mode 100644
index 0000000000..de2c6f79fa
--- /dev/null
+++ b/pipelined/bevy_render2/src/render_command/render_command_queue.rs
@@ -0,0 +1,227 @@
+use crate::{
+    render_resource::{BufferId, TextureId},
+    renderer::RenderContext,
+    texture::Extent3d,
+};
+
+#[derive(Clone, Debug)]
+pub enum Command {
+    CopyBufferToBuffer {
+        source_buffer: BufferId,
+        source_offset: u64,
+        destination_buffer: BufferId,
+        destination_offset: u64,
+        size: u64,
+    },
+    CopyBufferToTexture {
+        source_buffer: BufferId,
+        source_offset: u64,
+        source_bytes_per_row: u32,
+        destination_texture: TextureId,
+        destination_origin: [u32; 3],
+        destination_mip_level: u32,
+        size: Extent3d,
+    },
+    CopyTextureToTexture {
+        source_texture: TextureId,
+        source_origin: [u32; 3],
+        source_mip_level: u32,
+        destination_texture: TextureId,
+        destination_origin: [u32; 3],
+        destination_mip_level: u32,
+        size: Extent3d,
+    },
+    CopyTextureToBuffer {
+        source_texture: TextureId,
+        source_origin: [u32; 3],
+        source_mip_level: u32,
+        destination_buffer: BufferId,
+        destination_offset: u64,
+        destination_bytes_per_row: u32,
+        size: Extent3d,
+    },
+    // TODO: Frees probably don't need to be queued?
+    FreeBuffer(BufferId),
+}
+
+#[derive(Debug, Default, Clone)]
+pub struct RenderCommandQueue {
+    // TODO: this shouldn't really need a mutex. it just needs to be shared on whatever thread it's
+    // scheduled on
+    queue: Vec<Command>,
+}
+
+impl RenderCommandQueue {
+    fn push(&mut self, command: Command) {
+        self.queue.push(command);
+    }
+
+    pub fn copy_buffer_to_buffer(
+        &mut self,
+        source_buffer: BufferId,
+        source_offset: u64,
+        destination_buffer: BufferId,
+        destination_offset: u64,
+        size: u64,
+    ) {
+        self.push(Command::CopyBufferToBuffer {
+            source_buffer,
+            source_offset,
+            destination_buffer,
+            destination_offset,
+            size,
+        });
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub fn copy_buffer_to_texture(
+        &mut self,
+        source_buffer: BufferId,
+        source_offset: u64,
+        source_bytes_per_row: u32,
+        destination_texture: TextureId,
+        destination_origin: [u32; 3],
+        destination_mip_level: u32,
+        size: Extent3d,
+    ) {
+        self.push(Command::CopyBufferToTexture {
+            source_buffer,
+            source_offset,
+            source_bytes_per_row,
+            destination_texture,
+            destination_origin,
+            destination_mip_level,
+            size,
+        });
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub fn copy_texture_to_buffer(
+        &mut self,
+        source_texture: TextureId,
+        source_origin: [u32; 3],
+        source_mip_level: u32,
+        destination_buffer: BufferId,
+        destination_offset: u64,
+        destination_bytes_per_row: u32,
+        size: Extent3d,
+    ) {
+        self.push(Command::CopyTextureToBuffer {
+            source_texture,
+            source_origin,
+            source_mip_level,
+            destination_buffer,
+            destination_offset,
+            destination_bytes_per_row,
+            size,
+        })
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub fn copy_texture_to_texture(
+        &mut self,
+        source_texture: TextureId,
+        source_origin: [u32; 3],
+        source_mip_level: u32,
+        destination_texture: TextureId,
+        destination_origin: [u32; 3],
+        destination_mip_level: u32,
+        size: Extent3d,
+    ) {
+        self.push(Command::CopyTextureToTexture {
+            source_texture,
+            source_origin,
+            source_mip_level,
+            destination_texture,
+            destination_origin,
+            destination_mip_level,
+            size,
+        })
+    }
+
+    pub fn free_buffer(&mut self, buffer: BufferId) {
+        self.push(Command::FreeBuffer(buffer));
+    }
+
+    pub fn clear(&mut self) {
+        self.queue.clear();
+    }
+
+    pub fn extend(&mut self, other: &mut RenderCommandQueue) {
+        self.queue.extend(other.queue.drain(..));
+    }
+
+    // TODO: Ideally this consumes the queue, but RenderGraph Nodes currently don't have write access to World.
+    // This is currently ok because new queues are created every frame
+    pub fn execute(&self, render_context: &mut dyn RenderContext) {
+        for command in self.queue.iter().cloned() {
+            match command {
+                Command::CopyBufferToBuffer {
+                    source_buffer,
+                    source_offset,
+                    destination_buffer,
+                    destination_offset,
+                    size,
+                } => render_context.copy_buffer_to_buffer(
+                    source_buffer,
+                    source_offset,
+                    destination_buffer,
+                    destination_offset,
+                    size,
+                ),
+                Command::CopyBufferToTexture {
+                    source_buffer,
+                    source_offset,
+                    source_bytes_per_row,
+                    destination_texture,
+                    destination_origin,
+                    destination_mip_level,
+                    size,
+                } => render_context.copy_buffer_to_texture(
+                    source_buffer,
+                    source_offset,
+                    source_bytes_per_row,
+                    destination_texture,
+                    destination_origin,
+                    destination_mip_level,
+                    size,
+                ),
+                Command::CopyTextureToTexture {
+                    source_texture,
+                    source_origin,
+                    source_mip_level,
+                    destination_texture,
+                    destination_origin,
+                    destination_mip_level,
+                    size,
+                } => render_context.copy_texture_to_texture(
+                    source_texture,
+                    source_origin,
+                    source_mip_level,
+                    destination_texture,
+                    destination_origin,
+                    destination_mip_level,
+                    size,
+                ),
+                Command::CopyTextureToBuffer {
+                    source_texture,
+                    source_origin,
+                    source_mip_level,
+                    destination_buffer,
+                    destination_offset,
+                    destination_bytes_per_row,
+                    size,
+                } => render_context.copy_texture_to_buffer(
+                    source_texture,
+                    source_origin,
+                    source_mip_level,
+                    destination_buffer,
+                    destination_offset,
+                    destination_bytes_per_row,
+                    size,
+                ),
+                Command::FreeBuffer(buffer) => render_context.resources().remove_buffer(buffer),
+            }
+        }
+    }
+}
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..e736797598
--- /dev/null
+++ b/pipelined/bevy_render2/src/render_graph/edge.rs
@@ -0,0 +1,31 @@
+use super::NodeId;
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum Edge {
+    SlotEdge {
+        input_node: NodeId,
+        input_index: usize,
+        output_node: NodeId,
+        output_index: usize,
+    },
+    NodeEdge {
+        input_node: NodeId,
+        output_node: NodeId,
+    },
+}
+
+impl Edge {
+    pub fn get_input_node(&self) -> NodeId {
+        match self {
+            Edge::SlotEdge { input_node, .. } => *input_node,
+            Edge::NodeEdge { input_node, .. } => *input_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..a87afa09c1
--- /dev/null
+++ b/pipelined/bevy_render2/src/render_graph/graph.rs
@@ -0,0 +1,442 @@
+use super::{Edge, Node, NodeId, NodeLabel, NodeState, RenderGraphError, SlotLabel};
+use bevy_utils::HashMap;
+use std::{borrow::Cow, fmt::Debug};
+
+#[derive(Default)]
+pub struct RenderGraph {
+    nodes: HashMap<NodeId, NodeState>,
+    node_names: HashMap<Cow<'static, str>, NodeId>,
+}
+
+impl RenderGraph {
+    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
+    }
+
+    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))
+    }
+
+    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))
+    }
+
+    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)),
+        }
+    }
+
+    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())
+    }
+
+    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())
+    }
+
+    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_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)?;
+        let input_index = self
+            .get_node_state(input_node_id)?
+            .input_slots
+            .get_slot_index(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(())
+    }
+
+    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(())
+    }
+
+    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)?;
+                let input_slot = input_node_state.input_slots.get_slot(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.resource_type != input_slot.resource_type {
+                    return Err(RenderGraphError::MismatchedNodeSlots {
+                        output_node,
+                        output_slot: output_index,
+                        input_node,
+                        input_slot: input_index,
+                    });
+                }
+            }
+            Edge::NodeEdge { .. } => { /* nothing to validate here */ }
+        }
+
+        Ok(())
+    }
+
+    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
+    }
+
+    pub fn iter_nodes(&self) -> impl Iterator<Item = &NodeState> {
+        self.nodes.values()
+    }
+
+    pub fn iter_nodes_mut(&mut self) -> impl Iterator<Item = &mut NodeState> {
+        self.nodes.values_mut()
+    }
+
+    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())
+            }))
+    }
+
+    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())))
+    }
+}
+
+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(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{
+        render_graph::{
+            Edge, Node, NodeId, RenderGraph, RenderGraphError, ResourceSlotInfo, ResourceSlots,
+        },
+        render_resource::RenderResourceType,
+        renderer::RenderContext,
+    };
+    use bevy_ecs::world::World;
+    use bevy_utils::HashSet;
+    use std::iter::FromIterator;
+
+    #[derive(Debug)]
+    struct TestNode {
+        inputs: Vec<ResourceSlotInfo>,
+        outputs: Vec<ResourceSlotInfo>,
+    }
+
+    impl TestNode {
+        pub fn new(inputs: usize, outputs: usize) -> Self {
+            TestNode {
+                inputs: (0..inputs)
+                    .map(|i| ResourceSlotInfo {
+                        name: format!("in_{}", i).into(),
+                        resource_type: RenderResourceType::Texture,
+                    })
+                    .collect(),
+                outputs: (0..outputs)
+                    .map(|i| ResourceSlotInfo {
+                        name: format!("out_{}", i).into(),
+                        resource_type: RenderResourceType::Texture,
+                    })
+                    .collect(),
+            }
+        }
+    }
+
+    impl Node for TestNode {
+        fn input(&self) -> &[ResourceSlotInfo] {
+            &self.inputs
+        }
+
+        fn output(&self) -> &[ResourceSlotInfo] {
+            &self.outputs
+        }
+
+        fn update(
+            &mut self,
+            _: &World,
+            _: &mut dyn RenderContext,
+            _: &ResourceSlots,
+            _: &mut ResourceSlots,
+        ) {
+        }
+    }
+
+    #[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 update(
+                &mut self,
+                _: &World,
+                _: &mut dyn RenderContext,
+                _: &ResourceSlots,
+                _: &mut ResourceSlots,
+            ) {
+            }
+        }
+
+        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..70d9f98894
--- /dev/null
+++ b/pipelined/bevy_render2/src/render_graph/mod.rs
@@ -0,0 +1,44 @@
+mod edge;
+mod graph;
+mod node;
+mod node_slot;
+mod schedule;
+mod nodes;
+
+pub use edge::*;
+pub use graph::*;
+pub use node::*;
+pub use node_slot::*;
+pub use schedule::*;
+pub use nodes::*;
+
+use thiserror::Error;
+
+#[derive(Error, Debug, Eq, PartialEq)]
+pub enum RenderGraphError {
+    #[error("node does not exist")]
+    InvalidNode(NodeLabel),
+    #[error("node slot does not exist")]
+    InvalidNodeSlot(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..1d30d2f315
--- /dev/null
+++ b/pipelined/bevy_render2/src/render_graph/node.rs
@@ -0,0 +1,208 @@
+use super::{Edge, RenderGraphError, ResourceSlotInfo, ResourceSlots};
+use crate::renderer::RenderContext;
+use bevy_ecs::world::World;
+use bevy_utils::Uuid;
+use downcast_rs::{impl_downcast, Downcast};
+use std::{borrow::Cow, fmt::Debug};
+
+#[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
+    }
+}
+
+pub trait Node: Downcast + Send + Sync + 'static {
+    fn input(&self) -> &[ResourceSlotInfo] {
+        &[]
+    }
+
+    fn output(&self) -> &[ResourceSlotInfo] {
+        &[]
+    }
+
+    /// Run the graph node logic. This runs once per graph run after [Node::prepare] has been called
+    /// on all nodes.
+    fn update(
+        &mut self,
+        world: &World,
+        render_context: &mut dyn RenderContext,
+        input: &ResourceSlots,
+        output: &mut ResourceSlots,
+    );
+}
+
+impl_downcast!(Node);
+
+#[derive(Debug)]
+pub struct Edges {
+    pub id: NodeId,
+    pub input_edges: Vec<Edge>,
+    pub output_edges: Vec<Edge>,
+}
+
+impl Edges {
+    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(())
+    }
+
+    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(())
+    }
+
+    pub fn has_input_edge(&self, edge: &Edge) -> bool {
+        self.input_edges.contains(edge)
+    }
+
+    pub fn has_output_edge(&self, edge: &Edge) -> bool {
+        self.output_edges.contains(edge)
+    }
+
+    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,
+            })
+    }
+
+    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,
+            })
+    }
+}
+
+pub struct NodeState {
+    pub id: NodeId,
+    pub name: Option<Cow<'static, str>>,
+    pub type_name: &'static str,
+    pub node: Box<dyn Node>,
+    pub input_slots: ResourceSlots,
+    pub output_slots: ResourceSlots,
+    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 {
+    pub fn new<T>(id: NodeId, node: T) -> Self
+    where
+        T: Node,
+    {
+        NodeState {
+            id,
+            name: None,
+            input_slots: ResourceSlots::from(node.input()),
+            output_slots: ResourceSlots::from(node.output()),
+            node: Box::new(node),
+            type_name: std::any::type_name::<T>(),
+            edges: Edges {
+                id,
+                input_edges: Vec::new(),
+                output_edges: Vec::new(),
+            },
+        }
+    }
+
+    pub fn node<T>(&self) -> Result<&T, RenderGraphError>
+    where
+        T: Node,
+    {
+        self.node
+            .downcast_ref::<T>()
+            .ok_or(RenderGraphError::WrongNodeType)
+    }
+
+    pub fn node_mut<T>(&mut self) -> Result<&mut T, RenderGraphError>
+    where
+        T: Node,
+    {
+        self.node
+            .downcast_mut::<T>()
+            .ok_or(RenderGraphError::WrongNodeType)
+    }
+
+    pub fn validate_output_slots(&self) -> Result<(), RenderGraphError> {
+        for i in 0..self.output_slots.len() {
+            self.edges.get_output_slot_edge(i)?;
+        }
+
+        Ok(())
+    }
+
+    pub fn validate_input_slots(&self) -> Result<(), RenderGraphError> {
+        for i in 0..self.input_slots.len() {
+            self.edges.get_input_slot_edge(i)?;
+        }
+
+        Ok(())
+    }
+}
+
+#[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)
+    }
+}
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..6adfed3fcd
--- /dev/null
+++ b/pipelined/bevy_render2/src/render_graph/node_slot.rs
@@ -0,0 +1,143 @@
+use crate::render_resource::{RenderResourceId, RenderResourceType};
+
+use super::RenderGraphError;
+use std::borrow::Cow;
+
+#[derive(Debug, Clone)]
+pub struct ResourceSlot {
+    pub resource: Option<RenderResourceId>,
+    pub name: Cow<'static, str>,
+    pub resource_type: RenderResourceType,
+}
+
+#[derive(Default, Debug, Clone)]
+pub struct ResourceSlots {
+    slots: Vec<ResourceSlot>,
+}
+
+#[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<usize> for SlotLabel {
+    fn from(value: usize) -> Self {
+        SlotLabel::Index(value)
+    }
+}
+
+impl ResourceSlots {
+    pub fn set(&mut self, label: impl Into<SlotLabel>, resource: RenderResourceId) {
+        let mut slot = self.get_slot_mut(label).unwrap();
+        slot.resource = Some(resource);
+    }
+
+    pub fn get(&self, label: impl Into<SlotLabel>) -> Option<RenderResourceId> {
+        let slot = self.get_slot(label).unwrap();
+        slot.resource.clone()
+    }
+
+    pub fn get_slot(&self, label: impl Into<SlotLabel>) -> Result<&ResourceSlot, RenderGraphError> {
+        let label = label.into();
+        let index = self.get_slot_index(&label)?;
+        self.slots
+            .get(index)
+            .ok_or(RenderGraphError::InvalidNodeSlot(label))
+    }
+
+    pub fn get_slot_mut(
+        &mut self,
+        label: impl Into<SlotLabel>,
+    ) -> Result<&mut ResourceSlot, RenderGraphError> {
+        let label = label.into();
+        let index = self.get_slot_index(&label)?;
+        self.slots
+            .get_mut(index)
+            .ok_or(RenderGraphError::InvalidNodeSlot(label))
+    }
+
+    pub fn get_slot_index(&self, label: impl Into<SlotLabel>) -> Result<usize, RenderGraphError> {
+        let label = label.into();
+        match label {
+            SlotLabel::Index(index) => Ok(index),
+            SlotLabel::Name(ref name) => self
+                .slots
+                .iter()
+                .enumerate()
+                .find(|(_i, s)| s.name == *name)
+                .map(|(i, _s)| i)
+                .ok_or(RenderGraphError::InvalidNodeSlot(label)),
+        }
+    }
+
+    pub fn iter(&self) -> impl Iterator<Item = &ResourceSlot> {
+        self.slots.iter()
+    }
+
+    pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut ResourceSlot> {
+        self.slots.iter_mut()
+    }
+
+    pub fn len(&self) -> usize {
+        self.slots.len()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.slots.is_empty()
+    }
+}
+
+impl From<&ResourceSlotInfo> for ResourceSlot {
+    fn from(slot: &ResourceSlotInfo) -> Self {
+        ResourceSlot {
+            resource: None,
+            name: slot.name.clone(),
+            resource_type: slot.resource_type.clone(),
+        }
+    }
+}
+
+impl From<&[ResourceSlotInfo]> for ResourceSlots {
+    fn from(slots: &[ResourceSlotInfo]) -> Self {
+        ResourceSlots {
+            slots: slots
+                .iter()
+                .map(|s| s.into())
+                .collect::<Vec<ResourceSlot>>(),
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct ResourceSlotInfo {
+    pub name: Cow<'static, str>,
+    pub resource_type: RenderResourceType,
+}
+
+impl ResourceSlotInfo {
+    pub fn new(name: impl Into<Cow<'static, str>>, resource_type: RenderResourceType) -> Self {
+        ResourceSlotInfo {
+            name: name.into(),
+            resource_type,
+        }
+    }
+}
diff --git a/pipelined/bevy_render2/src/render_graph/nodes/mod.rs b/pipelined/bevy_render2/src/render_graph/nodes/mod.rs
new file mode 100644
index 0000000000..7702669d7e
--- /dev/null
+++ b/pipelined/bevy_render2/src/render_graph/nodes/mod.rs
@@ -0,0 +1,3 @@
+mod window_swap_chain_node;
+
+pub use window_swap_chain_node::*;
\ No newline at end of file
diff --git a/pipelined/bevy_render2/src/render_graph/nodes/window_swap_chain_node.rs b/pipelined/bevy_render2/src/render_graph/nodes/window_swap_chain_node.rs
new file mode 100644
index 0000000000..a09f942586
--- /dev/null
+++ b/pipelined/bevy_render2/src/render_graph/nodes/window_swap_chain_node.rs
@@ -0,0 +1,99 @@
+use crate::{
+    render_graph::{Node, ResourceSlotInfo, ResourceSlots},
+    render_resource::{RenderResourceId, RenderResourceType, SwapChainDescriptor},
+    renderer::RenderContext,
+};
+use bevy_ecs::world::World;
+use bevy_utils::HashMap;
+use bevy_window::WindowId;
+use raw_window_handle::{HasRawWindowHandle, RawWindowHandle};
+use std::borrow::Cow;
+use std::ops::{Deref, DerefMut};
+
+pub struct ExtractedWindow {
+    pub id: WindowId,
+    pub handle: RawWindowHandleWrapper,
+    pub physical_width: u32,
+    pub physical_height: u32,
+    pub vsync: 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
+    }
+}
+
+pub struct RawWindowHandleWrapper(pub RawWindowHandle);
+
+// TODO: THIS IS NOT SAFE ... ONLY FOR PROTOTYPING
+unsafe impl Send for RawWindowHandleWrapper {}
+unsafe impl Sync for RawWindowHandleWrapper {}
+
+// TODO: safe?
+unsafe impl HasRawWindowHandle for RawWindowHandleWrapper {
+    fn raw_window_handle(&self) -> RawWindowHandle {
+        self.0.clone()
+    }
+}
+
+pub struct WindowSwapChainNode {
+    window_id: WindowId,
+}
+
+impl WindowSwapChainNode {
+    pub const OUT_TEXTURE: &'static str = "texture";
+
+    pub fn new(window_id: WindowId) -> Self {
+        WindowSwapChainNode { window_id }
+    }
+}
+
+impl Node for WindowSwapChainNode {
+    fn output(&self) -> &[ResourceSlotInfo] {
+        static OUTPUT: &[ResourceSlotInfo] = &[ResourceSlotInfo {
+            name: Cow::Borrowed(WindowSwapChainNode::OUT_TEXTURE),
+            resource_type: RenderResourceType::Texture,
+        }];
+        OUTPUT
+    }
+
+    fn update(
+        &mut self,
+        world: &World,
+        render_context: &mut dyn RenderContext,
+        _input: &ResourceSlots,
+        output: &mut ResourceSlots,
+    ) {
+        let windows = world.get_resource::<ExtractedWindows>().unwrap();
+        let window = windows
+            .get(&self.window_id)
+            .expect("Window swapchain node refers to a non-existent window.");
+
+        let render_resource_context = render_context.resources_mut();
+        let swap_chain_descriptor = SwapChainDescriptor {
+            window_id: window.id,
+            format: crate::texture::TextureFormat::Bgra8UnormSrgb,
+            width: window.physical_width,
+            height: window.physical_height,
+            vsync: window.vsync,
+        };
+
+        let swap_chain_texture =
+            render_resource_context.next_swap_chain_texture(&swap_chain_descriptor);
+        output.set(0, RenderResourceId::Texture(swap_chain_texture));
+    }
+}
diff --git a/pipelined/bevy_render2/src/render_graph/schedule.rs b/pipelined/bevy_render2/src/render_graph/schedule.rs
new file mode 100644
index 0000000000..cab6a7bed4
--- /dev/null
+++ b/pipelined/bevy_render2/src/render_graph/schedule.rs
@@ -0,0 +1,552 @@
+use super::{NodeId, NodeState, RenderGraph, RenderGraphError};
+use bevy_utils::HashMap;
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum StagerError {
+    // This might have to be `:` tagged at the end.
+    #[error("encountered a `RenderGraphError`")]
+    RenderGraphError(#[from] RenderGraphError),
+}
+
+#[derive(Default, Debug, Eq, PartialEq)]
+pub struct Stage {
+    pub jobs: Vec<OrderedJob>,
+}
+
+#[derive(Default, Debug, Eq, PartialEq)]
+pub struct OrderedJob {
+    pub nodes: Vec<NodeId>,
+}
+
+#[derive(Default, Debug)]
+pub struct StageBorrow<'a> {
+    pub jobs: Vec<OrderedJobBorrow<'a>>,
+}
+
+#[derive(Default, Debug)]
+pub struct OrderedJobBorrow<'a> {
+    pub node_states: Vec<&'a mut NodeState>,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
+struct NodeIndices {
+    stage: usize,
+    job: usize,
+    node: usize,
+}
+
+#[derive(Default, Debug)]
+pub struct Stages {
+    stages: Vec<Stage>,
+    /// a collection of node indices that are used to efficiently borrow render graph nodes
+    node_indices: HashMap<NodeId, NodeIndices>,
+}
+
+impl Stages {
+    pub fn new(stages: Vec<Stage>) -> Self {
+        let mut node_indices = HashMap::default();
+        for (stage_index, stage) in stages.iter().enumerate() {
+            for (job_index, job) in stage.jobs.iter().enumerate() {
+                for (node_index, node) in job.nodes.iter().enumerate() {
+                    node_indices.insert(
+                        *node,
+                        NodeIndices {
+                            stage: stage_index,
+                            job: job_index,
+                            node: node_index,
+                        },
+                    );
+                }
+            }
+        }
+        Stages {
+            stages,
+            node_indices,
+        }
+    }
+
+    pub fn borrow<'a>(&self, render_graph: &'a mut RenderGraph) -> Vec<StageBorrow<'a>> {
+        // unfortunately borrowing render graph nodes in a specific order takes a little bit of
+        // gymnastics
+        let mut stage_borrows = Vec::with_capacity(self.stages.len());
+
+        let mut node_borrows = Vec::new();
+        for node in render_graph.iter_nodes_mut() {
+            let indices = self.node_indices.get(&node.id).unwrap();
+            node_borrows.push((node, indices));
+        }
+
+        node_borrows.sort_by_key(|(_node, indices)| <&NodeIndices>::clone(indices));
+        let mut last_stage = usize::MAX;
+        let mut last_job = usize::MAX;
+        for (node, indices) in node_borrows.drain(..) {
+            if last_stage != indices.stage {
+                stage_borrows.push(StageBorrow::default());
+                last_job = usize::MAX;
+            }
+
+            let stage = &mut stage_borrows[indices.stage];
+            if last_job != indices.job {
+                stage.jobs.push(OrderedJobBorrow::default());
+            }
+
+            let job = &mut stage.jobs[indices.job];
+            job.node_states.push(node);
+
+            last_stage = indices.stage;
+            last_job = indices.job;
+        }
+
+        stage_borrows
+    }
+}
+
+/// Produces a collection of `Stages`, which are sets of OrderedJobs that must be run before moving
+/// on to the next stage
+pub trait RenderGraphStager {
+    fn get_stages(&mut self, render_graph: &RenderGraph) -> Result<Stages, RenderGraphError>;
+}
+
+// TODO: remove this
+/// This scheduler ignores dependencies and puts everything in one stage. It shouldn't be used for
+/// anything :)
+#[derive(Debug, Default)]
+pub struct LinearStager;
+
+impl RenderGraphStager for LinearStager {
+    fn get_stages(&mut self, render_graph: &RenderGraph) -> Result<Stages, RenderGraphError> {
+        let mut stage = Stage::default();
+        let mut job = OrderedJob::default();
+        for node in render_graph.iter_nodes() {
+            job.nodes.push(node.id);
+        }
+
+        stage.jobs.push(job);
+
+        Ok(Stages::new(vec![stage]))
+    }
+}
+
+#[derive(Debug, Copy, Clone)]
+/// Determines the grouping strategy used when constructing graph stages
+pub enum JobGrouping {
+    /// Default to adding the current node to a new job in its assigned stage. This results
+    /// in a "loose" pack that is easier to parallelize but has more jobs
+    Loose,
+    /// Default to adding the current node into the first job in its assigned stage. This results
+    /// in a "tight" pack that is harder to parallelize but results in fewer jobs
+    Tight,
+}
+
+#[derive(Debug)]
+/// Produces Render Graph stages and jobs in a way that ensures node dependencies are respected.
+pub struct DependentNodeStager {
+    job_grouping: JobGrouping,
+}
+
+impl DependentNodeStager {
+    pub fn loose_grouping() -> Self {
+        DependentNodeStager {
+            job_grouping: JobGrouping::Loose,
+        }
+    }
+
+    pub fn tight_grouping() -> Self {
+        DependentNodeStager {
+            job_grouping: JobGrouping::Tight,
+        }
+    }
+}
+
+impl RenderGraphStager for DependentNodeStager {
+    fn get_stages<'a>(&mut self, render_graph: &RenderGraph) -> Result<Stages, RenderGraphError> {
+        // get all nodes without input. this intentionally includes nodes with no outputs
+        let output_only_nodes = render_graph
+            .iter_nodes()
+            .filter(|node| node.input_slots.is_empty());
+        let mut stages = vec![Stage::default()];
+        let mut node_stages = HashMap::default();
+        for output_only_node in output_only_nodes {
+            // each "output only" node should start a new job on the first stage
+            stage_node(
+                render_graph,
+                &mut stages,
+                &mut node_stages,
+                output_only_node,
+                self.job_grouping,
+            );
+        }
+
+        Ok(Stages::new(stages))
+    }
+}
+
+fn stage_node(
+    graph: &RenderGraph,
+    stages: &mut Vec<Stage>,
+    node_stages_and_jobs: &mut HashMap<NodeId, (usize, usize)>,
+    node: &NodeState,
+    job_grouping: JobGrouping,
+) {
+    // don't re-visit nodes or visit them before all of their parents have been visited
+    if node_stages_and_jobs.contains_key(&node.id)
+        || node
+            .edges
+            .input_edges
+            .iter()
+            .any(|e| !node_stages_and_jobs.contains_key(&e.get_output_node()))
+    {
+        return;
+    }
+
+    // by default assume we are creating a new job on a new stage
+    let mut stage_index = 0;
+    let mut job_index = match job_grouping {
+        JobGrouping::Tight => Some(0),
+        JobGrouping::Loose => None,
+    };
+
+    // check to see if the current node has a parent. if so, grab the parent with the highest stage
+    if let Some((max_parent_stage, max_parent_job)) = node
+        .edges
+        .input_edges
+        .iter()
+        .map(|e| {
+            node_stages_and_jobs
+                .get(&e.get_output_node())
+                .expect("Already checked that parents were visited.")
+        })
+        .max()
+    {
+        // count the number of parents that are in the highest stage
+        let max_stage_parent_count = node
+            .edges
+            .input_edges
+            .iter()
+            .filter(|e| {
+                let (max_stage, _) = node_stages_and_jobs
+                    .get(&e.get_output_node())
+                    .expect("Already checked that parents were visited.");
+                max_stage == max_parent_stage
+            })
+            .count();
+
+        // if the current node has more than one parent on the highest stage (aka requires
+        // synchronization), then move it to the next stage and start a new job on that
+        // stage
+        if max_stage_parent_count > 1 {
+            stage_index = max_parent_stage + 1;
+        } else {
+            stage_index = *max_parent_stage;
+            job_index = Some(*max_parent_job);
+        }
+    }
+
+    if stage_index == stages.len() {
+        stages.push(Stage::default());
+    }
+
+    let stage = &mut stages[stage_index];
+
+    let job_index = job_index.unwrap_or_else(|| stage.jobs.len());
+    if job_index == stage.jobs.len() {
+        stage.jobs.push(OrderedJob::default());
+    }
+
+    let job = &mut stage.jobs[job_index];
+    job.nodes.push(node.id);
+
+    node_stages_and_jobs.insert(node.id, (stage_index, job_index));
+
+    for (_edge, node) in graph.iter_node_outputs(node.id).unwrap() {
+        stage_node(graph, stages, node_stages_and_jobs, node, job_grouping);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::renderer::RenderContext;
+    use crate::{
+        render_graph::{
+            DependentNodeStager, Node, NodeId, OrderedJob, RenderGraph, RenderGraphStager,
+            ResourceSlotInfo, ResourceSlots, Stage,
+        },
+        render_resource::RenderResourceType,
+    };
+    use bevy_ecs::world::World;
+
+    struct TestNode {
+        inputs: Vec<ResourceSlotInfo>,
+        outputs: Vec<ResourceSlotInfo>,
+    }
+
+    impl TestNode {
+        pub fn new(inputs: usize, outputs: usize) -> Self {
+            TestNode {
+                inputs: (0..inputs)
+                    .map(|i| ResourceSlotInfo {
+                        name: format!("in_{}", i).into(),
+                        resource_type: RenderResourceType::Texture,
+                    })
+                    .collect(),
+                outputs: (0..outputs)
+                    .map(|i| ResourceSlotInfo {
+                        name: format!("out_{}", i).into(),
+                        resource_type: RenderResourceType::Texture,
+                    })
+                    .collect(),
+            }
+        }
+    }
+
+    impl Node for TestNode {
+        fn input(&self) -> &[ResourceSlotInfo] {
+            &self.inputs
+        }
+
+        fn output(&self) -> &[ResourceSlotInfo] {
+            &self.outputs
+        }
+
+        fn update(
+            &mut self,
+            _: &World,
+            _: &mut dyn RenderContext,
+            _: &ResourceSlots,
+            _: &mut ResourceSlots,
+        ) {
+        }
+    }
+
+    #[test]
+    fn test_render_graph_dependency_stager_loose() {
+        let mut graph = RenderGraph::default();
+
+        // Setup graph to look like this:
+        //
+        // A -> B -> C -> D
+        //    /     /
+        //  E      F -> G
+        //
+        // H -> I -> J
+
+        let a_id = graph.add_node("A", TestNode::new(0, 1));
+        let b_id = graph.add_node("B", TestNode::new(2, 1));
+        let c_id = graph.add_node("C", TestNode::new(2, 1));
+        let d_id = graph.add_node("D", TestNode::new(1, 0));
+        let e_id = graph.add_node("E", TestNode::new(0, 1));
+        let f_id = graph.add_node("F", TestNode::new(0, 2));
+        let g_id = graph.add_node("G", TestNode::new(1, 0));
+        let h_id = graph.add_node("H", TestNode::new(0, 1));
+        let i_id = graph.add_node("I", TestNode::new(1, 1));
+        let j_id = graph.add_node("J", TestNode::new(1, 0));
+
+        graph.add_node_edge("A", "B").unwrap();
+        graph.add_node_edge("B", "C").unwrap();
+        graph.add_node_edge("C", "D").unwrap();
+        graph.add_node_edge("E", "B").unwrap();
+        graph.add_node_edge("F", "C").unwrap();
+        graph.add_node_edge("F", "G").unwrap();
+        graph.add_node_edge("H", "I").unwrap();
+        graph.add_node_edge("I", "J").unwrap();
+
+        let mut stager = DependentNodeStager::loose_grouping();
+        let mut stages = stager.get_stages(&graph).unwrap();
+
+        // Expected Stages:
+        // (X indicates nodes that are not part of that stage)
+
+        // Stage 1
+        // A -> X -> X -> X
+        //    /     /
+        //  E      F -> G
+        //
+        // H -> I -> J
+
+        // Stage 2
+        // X -> B -> C -> D
+        //    /     /
+        //  X      X -> X
+        //
+        // X -> X -> X
+
+        let mut expected_stages = vec![
+            Stage {
+                jobs: vec![
+                    OrderedJob {
+                        nodes: vec![f_id, g_id],
+                    },
+                    OrderedJob { nodes: vec![a_id] },
+                    OrderedJob { nodes: vec![e_id] },
+                    OrderedJob {
+                        nodes: vec![h_id, i_id, j_id],
+                    },
+                ],
+            },
+            Stage {
+                jobs: vec![OrderedJob {
+                    nodes: vec![b_id, c_id, d_id],
+                }],
+            },
+        ];
+
+        // ensure job order lines up within stages (this can vary due to hash maps)
+        // jobs within a stage are unordered conceptually so this is ok
+        expected_stages
+            .iter_mut()
+            .for_each(|stage| stage.jobs.sort_by_key(|job| job.nodes[0]));
+
+        stages
+            .stages
+            .iter_mut()
+            .for_each(|stage| stage.jobs.sort_by_key(|job| job.nodes[0]));
+
+        assert_eq!(
+            stages.stages, expected_stages,
+            "stages should be loosely grouped"
+        );
+
+        let mut borrowed = stages.borrow(&mut graph);
+        // ensure job order lines up within stages (this can vary due to hash maps)
+        // jobs within a stage are unordered conceptually so this is ok
+        borrowed
+            .iter_mut()
+            .for_each(|stage| stage.jobs.sort_by_key(|job| job.node_states[0].id));
+
+        assert_eq!(
+            borrowed.len(),
+            expected_stages.len(),
+            "same number of stages"
+        );
+        for (stage_index, borrowed_stage) in borrowed.iter().enumerate() {
+            assert_eq!(
+                borrowed_stage.jobs.len(),
+                stages.stages[stage_index].jobs.len(),
+                "job length matches"
+            );
+            for (job_index, borrowed_job) in borrowed_stage.jobs.iter().enumerate() {
+                assert_eq!(
+                    borrowed_job.node_states.len(),
+                    stages.stages[stage_index].jobs[job_index].nodes.len(),
+                    "node length matches"
+                );
+                for (node_index, borrowed_node) in borrowed_job.node_states.iter().enumerate() {
+                    assert_eq!(
+                        borrowed_node.id,
+                        stages.stages[stage_index].jobs[job_index].nodes[node_index]
+                    );
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn test_render_graph_dependency_stager_tight() {
+        let mut graph = RenderGraph::default();
+
+        // Setup graph to look like this:
+        //
+        // A -> B -> C -> D
+        //    /     /
+        //  E      F -> G
+        //
+        // H -> I -> J
+
+        let _a_id = graph.add_node("A", TestNode::new(0, 1));
+        let b_id = graph.add_node("B", TestNode::new(2, 1));
+        let c_id = graph.add_node("C", TestNode::new(2, 1));
+        let d_id = graph.add_node("D", TestNode::new(1, 0));
+        let _e_id = graph.add_node("E", TestNode::new(0, 1));
+        let f_id = graph.add_node("F", TestNode::new(0, 2));
+        let g_id = graph.add_node("G", TestNode::new(1, 0));
+        let h_id = graph.add_node("H", TestNode::new(0, 1));
+        let i_id = graph.add_node("I", TestNode::new(1, 1));
+        let j_id = graph.add_node("J", TestNode::new(1, 0));
+
+        graph.add_node_edge("A", "B").unwrap();
+        graph.add_node_edge("B", "C").unwrap();
+        graph.add_node_edge("C", "D").unwrap();
+        graph.add_node_edge("E", "B").unwrap();
+        graph.add_node_edge("F", "C").unwrap();
+        graph.add_node_edge("F", "G").unwrap();
+        graph.add_node_edge("H", "I").unwrap();
+        graph.add_node_edge("I", "J").unwrap();
+
+        let mut stager = DependentNodeStager::tight_grouping();
+        let mut stages = stager.get_stages(&graph).unwrap();
+
+        // Expected Stages:
+        // (X indicates nodes that are not part of that stage)
+
+        // Stage 1
+        // A -> X -> X -> X
+        //    /     /
+        //  E      F -> G
+        //
+        // H -> I -> J
+
+        // Stage 2
+        // X -> B -> C -> D
+        //    /     /
+        //  X      X -> X
+        //
+        // X -> X -> X
+
+        assert_eq!(stages.stages[0].jobs.len(), 1, "expect exactly 1 job");
+
+        let job = &stages.stages[0].jobs[0];
+
+        assert_eq!(job.nodes.len(), 7, "expect exactly 7 nodes in the job");
+
+        // its hard to test the exact order of this job's nodes because of hashing, so instead we'll
+        // test the constraints that must hold true
+        let index =
+            |node_id: NodeId| -> usize { job.nodes.iter().position(|id| *id == node_id).unwrap() };
+
+        assert!(index(f_id) < index(g_id));
+        assert!(index(h_id) < index(i_id));
+        assert!(index(i_id) < index(j_id));
+
+        let expected_stage_1 = Stage {
+            jobs: vec![OrderedJob {
+                nodes: vec![b_id, c_id, d_id],
+            }],
+        };
+
+        assert_eq!(stages.stages[1], expected_stage_1,);
+
+        let mut borrowed = stages.borrow(&mut graph);
+        // ensure job order lines up within stages (this can vary due to hash maps)
+        // jobs within a stage are unordered conceptually so this is ok
+        stages
+            .stages
+            .iter_mut()
+            .for_each(|stage| stage.jobs.sort_by_key(|job| job.nodes[0]));
+        borrowed
+            .iter_mut()
+            .for_each(|stage| stage.jobs.sort_by_key(|job| job.node_states[0].id));
+
+        assert_eq!(borrowed.len(), 2, "same number of stages");
+        for (stage_index, borrowed_stage) in borrowed.iter().enumerate() {
+            assert_eq!(
+                borrowed_stage.jobs.len(),
+                stages.stages[stage_index].jobs.len(),
+                "job length matches"
+            );
+            for (job_index, borrowed_job) in borrowed_stage.jobs.iter().enumerate() {
+                assert_eq!(
+                    borrowed_job.node_states.len(),
+                    stages.stages[stage_index].jobs[job_index].nodes.len(),
+                    "node length matches"
+                );
+                for (node_index, borrowed_node) in borrowed_job.node_states.iter().enumerate() {
+                    assert_eq!(
+                        borrowed_node.id,
+                        stages.stages[stage_index].jobs[job_index].nodes[node_index]
+                    );
+                }
+            }
+        }
+    }
+}
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..34c3460a23
--- /dev/null
+++ b/pipelined/bevy_render2/src/render_resource/bind_group.rs
@@ -0,0 +1,127 @@
+use crate::render_resource::RenderResourceId;
+
+use super::{BufferId, RenderResourceBinding, SamplerId, TextureId};
+use bevy_utils::AHasher;
+use std::{
+    hash::{Hash, Hasher},
+    ops::Range,
+    sync::Arc,
+};
+
+#[derive(Hash, Eq, PartialEq, Debug, Copy, Clone)]
+pub struct BindGroupId(pub u64);
+
+#[derive(Eq, PartialEq, Debug)]
+pub struct IndexedBindGroupEntry {
+    pub index: u32,
+    pub entry: RenderResourceBinding,
+}
+
+#[derive(Clone, Eq, PartialEq, Debug)]
+pub struct BindGroup {
+    pub id: BindGroupId,
+    pub indexed_bindings: Arc<[IndexedBindGroupEntry]>,
+    pub dynamic_uniform_indices: Option<Arc<[u32]>>,
+}
+
+impl BindGroup {
+    pub fn build() -> BindGroupBuilder {
+        BindGroupBuilder::default()
+    }
+}
+
+#[derive(Debug, Default)]
+pub struct BindGroupBuilder {
+    pub indexed_bindings: Vec<IndexedBindGroupEntry>,
+    pub dynamic_uniform_indices: Vec<u32>,
+    pub hasher: AHasher,
+}
+
+impl BindGroupBuilder {
+    pub fn add_binding<T: Into<RenderResourceBinding>>(mut self, index: u32, binding: T) -> Self {
+        let binding = binding.into();
+        if let RenderResourceBinding::Buffer {
+            dynamic_index: Some(dynamic_index),
+            ..
+        } = binding
+        {
+            self.dynamic_uniform_indices.push(dynamic_index);
+        }
+
+        self.hash_binding(&binding);
+        self.indexed_bindings.push(IndexedBindGroupEntry {
+            index,
+            entry: binding,
+        });
+        self
+    }
+
+    pub fn add_texture(self, index: u32, texture: TextureId) -> Self {
+        self.add_binding(index, RenderResourceBinding::Texture(texture))
+    }
+
+    pub fn add_sampler(self, index: u32, sampler: SamplerId) -> Self {
+        self.add_binding(index, RenderResourceBinding::Sampler(sampler))
+    }
+
+    pub fn add_buffer(self, index: u32, buffer: BufferId, range: Range<u64>) -> Self {
+        self.add_binding(
+            index,
+            RenderResourceBinding::Buffer {
+                buffer,
+                range,
+                dynamic_index: None,
+            },
+        )
+    }
+
+    pub fn add_dynamic_buffer(
+        self,
+        index: u32,
+        buffer: BufferId,
+        range: Range<u64>,
+        dynamic_index: u32,
+    ) -> Self {
+        self.add_binding(
+            index,
+            RenderResourceBinding::Buffer {
+                buffer,
+                range,
+                dynamic_index: Some(dynamic_index),
+            },
+        )
+    }
+
+    pub fn finish(mut self) -> BindGroup {
+        // this sort ensures that RenderResourceSets are insertion-order independent
+        self.indexed_bindings.sort_by_key(|i| i.index);
+        BindGroup {
+            id: BindGroupId(self.hasher.finish()),
+            indexed_bindings: self.indexed_bindings.into(),
+            dynamic_uniform_indices: if self.dynamic_uniform_indices.is_empty() {
+                None
+            } else {
+                Some(self.dynamic_uniform_indices.into())
+            },
+        }
+    }
+
+    fn hash_binding(&mut self, binding: &RenderResourceBinding) {
+        match binding {
+            RenderResourceBinding::Buffer {
+                buffer,
+                range,
+                dynamic_index: _, // dynamic_index is not a part of the binding
+            } => {
+                RenderResourceId::Buffer(*buffer).hash(&mut self.hasher);
+                range.hash(&mut self.hasher);
+            }
+            RenderResourceBinding::Texture(texture) => {
+                RenderResourceId::Texture(*texture).hash(&mut self.hasher);
+            }
+            RenderResourceBinding::Sampler(sampler) => {
+                RenderResourceId::Sampler(*sampler).hash(&mut self.hasher);
+            }
+        }
+    }
+}
\ No newline at end of file
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..00252ffa9e
--- /dev/null
+++ b/pipelined/bevy_render2/src/render_resource/buffer.rs
@@ -0,0 +1,51 @@
+use bevy_utils::Uuid;
+
+#[derive(Copy, Clone, Hash, Eq, PartialEq, Debug)]
+pub struct BufferId(Uuid);
+
+impl BufferId {
+    #[allow(clippy::new_without_default)]
+    pub fn new() -> Self {
+        BufferId(Uuid::new_v4())
+    }
+}
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct BufferInfo {
+    pub size: usize,
+    pub buffer_usage: BufferUsage,
+    pub mapped_at_creation: bool,
+}
+
+impl Default for BufferInfo {
+    fn default() -> Self {
+        BufferInfo {
+            size: 0,
+            buffer_usage: BufferUsage::empty(),
+            mapped_at_creation: false,
+        }
+    }
+}
+
+bitflags::bitflags! {
+    #[repr(transparent)]
+    #[cfg_attr(feature = "trace", derive(Serialize))]
+    #[cfg_attr(feature = "replay", derive(Deserialize))]
+    pub struct BufferUsage: u32 {
+        const MAP_READ = 1;
+        const MAP_WRITE = 2;
+        const COPY_SRC = 4;
+        const COPY_DST = 8;
+        const INDEX = 16;
+        const VERTEX = 32;
+        const UNIFORM = 64;
+        const STORAGE = 128;
+        const INDIRECT = 256;
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum BufferMapMode {
+    Read,
+    Write,
+}
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..083cefc395
--- /dev/null
+++ b/pipelined/bevy_render2/src/render_resource/buffer_vec.rs
@@ -0,0 +1,124 @@
+use crate::{
+    render_resource::{BufferId, BufferInfo, BufferMapMode, BufferUsage},
+    renderer::{RenderContext, RenderResources},
+};
+use bevy_core::{Pod, cast_slice};
+
+pub struct BufferVec<T: Pod> {
+    values: Vec<T>,
+    staging_buffer: Option<BufferId>,
+    buffer: Option<BufferId>,
+    capacity: usize,
+    item_size: usize,
+    buffer_usage: BufferUsage,
+}
+
+impl<T: Pod> Default for BufferVec<T> {
+    fn default() -> Self {
+        Self {
+            values: Vec::new(),
+            staging_buffer: None,
+            buffer: None,
+            capacity: 0,
+            buffer_usage: BufferUsage::all(),
+            item_size: std::mem::size_of::<T>(),
+        }
+    }
+}
+
+impl<T: Pod> BufferVec<T> {
+    pub fn new(buffer_usage: BufferUsage) -> Self {
+        Self {
+            buffer_usage,
+            ..Default::default()
+        }
+    }
+    #[inline]
+    pub fn staging_buffer(&self) -> Option<BufferId> {
+        self.staging_buffer
+    }
+
+    #[inline]
+    pub fn buffer(&self) -> Option<BufferId> {
+        self.buffer
+    }
+
+    #[inline]
+    pub fn capacity(&self) -> usize {
+        self.capacity
+    }
+
+    pub fn push(&mut self, value: T) -> usize {
+        if self.values.len() < self.capacity {
+            let index = self.values.len();
+            self.values.push(value);
+            index
+        } else {
+            panic!(
+                "Cannot push value because capacity of {} has been reached",
+                self.capacity
+            );
+        }
+    }
+
+    pub fn reserve(&mut self, capacity: usize, render_resources: &RenderResources) {
+        if capacity > self.capacity {
+            self.capacity = capacity;
+            if let Some(staging_buffer) = self.staging_buffer.take() {
+                render_resources.remove_buffer(staging_buffer);
+            }
+
+            if let Some(buffer) = self.buffer.take() {
+                render_resources.remove_buffer(buffer);
+            }
+
+            let size = self.item_size * capacity;
+            self.staging_buffer = Some(render_resources.create_buffer(BufferInfo {
+                size,
+                buffer_usage: BufferUsage::COPY_SRC | BufferUsage::MAP_WRITE,
+                mapped_at_creation: false,
+            }));
+            self.buffer = Some(render_resources.create_buffer(BufferInfo {
+                size,
+                buffer_usage: BufferUsage::COPY_DST | self.buffer_usage,
+                mapped_at_creation: false,
+            }));
+        }
+    }
+
+    pub fn reserve_and_clear(&mut self, capacity: usize, render_resources: &RenderResources) {
+        self.clear();
+        self.reserve(capacity, render_resources);
+    }
+
+    pub fn write_to_staging_buffer(&self, render_resources: &RenderResources) {
+        if let Some(staging_buffer) = self.staging_buffer {
+            let size = self.values.len() * self.item_size;
+            render_resources.map_buffer(staging_buffer, BufferMapMode::Write);
+            render_resources.write_mapped_buffer(
+                staging_buffer,
+                0..size as u64,
+                &mut |data, _renderer| {
+                    let bytes: &[u8] = cast_slice(&self.values);
+                    data.copy_from_slice(bytes);
+                },
+            );
+            render_resources.unmap_buffer(staging_buffer);
+        }
+    }
+    pub fn write_to_uniform_buffer(&self, render_context: &mut dyn RenderContext) {
+        if let (Some(staging_buffer), Some(uniform_buffer)) = (self.staging_buffer, self.buffer) {
+            render_context.copy_buffer_to_buffer(
+                staging_buffer,
+                0,
+                uniform_buffer,
+                0,
+                (self.values.len() * self.item_size) as u64,
+            );
+        }
+    }
+
+    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..451347654d
--- /dev/null
+++ b/pipelined/bevy_render2/src/render_resource/mod.rs
@@ -0,0 +1,17 @@
+mod bind_group;
+mod buffer;
+mod buffer_vec;
+mod render_resource_bindings;
+mod render_resource_id;
+mod swap_chain;
+mod texture;
+mod uniform_vec;
+
+pub use bind_group::*;
+pub use buffer::*;
+pub use buffer_vec::*;
+pub use render_resource_bindings::*;
+pub use render_resource_id::*;
+pub use swap_chain::*;
+pub use texture::*;
+pub use uniform_vec::*;
diff --git a/pipelined/bevy_render2/src/render_resource/render_resource_bindings.rs b/pipelined/bevy_render2/src/render_resource/render_resource_bindings.rs
new file mode 100644
index 0000000000..b2cb2083b1
--- /dev/null
+++ b/pipelined/bevy_render2/src/render_resource/render_resource_bindings.rs
@@ -0,0 +1,61 @@
+use super::{BufferId, SamplerId, TextureId};
+use std::ops::Range;
+
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub enum RenderResourceBinding {
+    Buffer {
+        buffer: BufferId,
+        range: Range<u64>,
+        dynamic_index: Option<u32>,
+    },
+    Texture(TextureId),
+    Sampler(SamplerId),
+}
+
+impl RenderResourceBinding {
+    pub fn get_texture(&self) -> Option<TextureId> {
+        if let RenderResourceBinding::Texture(texture) = self {
+            Some(*texture)
+        } else {
+            None
+        }
+    }
+
+    pub fn get_buffer(&self) -> Option<BufferId> {
+        if let RenderResourceBinding::Buffer { buffer, .. } = self {
+            Some(*buffer)
+        } else {
+            None
+        }
+    }
+
+    pub fn is_dynamic_buffer(&self) -> bool {
+        matches!(
+            self,
+            RenderResourceBinding::Buffer {
+                dynamic_index: Some(_),
+                ..
+            }
+        )
+    }
+
+    pub fn get_sampler(&self) -> Option<SamplerId> {
+        if let RenderResourceBinding::Sampler(sampler) = self {
+            Some(*sampler)
+        } else {
+            None
+        }
+    }
+}
+
+impl From<TextureId> for RenderResourceBinding {
+    fn from(id: TextureId) -> Self {
+        RenderResourceBinding::Texture(id)
+    }
+}
+
+impl From<SamplerId> for RenderResourceBinding {
+    fn from(id: SamplerId) -> Self {
+        RenderResourceBinding::Sampler(id)
+    }
+}
diff --git a/pipelined/bevy_render2/src/render_resource/render_resource_id.rs b/pipelined/bevy_render2/src/render_resource/render_resource_id.rs
new file mode 100644
index 0000000000..5110490031
--- /dev/null
+++ b/pipelined/bevy_render2/src/render_resource/render_resource_id.rs
@@ -0,0 +1,41 @@
+use crate::render_resource::{BufferId, SamplerId, TextureId};
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub enum RenderResourceType {
+    Buffer,
+    Texture,
+    Sampler,
+}
+
+#[derive(Debug, Clone, Hash, Eq, PartialEq)]
+pub enum RenderResourceId {
+    Buffer(BufferId),
+    Texture(TextureId),
+    Sampler(SamplerId),
+}
+
+impl RenderResourceId {
+    pub fn get_texture(&self) -> Option<TextureId> {
+        if let RenderResourceId::Texture(id) = self {
+            Some(*id)
+        } else {
+            None
+        }
+    }
+
+    pub fn get_buffer(&self) -> Option<BufferId> {
+        if let RenderResourceId::Buffer(id) = self {
+            Some(*id)
+        } else {
+            None
+        }
+    }
+
+    pub fn get_sampler(&self) -> Option<SamplerId> {
+        if let RenderResourceId::Sampler(id) = self {
+            Some(*id)
+        } else {
+            None
+        }
+    }
+}
\ No newline at end of file
diff --git a/pipelined/bevy_render2/src/render_resource/swap_chain.rs b/pipelined/bevy_render2/src/render_resource/swap_chain.rs
new file mode 100644
index 0000000000..140b97c3ac
--- /dev/null
+++ b/pipelined/bevy_render2/src/render_resource/swap_chain.rs
@@ -0,0 +1,16 @@
+use bevy_window::WindowId;
+
+use crate::texture::TextureFormat;
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct SwapChainDescriptor {
+    pub window_id: WindowId,
+    /// The texture format of the swap chain. The only formats that are guaranteed are
+    /// `Bgra8Unorm` and `Bgra8UnormSrgb`
+    pub format: TextureFormat,
+    /// Width of the swap chain. Must be the same size as the surface.
+    pub width: u32,
+    /// Height of the swap chain. Must be the same size as the surface.
+    pub height: u32,
+    pub vsync: bool,
+}
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..46e7e51753
--- /dev/null
+++ b/pipelined/bevy_render2/src/render_resource/texture.rs
@@ -0,0 +1,21 @@
+use bevy_utils::Uuid;
+
+#[derive(Copy, Clone, Hash, Eq, PartialEq, Debug)]
+pub struct TextureId(Uuid);
+
+impl TextureId {
+    #[allow(clippy::new_without_default)]
+    pub fn new() -> Self {
+        TextureId(Uuid::new_v4())
+    }
+}
+
+#[derive(Copy, Clone, Hash, Eq, PartialEq, Debug)]
+pub struct SamplerId(Uuid);
+
+impl SamplerId {
+    #[allow(clippy::new_without_default)]
+    pub fn new() -> Self {
+        SamplerId(Uuid::new_v4())
+    }
+}
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..8cb71f4ec7
--- /dev/null
+++ b/pipelined/bevy_render2/src/render_resource/uniform_vec.rs
@@ -0,0 +1,183 @@
+use crate::{
+    render_resource::{BufferId, BufferInfo, BufferMapMode, BufferUsage, RenderResourceBinding},
+    renderer::{RenderContext, RenderResources},
+};
+use crevice::std140::{self, AsStd140, DynamicUniform, Std140};
+
+pub struct UniformVec<T: AsStd140> {
+    values: Vec<T>,
+    staging_buffer: Option<BufferId>,
+    uniform_buffer: Option<BufferId>,
+    capacity: usize,
+    item_size: usize,
+}
+
+impl<T: AsStd140> Default for UniformVec<T> {
+    fn default() -> Self {
+        Self {
+            values: Vec::new(),
+            staging_buffer: None,
+            uniform_buffer: None,
+            capacity: 0,
+            item_size: (T::std140_size_static() + <T as AsStd140>::Std140Type::ALIGNMENT - 1)
+                & !(<T as AsStd140>::Std140Type::ALIGNMENT - 1),
+        }
+    }
+}
+
+impl<T: AsStd140> UniformVec<T> {
+    #[inline]
+    pub fn staging_buffer(&self) -> Option<BufferId> {
+        self.staging_buffer
+    }
+
+    #[inline]
+    pub fn uniform_buffer(&self) -> Option<BufferId> {
+        self.uniform_buffer
+    }
+
+    #[inline]
+    pub fn capacity(&self) -> usize {
+        self.capacity
+    }
+
+    pub fn push(&mut self, value: T) -> RenderResourceBinding {
+        if self.values.len() < self.capacity {
+            let binding = RenderResourceBinding::Buffer {
+                buffer: self.uniform_buffer.unwrap(),
+                dynamic_index: Some((self.values.len() * self.item_size) as u32),
+                range: 0..self.item_size as u64,
+            };
+            self.values.push(value);
+            binding
+        } else {
+            panic!(
+                "Cannot push value because capacity of {} has been reached",
+                self.capacity
+            );
+        }
+    }
+
+    pub fn reserve(&mut self, capacity: usize, render_resources: &RenderResources) {
+        if capacity > self.capacity {
+            self.capacity = capacity;
+            if let Some(staging_buffer) = self.staging_buffer.take() {
+                render_resources.remove_buffer(staging_buffer);
+            }
+
+            if let Some(uniform_buffer) = self.uniform_buffer.take() {
+                render_resources.remove_buffer(uniform_buffer);
+            }
+
+            let size = self.item_size * capacity;
+            self.staging_buffer = Some(render_resources.create_buffer(BufferInfo {
+                size,
+                buffer_usage: BufferUsage::COPY_SRC | BufferUsage::MAP_WRITE,
+                mapped_at_creation: false,
+            }));
+            self.uniform_buffer = Some(render_resources.create_buffer(BufferInfo {
+                size,
+                buffer_usage: BufferUsage::COPY_DST | BufferUsage::UNIFORM,
+                mapped_at_creation: false,
+            }));
+        }
+    }
+
+    pub fn reserve_and_clear(&mut self, capacity: usize, render_resources: &RenderResources) {
+        self.clear();
+        self.reserve(capacity, render_resources);
+    }
+
+    pub fn write_to_staging_buffer(&self, render_resources: &RenderResources) {
+        if let Some(staging_buffer) = self.staging_buffer {
+            let size = self.values.len() * self.item_size;
+            render_resources.map_buffer(staging_buffer, BufferMapMode::Write);
+            render_resources.write_mapped_buffer(
+                staging_buffer,
+                0..size as u64,
+                &mut |data, _renderer| {
+                    let mut writer = std140::Writer::new(data);
+                    writer.write(self.values.as_slice()).unwrap();
+                },
+            );
+            render_resources.unmap_buffer(staging_buffer);
+        }
+    }
+    pub fn write_to_uniform_buffer(&self, render_context: &mut dyn RenderContext) {
+        if let (Some(staging_buffer), Some(uniform_buffer)) =
+            (self.staging_buffer, self.uniform_buffer)
+        {
+            render_context.copy_buffer_to_buffer(
+                staging_buffer,
+                0,
+                uniform_buffer,
+                0,
+                (self.values.len() * self.item_size) as u64,
+            );
+        }
+    }
+
+    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 staging_buffer(&self) -> Option<BufferId> {
+        self.uniform_vec.staging_buffer()
+    }
+
+    #[inline]
+    pub fn uniform_buffer(&self) -> Option<BufferId> {
+        self.uniform_vec.uniform_buffer()
+    }
+
+    #[inline]
+    pub fn capacity(&self) -> usize {
+        self.uniform_vec.capacity()
+    }
+
+    #[inline]
+    pub fn push(&mut self, value: T) -> RenderResourceBinding {
+        self.uniform_vec.push(DynamicUniform(value))
+    }
+
+    #[inline]
+    pub fn reserve(&mut self, capacity: usize, render_resources: &RenderResources) {
+        self.uniform_vec.reserve(capacity, render_resources);
+    }
+
+    #[inline]
+    pub fn reserve_and_clear(&mut self, capacity: usize, render_resources: &RenderResources) {
+        self.uniform_vec
+            .reserve_and_clear(capacity, render_resources);
+    }
+
+    #[inline]
+    pub fn write_to_staging_buffer(&self, render_resources: &RenderResources) {
+        self.uniform_vec.write_to_staging_buffer(render_resources);
+    }
+
+    #[inline]
+    pub fn write_to_uniform_buffer(&self, render_context: &mut dyn RenderContext) {
+        self.uniform_vec.write_to_uniform_buffer(render_context);
+    }
+
+    #[inline]
+    pub fn clear(&mut self) {
+        self.uniform_vec.clear();
+    }
+}
diff --git a/pipelined/bevy_render2/src/renderer/headless_render_resource_context.rs b/pipelined/bevy_render2/src/renderer/headless_render_resource_context.rs
new file mode 100644
index 0000000000..6974682b3c
--- /dev/null
+++ b/pipelined/bevy_render2/src/renderer/headless_render_resource_context.rs
@@ -0,0 +1,137 @@
+use super::RenderResourceContext;
+use crate::{
+    pipeline::{BindGroupDescriptorId, PipelineDescriptor, PipelineId},
+    render_resource::{
+        BindGroup, BufferId, BufferInfo, BufferMapMode, SamplerId, SwapChainDescriptor, TextureId,
+    },
+    shader::{Shader, ShaderId},
+    texture::{SamplerDescriptor, TextureDescriptor},
+};
+use bevy_utils::HashMap;
+use bevy_window::Window;
+use parking_lot::RwLock;
+use std::{ops::Range, sync::Arc};
+
+#[derive(Debug, Default)]
+pub struct HeadlessRenderResourceContext {
+    buffer_info: Arc<RwLock<HashMap<BufferId, BufferInfo>>>,
+    texture_descriptors: Arc<RwLock<HashMap<TextureId, TextureDescriptor>>>,
+}
+
+impl HeadlessRenderResourceContext {
+    pub fn add_buffer_info(&self, buffer: BufferId, info: BufferInfo) {
+        self.buffer_info.write().insert(buffer, info);
+    }
+
+    pub fn add_texture_descriptor(&self, texture: TextureId, descriptor: TextureDescriptor) {
+        self.texture_descriptors.write().insert(texture, descriptor);
+    }
+}
+
+impl RenderResourceContext for HeadlessRenderResourceContext {
+    fn create_swap_chain(&self, _window: &Window) {}
+
+    fn drop_swap_chain_texture(&self, _render_resource: TextureId) {}
+
+    fn drop_all_swap_chain_textures(&self) {}
+
+    fn create_sampler(&self, _sampler_descriptor: &SamplerDescriptor) -> SamplerId {
+        SamplerId::new()
+    }
+
+    fn create_texture(&self, texture_descriptor: TextureDescriptor) -> TextureId {
+        let texture = TextureId::new();
+        self.add_texture_descriptor(texture, texture_descriptor);
+        texture
+    }
+
+    fn create_buffer(&self, buffer_info: BufferInfo) -> BufferId {
+        let buffer = BufferId::new();
+        self.add_buffer_info(buffer, buffer_info);
+        buffer
+    }
+
+    fn write_mapped_buffer(
+        &self,
+        id: BufferId,
+        _range: Range<u64>,
+        write: &mut dyn FnMut(&mut [u8], &dyn RenderResourceContext),
+    ) {
+        let size = self.buffer_info.read().get(&id).unwrap().size;
+        let mut buffer = vec![0; size];
+        write(&mut buffer, self);
+    }
+
+    fn read_mapped_buffer(
+        &self,
+        id: BufferId,
+        _range: Range<u64>,
+        read: &dyn Fn(&[u8], &dyn RenderResourceContext),
+    ) {
+        let size = self.buffer_info.read().get(&id).unwrap().size;
+        let buffer = vec![0; size];
+        read(&buffer, self);
+    }
+
+    fn map_buffer(&self, _id: BufferId, _mode: BufferMapMode) {}
+
+    fn unmap_buffer(&self, _id: BufferId) {}
+
+    fn create_buffer_with_data(&self, buffer_info: BufferInfo, _data: &[u8]) -> BufferId {
+        let buffer = BufferId::new();
+        self.add_buffer_info(buffer, buffer_info);
+        buffer
+    }
+
+    fn create_shader_module(&self, _shader: &Shader) -> ShaderId {
+        ShaderId::new()
+    }
+
+    fn remove_buffer(&self, buffer: BufferId) {
+        self.buffer_info.write().remove(&buffer);
+    }
+
+    fn remove_texture(&self, texture: TextureId) {
+        self.texture_descriptors.write().remove(&texture);
+    }
+
+    fn remove_sampler(&self, _sampler: SamplerId) {}
+
+    fn create_render_pipeline(&self, _pipeline_descriptor: &PipelineDescriptor) -> PipelineId {
+        PipelineId::new()
+    }
+
+    fn create_bind_group(
+        &self,
+        _bind_group_descriptor_id: BindGroupDescriptorId,
+        _bind_group: &BindGroup,
+    ) {
+    }
+
+    fn clear_bind_groups(&self) {}
+
+    fn get_buffer_info(&self, buffer: BufferId) -> Option<BufferInfo> {
+        self.buffer_info.read().get(&buffer).cloned()
+    }
+
+    fn bind_group_descriptor_exists(
+        &self,
+        _bind_group_descriptor_id: BindGroupDescriptorId,
+    ) -> bool {
+        false
+    }
+
+    fn get_aligned_uniform_size(&self, size: usize, _dynamic: bool) -> usize {
+        size
+    }
+
+    fn get_aligned_texture_size(&self, size: usize) -> usize {
+        size
+    }
+
+    fn remove_stale_bind_groups(&self) {}
+
+    fn next_swap_chain_texture(&self, _descriptor: &SwapChainDescriptor) -> TextureId {
+        TextureId::new()
+    }
+}
diff --git a/pipelined/bevy_render2/src/renderer/mod.rs b/pipelined/bevy_render2/src/renderer/mod.rs
new file mode 100644
index 0000000000..945f4d8e6a
--- /dev/null
+++ b/pipelined/bevy_render2/src/renderer/mod.rs
@@ -0,0 +1,7 @@
+mod headless_render_resource_context;
+mod render_context;
+mod render_resource_context;
+
+pub use headless_render_resource_context::*;
+pub use render_context::*;
+pub use render_resource_context::*;
diff --git a/pipelined/bevy_render2/src/renderer/render_context.rs b/pipelined/bevy_render2/src/renderer/render_context.rs
new file mode 100644
index 0000000000..dcddc61cc6
--- /dev/null
+++ b/pipelined/bevy_render2/src/renderer/render_context.rs
@@ -0,0 +1,57 @@
+use super::RenderResourceContext;
+use crate::{
+    pass::{PassDescriptor, RenderPass},
+    render_resource::{BufferId, TextureId},
+    texture::Extent3d,
+};
+
+pub trait RenderContext {
+    fn resources(&self) -> &dyn RenderResourceContext;
+    fn resources_mut(&mut self) -> &mut dyn RenderResourceContext;
+    fn copy_buffer_to_buffer(
+        &mut self,
+        source_buffer: BufferId,
+        source_offset: u64,
+        destination_buffer: BufferId,
+        destination_offset: u64,
+        size: u64,
+    );
+    #[allow(clippy::too_many_arguments)]
+    fn copy_buffer_to_texture(
+        &mut self,
+        source_buffer: BufferId,
+        source_offset: u64,
+        source_bytes_per_row: u32,
+        destination_texture: TextureId,
+        destination_origin: [u32; 3],
+        destination_mip_level: u32,
+        size: Extent3d,
+    );
+    #[allow(clippy::too_many_arguments)]
+    fn copy_texture_to_buffer(
+        &mut self,
+        source_texture: TextureId,
+        source_origin: [u32; 3],
+        source_mip_level: u32,
+        destination_buffer: BufferId,
+        destination_offset: u64,
+        destination_bytes_per_row: u32,
+        size: Extent3d,
+    );
+    #[allow(clippy::too_many_arguments)]
+    fn copy_texture_to_texture(
+        &mut self,
+        source_texture: TextureId,
+        source_origin: [u32; 3],
+        source_mip_level: u32,
+        destination_texture: TextureId,
+        destination_origin: [u32; 3],
+        destination_mip_level: u32,
+        size: Extent3d,
+    );
+    fn begin_pass(
+        &mut self,
+        pass_descriptor: &PassDescriptor,
+        run_pass: &mut dyn FnMut(&mut dyn RenderPass),
+    );
+}
diff --git a/pipelined/bevy_render2/src/renderer/render_resource_context.rs b/pipelined/bevy_render2/src/renderer/render_resource_context.rs
new file mode 100644
index 0000000000..ce74d852e2
--- /dev/null
+++ b/pipelined/bevy_render2/src/renderer/render_resource_context.rs
@@ -0,0 +1,79 @@
+use crate::{
+    pipeline::{BindGroupDescriptorId, PipelineDescriptor, PipelineId},
+    render_resource::{
+        BindGroup, BufferId, BufferInfo, BufferMapMode, SamplerId, SwapChainDescriptor, TextureId,
+    },
+    shader::{Shader, ShaderId},
+    texture::{SamplerDescriptor, TextureDescriptor},
+};
+use bevy_window::Window;
+use downcast_rs::{impl_downcast, Downcast};
+use std::ops::{Deref, DerefMut, Range};
+
+pub struct RenderResources(Box<dyn RenderResourceContext>);
+
+impl RenderResources {
+    pub fn new(context: Box<dyn RenderResourceContext>) -> Self {
+        Self(context)
+    }
+}
+
+impl Deref for RenderResources {
+    type Target = dyn RenderResourceContext;
+
+    fn deref(&self) -> &Self::Target {
+        &*self.0
+    }
+}
+
+impl DerefMut for RenderResources {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut *self.0
+    }
+}
+
+pub trait RenderResourceContext: Downcast + Send + Sync + 'static {
+    // TODO: remove me
+    fn create_swap_chain(&self, window: &Window);
+    fn next_swap_chain_texture(&self, descriptor: &SwapChainDescriptor) -> TextureId;
+    fn drop_swap_chain_texture(&self, resource: TextureId);
+    fn drop_all_swap_chain_textures(&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;
+    // TODO: remove RenderResourceContext here
+    fn write_mapped_buffer(
+        &self,
+        id: BufferId,
+        range: Range<u64>,
+        write: &mut dyn FnMut(&mut [u8], &dyn RenderResourceContext),
+    );
+    fn read_mapped_buffer(
+        &self,
+        id: BufferId,
+        range: Range<u64>,
+        read: &dyn Fn(&[u8], &dyn RenderResourceContext),
+    );
+    fn map_buffer(&self, id: BufferId, mode: BufferMapMode);
+    fn unmap_buffer(&self, id: BufferId);
+    fn create_buffer_with_data(&self, buffer_info: BufferInfo, data: &[u8]) -> BufferId;
+    fn create_shader_module(&self, shader: &Shader) -> ShaderId;
+    fn remove_buffer(&self, buffer: BufferId);
+    fn remove_texture(&self, texture: TextureId);
+    fn remove_sampler(&self, sampler: SamplerId);
+    fn get_buffer_info(&self, buffer: BufferId) -> Option<BufferInfo>;
+    fn get_aligned_uniform_size(&self, size: usize, dynamic: bool) -> usize;
+    fn get_aligned_texture_size(&self, data_size: usize) -> usize;
+    fn create_render_pipeline(&self, pipeline_descriptor: &PipelineDescriptor) -> PipelineId;
+    fn bind_group_descriptor_exists(&self, bind_group_descriptor_id: BindGroupDescriptorId)
+        -> bool;
+    fn create_bind_group(
+        &self,
+        bind_group_descriptor_id: BindGroupDescriptorId,
+        bind_group: &BindGroup,
+    );
+    fn clear_bind_groups(&self);
+    fn remove_stale_bind_groups(&self);
+}
+
+impl_downcast!(RenderResourceContext);
diff --git a/pipelined/bevy_render2/src/shader/mod.rs b/pipelined/bevy_render2/src/shader/mod.rs
new file mode 100644
index 0000000000..5c6b3f4b67
--- /dev/null
+++ b/pipelined/bevy_render2/src/shader/mod.rs
@@ -0,0 +1,24 @@
+#[allow(clippy::module_inception)]
+mod shader;
+
+#[cfg(not(target_arch = "wasm32"))]
+mod shader_reflect;
+
+pub use shader::*;
+
+#[cfg(not(target_arch = "wasm32"))]
+pub use shader_reflect::*;
+
+use crate::pipeline::{BindGroupDescriptor, VertexBufferLayout};
+
+/// Defines the memory layout of a shader
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ShaderLayout {
+    pub bind_groups: Vec<BindGroupDescriptor>,
+    pub vertex_buffer_layout: Vec<VertexBufferLayout>,
+    pub entry_point: String,
+}
+
+pub const GL_VERTEX_INDEX: &str = "gl_VertexIndex";
+pub const GL_INSTANCE_INDEX: &str = "gl_InstanceIndex";
+pub const GL_FRONT_FACING: &str = "gl_FrontFacing";
diff --git a/pipelined/bevy_render2/src/shader/shader.rs b/pipelined/bevy_render2/src/shader/shader.rs
new file mode 100644
index 0000000000..e9a4fd841b
--- /dev/null
+++ b/pipelined/bevy_render2/src/shader/shader.rs
@@ -0,0 +1,286 @@
+use super::ShaderLayout;
+use bevy_asset::{AssetLoader, LoadContext, LoadedAsset};
+use bevy_reflect::{TypeUuid, Uuid};
+use bevy_utils::{tracing::error, BoxedFuture};
+use std::marker::Copy;
+use thiserror::Error;
+
+/// The stage of a shader
+#[derive(Hash, Eq, PartialEq, Copy, Clone, Debug)]
+pub enum ShaderStage {
+    Vertex,
+    Fragment,
+    Compute,
+}
+
+/// An error that occurs during shader handling.
+#[derive(Error, Debug)]
+pub enum ShaderError {
+    /// Shader compilation error.
+    #[error("Shader compilation error:\n{0}")]
+    Compilation(String),
+
+    #[cfg(not(any(
+        target_arch = "wasm32",
+        all(target_arch = "x86_64", target_os = "linux", target_env = "gnu"),
+        all(target_arch = "x86_64", target_os = "macos"),
+        all(target_arch = "aarch64", target_os = "android"),
+        all(target_arch = "armv7", target_os = "androidabi"),
+        all(target_arch = "x86_64", target_os = "windows", target_env = "msvc"),
+    )))]
+    /// shaderc error.
+    #[error("shaderc error: {0}")]
+    ShaderC(#[from] shaderc::Error),
+
+    #[cfg(not(any(
+        target_arch = "wasm32",
+        all(target_arch = "x86_64", target_os = "linux", target_env = "gnu"),
+        all(target_arch = "x86_64", target_os = "macos"),
+        all(target_arch = "aarch64", target_os = "android"),
+        all(target_arch = "armv7", target_os = "androidabi"),
+        all(target_arch = "x86_64", target_os = "windows", target_env = "msvc"),
+    )))]
+    #[error("Error initializing shaderc Compiler")]
+    ErrorInitializingShadercCompiler,
+
+    #[cfg(not(any(
+        target_arch = "wasm32",
+        all(target_arch = "x86_64", target_os = "linux", target_env = "gnu"),
+        all(target_arch = "x86_64", target_os = "macos"),
+        all(target_arch = "aarch64", target_os = "android"),
+        all(target_arch = "armv7", target_os = "androidabi"),
+        all(target_arch = "x86_64", target_os = "windows", target_env = "msvc"),
+    )))]
+    #[error("Error initializing shaderc CompileOptions")]
+    ErrorInitializingShadercCompileOptions,
+}
+
+#[cfg(any(
+    all(target_arch = "x86_64", target_os = "linux", target_env = "gnu"),
+    all(target_arch = "x86_64", target_os = "macos"),
+    all(target_arch = "aarch64", target_os = "android"),
+    all(target_arch = "armv7", target_os = "androidabi"),
+    all(target_arch = "x86_64", target_os = "windows", target_env = "msvc"),
+))]
+impl From<ShaderStage> for bevy_glsl_to_spirv::ShaderType {
+    fn from(s: ShaderStage) -> bevy_glsl_to_spirv::ShaderType {
+        match s {
+            ShaderStage::Vertex => bevy_glsl_to_spirv::ShaderType::Vertex,
+            ShaderStage::Fragment => bevy_glsl_to_spirv::ShaderType::Fragment,
+            ShaderStage::Compute => bevy_glsl_to_spirv::ShaderType::Compute,
+        }
+    }
+}
+
+#[cfg(any(
+    all(target_arch = "x86_64", target_os = "linux", target_env = "gnu"),
+    all(target_arch = "x86_64", target_os = "macos"),
+    all(target_arch = "aarch64", target_os = "android"),
+    all(target_arch = "armv7", target_os = "androidabi"),
+    all(target_arch = "x86_64", target_os = "windows", target_env = "msvc"),
+))]
+pub fn glsl_to_spirv(
+    glsl_source: &str,
+    stage: ShaderStage,
+    shader_defs: Option<&[String]>,
+) -> Result<Vec<u32>, ShaderError> {
+    bevy_glsl_to_spirv::compile(glsl_source, stage.into(), shader_defs)
+        .map_err(ShaderError::Compilation)
+}
+
+#[cfg(not(any(
+    target_arch = "wasm32",
+    all(target_arch = "x86_64", target_os = "linux", target_env = "gnu"),
+    all(target_arch = "x86_64", target_os = "macos"),
+    all(target_arch = "aarch64", target_os = "android"),
+    all(target_arch = "armv7", target_os = "androidabi"),
+    all(target_arch = "x86_64", target_os = "windows", target_env = "msvc"),
+)))]
+impl Into<shaderc::ShaderKind> for ShaderStage {
+    fn into(self) -> shaderc::ShaderKind {
+        match self {
+            ShaderStage::Vertex => shaderc::ShaderKind::Vertex,
+            ShaderStage::Fragment => shaderc::ShaderKind::Fragment,
+            ShaderStage::Compute => shaderc::ShaderKind::Compute,
+        }
+    }
+}
+
+#[cfg(not(any(
+    target_arch = "wasm32",
+    all(target_arch = "x86_64", target_os = "linux", target_env = "gnu"),
+    all(target_arch = "x86_64", target_os = "macos"),
+    all(target_arch = "aarch64", target_os = "android"),
+    all(target_arch = "armv7", target_os = "androidabi"),
+    all(target_arch = "x86_64", target_os = "windows", target_env = "msvc"),
+)))]
+pub fn glsl_to_spirv(
+    glsl_source: &str,
+    stage: ShaderStage,
+    shader_defs: Option<&[String]>,
+) -> Result<Vec<u32>, ShaderError> {
+    let mut compiler =
+        shaderc::Compiler::new().ok_or(ShaderError::ErrorInitializingShadercCompiler)?;
+    let mut options = shaderc::CompileOptions::new()
+        .ok_or(ShaderError::ErrorInitializingShadercCompileOptions)?;
+    if let Some(shader_defs) = shader_defs {
+        for def in shader_defs.iter() {
+            options.add_macro_definition(def, None);
+        }
+    }
+
+    let binary_result = compiler.compile_into_spirv(
+        glsl_source,
+        stage.into(),
+        "shader.glsl",
+        "main",
+        Some(&options),
+    )?;
+
+    Ok(binary_result.as_binary().to_vec())
+}
+
+fn bytes_to_words(bytes: &[u8]) -> Vec<u32> {
+    let mut words = Vec::new();
+    for bytes4 in bytes.chunks(4) {
+        words.push(u32::from_le_bytes([
+            bytes4[0], bytes4[1], bytes4[2], bytes4[3],
+        ]));
+    }
+
+    words
+}
+
+/// The full "source" of a shader
+#[derive(Clone, Debug, Hash, Eq, PartialEq)]
+pub enum ShaderSource {
+    Spirv(Vec<u32>),
+    Glsl(String),
+}
+
+impl ShaderSource {
+    pub fn spirv_from_bytes(bytes: &[u8]) -> ShaderSource {
+        ShaderSource::Spirv(bytes_to_words(bytes))
+    }
+}
+
+#[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())
+    }
+}
+
+/// A shader, as defined by its [ShaderSource] and [ShaderStage]
+#[derive(Clone, Debug, TypeUuid)]
+#[uuid = "d95bc916-6c55-4de3-9622-37e7b6969fda"]
+pub struct Shader {
+    pub source: ShaderSource,
+    pub stage: ShaderStage,
+}
+
+impl Shader {
+    pub fn new(stage: ShaderStage, source: ShaderSource) -> Shader {
+        Shader { source, stage }
+    }
+
+    #[cfg(not(target_arch = "wasm32"))]
+    pub fn from_spirv(spirv: &[u8]) -> Result<Shader, ShaderError> {
+        use spirv_reflect::{types::ReflectShaderStageFlags, ShaderModule};
+
+        let module = ShaderModule::load_u8_data(spirv)
+            .map_err(|msg| ShaderError::Compilation(msg.to_string()))?;
+        let stage = match module.get_shader_stage() {
+            ReflectShaderStageFlags::VERTEX => ShaderStage::Vertex,
+            ReflectShaderStageFlags::FRAGMENT => ShaderStage::Fragment,
+            other => panic!("cannot load {:?} shader", other),
+        };
+
+        Ok(Shader {
+            source: ShaderSource::spirv_from_bytes(spirv),
+            stage,
+        })
+    }
+
+    pub fn from_glsl(stage: ShaderStage, glsl: &str) -> Shader {
+        Shader {
+            source: ShaderSource::Glsl(glsl.to_string()),
+            stage,
+        }
+    }
+
+    #[cfg(not(target_arch = "wasm32"))]
+    pub fn get_spirv(&self, macros: Option<&[String]>) -> Result<Vec<u32>, ShaderError> {
+        match self.source {
+            ShaderSource::Spirv(ref bytes) => Ok(bytes.clone()),
+            ShaderSource::Glsl(ref source) => glsl_to_spirv(&source, self.stage, macros),
+        }
+    }
+
+    #[cfg(not(target_arch = "wasm32"))]
+    pub fn get_spirv_shader(&self, macros: Option<&[String]>) -> Result<Shader, ShaderError> {
+        Ok(Shader {
+            source: ShaderSource::Spirv(self.get_spirv(macros)?),
+            stage: self.stage,
+        })
+    }
+
+    #[cfg(not(target_arch = "wasm32"))]
+    pub fn reflect_layout(&self, enforce_bevy_conventions: bool) -> Option<ShaderLayout> {
+        if let ShaderSource::Spirv(ref spirv) = self.source {
+            Some(ShaderLayout::from_spirv(
+                spirv.as_slice(),
+                enforce_bevy_conventions,
+            ))
+        } else {
+            panic!("Cannot reflect layout of non-SpirV shader. Try compiling this shader to SpirV first using self.get_spirv_shader().");
+        }
+    }
+
+    #[cfg(target_arch = "wasm32")]
+    pub fn reflect_layout(&self, _enforce_bevy_conventions: bool) -> Option<ShaderLayout> {
+        panic!("Cannot reflect layout on wasm32.");
+    }
+}
+
+/// All stages in a shader program
+#[derive(Clone, Debug, Eq, PartialEq, Hash)]
+pub struct ShaderStages {
+    pub vertex: ShaderId,
+    pub fragment: Option<ShaderId>,
+}
+
+#[derive(Default)]
+pub struct ShaderLoader;
+
+impl AssetLoader for ShaderLoader {
+    fn load<'a>(
+        &'a self,
+        bytes: &'a [u8],
+        load_context: &'a mut LoadContext,
+    ) -> BoxedFuture<'a, Result<(), anyhow::Error>> {
+        Box::pin(async move {
+            let ext = load_context.path().extension().unwrap().to_str().unwrap();
+
+            let shader = match ext {
+                "vert" => Shader::from_glsl(ShaderStage::Vertex, std::str::from_utf8(bytes)?),
+                "frag" => Shader::from_glsl(ShaderStage::Fragment, std::str::from_utf8(bytes)?),
+                #[cfg(not(target_arch = "wasm32"))]
+                "spv" => Shader::from_spirv(bytes)?,
+                #[cfg(target_arch = "wasm32")]
+                "spv" => panic!("cannot load .spv file on wasm"),
+                _ => panic!("unhandled extension: {}", ext),
+            };
+
+            load_context.set_default_asset(LoadedAsset::new(shader));
+            Ok(())
+        })
+    }
+
+    fn extensions(&self) -> &[&str] {
+        &["vert", "frag", "spv"]
+    }
+}
diff --git a/pipelined/bevy_render2/src/shader/shader_reflect.rs b/pipelined/bevy_render2/src/shader/shader_reflect.rs
new file mode 100644
index 0000000000..9952970e8f
--- /dev/null
+++ b/pipelined/bevy_render2/src/shader/shader_reflect.rs
@@ -0,0 +1,404 @@
+use crate::{
+    pipeline::{
+        BindGroupDescriptor, BindType, BindingDescriptor, BindingShaderStage, InputStepMode,
+        UniformProperty, VertexAttribute, VertexBufferLayout, VertexFormat,
+    },
+    shader::{ShaderLayout, GL_FRONT_FACING, GL_INSTANCE_INDEX, GL_VERTEX_INDEX},
+    texture::{TextureSampleType, TextureViewDimension},
+};
+use bevy_core::cast_slice;
+use spirv_reflect::{
+    types::{
+        ReflectDescriptorBinding, ReflectDescriptorSet, ReflectDescriptorType, ReflectDimension,
+        ReflectShaderStageFlags, ReflectTypeDescription, ReflectTypeFlags,
+    },
+    ShaderModule,
+};
+
+impl ShaderLayout {
+    pub fn from_spirv(spirv_data: &[u32], bevy_conventions: bool) -> ShaderLayout {
+        match ShaderModule::load_u8_data(cast_slice(spirv_data)) {
+            Ok(ref mut module) => {
+                // init
+                let entry_point_name = module.get_entry_point_name();
+                let shader_stage = module.get_shader_stage();
+                let mut bind_groups = Vec::new();
+                for descriptor_set in module.enumerate_descriptor_sets(None).unwrap() {
+                    let bind_group = reflect_bind_group(&descriptor_set, shader_stage);
+                    bind_groups.push(bind_group);
+                }
+
+                // obtain attribute descriptors from reflection
+                let mut vertex_attributes = Vec::new();
+                for input_variable in module.enumerate_input_variables(None).unwrap() {
+                    if input_variable.name == GL_VERTEX_INDEX
+                        || input_variable.name == GL_INSTANCE_INDEX
+                        || input_variable.name == GL_FRONT_FACING
+                    {
+                        continue;
+                    }
+                    // reflect vertex attribute descriptor and record it
+                    vertex_attributes.push(VertexAttribute {
+                        name: input_variable.name.clone().into(),
+                        format: reflect_vertex_format(
+                            input_variable.type_description.as_ref().unwrap(),
+                        ),
+                        offset: 0,
+                        shader_location: input_variable.location,
+                    });
+                }
+
+                vertex_attributes.sort_by(|a, b| a.shader_location.cmp(&b.shader_location));
+
+                let mut vertex_buffer_layout = Vec::new();
+                for vertex_attribute in vertex_attributes.drain(..) {
+                    let mut instance = false;
+                    // obtain buffer name and instancing flag
+                    let current_buffer_name = {
+                        if bevy_conventions {
+                            if vertex_attribute.name == GL_VERTEX_INDEX {
+                                GL_VERTEX_INDEX.to_string()
+                            } else {
+                                instance = vertex_attribute.name.starts_with("I_");
+                                vertex_attribute.name.to_string()
+                            }
+                        } else {
+                            "DefaultVertex".to_string()
+                        }
+                    };
+
+                    // create a new buffer descriptor, per attribute!
+                    vertex_buffer_layout.push(VertexBufferLayout {
+                        attributes: vec![vertex_attribute],
+                        name: current_buffer_name.into(),
+                        step_mode: if instance {
+                            InputStepMode::Instance
+                        } else {
+                            InputStepMode::Vertex
+                        },
+                        stride: 0,
+                    });
+                }
+
+                ShaderLayout {
+                    bind_groups,
+                    vertex_buffer_layout,
+                    entry_point: entry_point_name,
+                }
+            }
+            Err(err) => panic!("Failed to reflect shader layout: {:?}.", err),
+        }
+    }
+}
+
+fn reflect_bind_group(
+    descriptor_set: &ReflectDescriptorSet,
+    shader_stage: ReflectShaderStageFlags,
+) -> BindGroupDescriptor {
+    let mut bindings = Vec::new();
+    for descriptor_binding in descriptor_set.bindings.iter() {
+        let binding = reflect_binding(descriptor_binding, shader_stage);
+        bindings.push(binding);
+    }
+
+    BindGroupDescriptor::new(descriptor_set.set, bindings)
+}
+
+fn reflect_dimension(type_description: &ReflectTypeDescription) -> TextureViewDimension {
+    match type_description.traits.image.dim {
+        ReflectDimension::Type1d => TextureViewDimension::D1,
+        ReflectDimension::Type2d => TextureViewDimension::D2,
+        ReflectDimension::Type3d => TextureViewDimension::D3,
+        ReflectDimension::Cube => TextureViewDimension::Cube,
+        dimension => panic!("Unsupported image dimension: {:?}.", dimension),
+    }
+}
+
+fn reflect_binding(
+    binding: &ReflectDescriptorBinding,
+    shader_stage: ReflectShaderStageFlags,
+) -> BindingDescriptor {
+    let type_description = binding.type_description.as_ref().unwrap();
+    let (name, bind_type) = match binding.descriptor_type {
+        ReflectDescriptorType::UniformBuffer => (
+            &type_description.type_name,
+            BindType::Uniform {
+                has_dynamic_offset: false,
+                property: reflect_uniform(type_description),
+            },
+        ),
+        ReflectDescriptorType::SampledImage => (
+            &binding.name,
+            BindType::Texture {
+                view_dimension: reflect_dimension(type_description),
+                sample_type: TextureSampleType::Float { filterable: true },
+                multisampled: false,
+            },
+        ),
+        ReflectDescriptorType::StorageBuffer => (
+            &type_description.type_name,
+            BindType::StorageBuffer {
+                has_dynamic_offset: false,
+                readonly: true,
+            },
+        ),
+        // TODO: detect comparison "true" case: https://github.com/gpuweb/gpuweb/issues/552
+        // TODO: detect filtering "true" case
+        ReflectDescriptorType::Sampler => (
+            &binding.name,
+            BindType::Sampler {
+                comparison: false,
+                filtering: true,
+            },
+        ),
+        _ => panic!("Unsupported bind type {:?}.", binding.descriptor_type),
+    };
+
+    let shader_stage = match shader_stage {
+        ReflectShaderStageFlags::COMPUTE => BindingShaderStage::COMPUTE,
+        ReflectShaderStageFlags::VERTEX => BindingShaderStage::VERTEX,
+        ReflectShaderStageFlags::FRAGMENT => BindingShaderStage::FRAGMENT,
+        _ => panic!("Only one specified shader stage is supported."),
+    };
+
+    BindingDescriptor {
+        index: binding.binding,
+        bind_type,
+        name: name.to_string(),
+        shader_stage,
+    }
+}
+
+#[derive(Debug)]
+enum NumberType {
+    Int,
+    UInt,
+    Float,
+}
+
+fn reflect_uniform(type_description: &ReflectTypeDescription) -> UniformProperty {
+    if type_description
+        .type_flags
+        .contains(ReflectTypeFlags::STRUCT)
+    {
+        reflect_uniform_struct(type_description)
+    } else {
+        reflect_uniform_numeric(type_description)
+    }
+}
+
+fn reflect_uniform_struct(type_description: &ReflectTypeDescription) -> UniformProperty {
+    let mut properties = Vec::new();
+    for member in type_description.members.iter() {
+        properties.push(reflect_uniform(member));
+    }
+
+    UniformProperty::Struct(properties)
+}
+
+fn reflect_uniform_numeric(type_description: &ReflectTypeDescription) -> UniformProperty {
+    let traits = &type_description.traits;
+    let number_type = if type_description.type_flags.contains(ReflectTypeFlags::INT) {
+        match traits.numeric.scalar.signedness {
+            0 => NumberType::UInt,
+            1 => NumberType::Int,
+            signedness => panic!("Unexpected signedness {}.", signedness),
+        }
+    } else if type_description
+        .type_flags
+        .contains(ReflectTypeFlags::FLOAT)
+    {
+        NumberType::Float
+    } else {
+        panic!("Unexpected type flag {:?}.", type_description.type_flags);
+    };
+
+    // TODO: handle scalar width here
+
+    if type_description
+        .type_flags
+        .contains(ReflectTypeFlags::MATRIX)
+    {
+        match (
+            number_type,
+            traits.numeric.matrix.column_count,
+            traits.numeric.matrix.row_count,
+        ) {
+            (NumberType::Float, 3, 3) => UniformProperty::Mat3,
+            (NumberType::Float, 4, 4) => UniformProperty::Mat4,
+            (number_type, column_count, row_count) => panic!(
+                "unexpected uniform property matrix format {:?} {}x{}",
+                number_type, column_count, row_count
+            ),
+        }
+    } else {
+        match (number_type, traits.numeric.vector.component_count) {
+            (NumberType::UInt, 0) => UniformProperty::UInt,
+            (NumberType::Int, 0) => UniformProperty::Int,
+            (NumberType::Int, 2) => UniformProperty::IVec2,
+            (NumberType::Float, 0) => UniformProperty::Float,
+            (NumberType::Float, 2) => UniformProperty::Vec2,
+            (NumberType::Float, 3) => UniformProperty::Vec3,
+            (NumberType::Float, 4) => UniformProperty::Vec4,
+            (NumberType::UInt, 4) => UniformProperty::UVec4,
+            (number_type, component_count) => panic!(
+                "unexpected uniform property format {:?} {}",
+                number_type, component_count
+            ),
+        }
+    }
+}
+
+fn reflect_vertex_format(type_description: &ReflectTypeDescription) -> VertexFormat {
+    let traits = &type_description.traits;
+    let number_type = if type_description.type_flags.contains(ReflectTypeFlags::INT) {
+        match traits.numeric.scalar.signedness {
+            0 => NumberType::UInt,
+            1 => NumberType::Int,
+            signedness => panic!("Unexpected signedness {}.", signedness),
+        }
+    } else if type_description
+        .type_flags
+        .contains(ReflectTypeFlags::FLOAT)
+    {
+        NumberType::Float
+    } else {
+        panic!("Unexpected type flag {:?}.", type_description.type_flags);
+    };
+
+    let width = traits.numeric.scalar.width;
+
+    match (number_type, traits.numeric.vector.component_count, width) {
+        (NumberType::UInt, 2, 8) => VertexFormat::Uint8x2,
+        (NumberType::UInt, 4, 8) => VertexFormat::Uint8x4,
+        (NumberType::Int, 2, 8) => VertexFormat::Sint8x2,
+        (NumberType::Int, 4, 8) => VertexFormat::Sint8x4,
+        (NumberType::UInt, 2, 16) => VertexFormat::Uint16x2,
+        (NumberType::UInt, 4, 16) => VertexFormat::Uint16x4,
+        (NumberType::Int, 2, 16) => VertexFormat::Sint16x2,
+        (NumberType::Int, 8, 16) => VertexFormat::Sint16x4,
+        (NumberType::Float, 2, 16) => VertexFormat::Float16x2,
+        (NumberType::Float, 4, 16) => VertexFormat::Float16x4,
+        (NumberType::Float, 0, 32) => VertexFormat::Float32,
+        (NumberType::Float, 2, 32) => VertexFormat::Float32x2,
+        (NumberType::Float, 3, 32) => VertexFormat::Float32x3,
+        (NumberType::Float, 4, 32) => VertexFormat::Float32x4,
+        (NumberType::UInt, 0, 32) => VertexFormat::Uint32,
+        (NumberType::UInt, 2, 32) => VertexFormat::Uint32x2,
+        (NumberType::UInt, 3, 32) => VertexFormat::Uint32x3,
+        (NumberType::UInt, 4, 32) => VertexFormat::Uint32x4,
+        (NumberType::Int, 0, 32) => VertexFormat::Sint32,
+        (NumberType::Int, 2, 32) => VertexFormat::Sint32x2,
+        (NumberType::Int, 3, 32) => VertexFormat::Sint32x3,
+        (NumberType::Int, 4, 32) => VertexFormat::Sint32x4,
+        (number_type, component_count, width) => panic!(
+            "unexpected uniform property format {:?} {} {}",
+            number_type, component_count, width
+        ),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::shader::{Shader, ShaderStage};
+
+    impl VertexBufferLayout {
+        pub fn test_zero_stride(mut self) -> VertexBufferLayout {
+            self.stride = 0;
+            self
+        }
+    }
+    #[test]
+    fn test_reflection() {
+        let vertex_shader = Shader::from_glsl(
+            ShaderStage::Vertex,
+            r#"
+            #version 450
+            layout(location = 0) in vec4 Vertex_Position;
+            layout(location = 1) in uvec4 Vertex_Normal;
+            layout(location = 2) in uvec4 I_TestInstancing_Property;
+
+            layout(location = 0) out vec4 v_Position;
+            layout(set = 0, binding = 0) uniform CameraViewProj {
+                mat4 ViewProj;
+            };
+            layout(set = 1, binding = 0) uniform texture2D Texture;
+
+            void main() {
+                v_Position = Vertex_Position;
+                gl_Position = ViewProj * v_Position;
+            }
+        "#,
+        )
+        .get_spirv_shader(None)
+        .unwrap();
+
+        let layout = vertex_shader.reflect_layout(true).unwrap();
+        assert_eq!(
+            layout,
+            ShaderLayout {
+                entry_point: "main".into(),
+                vertex_buffer_layout: vec![
+                    VertexBufferLayout::new_from_attribute(
+                        VertexAttribute {
+                            name: "Vertex_Position".into(),
+                            format: VertexFormat::Float32x4,
+                            offset: 0,
+                            shader_location: 0,
+                        },
+                        InputStepMode::Vertex
+                    )
+                    .test_zero_stride(),
+                    VertexBufferLayout::new_from_attribute(
+                        VertexAttribute {
+                            name: "Vertex_Normal".into(),
+                            format: VertexFormat::Uint32x4,
+                            offset: 0,
+                            shader_location: 1,
+                        },
+                        InputStepMode::Vertex
+                    )
+                    .test_zero_stride(),
+                    VertexBufferLayout::new_from_attribute(
+                        VertexAttribute {
+                            name: "I_TestInstancing_Property".into(),
+                            format: VertexFormat::Uint32x4,
+                            offset: 0,
+                            shader_location: 2,
+                        },
+                        InputStepMode::Instance
+                    )
+                    .test_zero_stride(),
+                ],
+                bind_groups: vec![
+                    BindGroupDescriptor::new(
+                        0,
+                        vec![BindingDescriptor {
+                            index: 0,
+                            name: "CameraViewProj".into(),
+                            bind_type: BindType::Uniform {
+                                has_dynamic_offset: false,
+                                property: UniformProperty::Struct(vec![UniformProperty::Mat4]),
+                            },
+                            shader_stage: BindingShaderStage::VERTEX,
+                        }]
+                    ),
+                    BindGroupDescriptor::new(
+                        1,
+                        vec![BindingDescriptor {
+                            index: 0,
+                            name: "Texture".into(),
+                            bind_type: BindType::Texture {
+                                multisampled: false,
+                                view_dimension: TextureViewDimension::D2,
+                                sample_type: TextureSampleType::Float { filterable: true }
+                            },
+                            shader_stage: BindingShaderStage::VERTEX,
+                        }]
+                    ),
+                ]
+            }
+        );
+    }
+}
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..da03340ef6
--- /dev/null
+++ b/pipelined/bevy_render2/src/texture/hdr_texture_loader.rs
@@ -0,0 +1,53 @@
+use super::{Extent3d, Texture, TextureDimension, TextureFormat};
+use anyhow::Result;
+use bevy_asset::{AssetLoader, LoadContext, LoadedAsset};
+use bevy_utils::BoxedFuture;
+
+/// 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 = Texture::new(
+                Extent3d::new(info.width, info.height, 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_texture_conversion.rs b/pipelined/bevy_render2/src/texture/image_texture_conversion.rs
new file mode 100644
index 0000000000..dbf12a0ead
--- /dev/null
+++ b/pipelined/bevy_render2/src/texture/image_texture_conversion.rs
@@ -0,0 +1,151 @@
+use super::{Extent3d, Texture, TextureDimension, TextureFormat};
+
+/// Helper method to convert a `DynamicImage` to a `Texture`
+pub(crate) fn image_to_texture(dyn_img: image::DynamicImage) -> Texture {
+    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 unsafe_get in release builds?
+                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();
+        }
+    }
+
+    Texture::new(
+        Extent3d::new(width, height, 1),
+        TextureDimension::D2,
+        data,
+        format,
+    )
+}
+
+/// Helper method to convert a `Texture` to a `DynamicImage`. Not all `Texture` formats are
+/// covered, it will return `None` if the format is not supported
+pub(crate) fn texture_to_image(texture: &Texture) -> Option<image::DynamicImage> {
+    match texture.format {
+        TextureFormat::R8Unorm => image::ImageBuffer::from_raw(
+            texture.size.width,
+            texture.size.height,
+            texture.data.clone(),
+        )
+        .map(image::DynamicImage::ImageLuma8),
+        TextureFormat::Rg8Unorm => image::ImageBuffer::from_raw(
+            texture.size.width,
+            texture.size.height,
+            texture.data.clone(),
+        )
+        .map(image::DynamicImage::ImageLumaA8),
+        TextureFormat::Rgba8UnormSrgb => image::ImageBuffer::from_raw(
+            texture.size.width,
+            texture.size.height,
+            texture.data.clone(),
+        )
+        .map(image::DynamicImage::ImageRgba8),
+        TextureFormat::Bgra8UnormSrgb => image::ImageBuffer::from_raw(
+            texture.size.width,
+            texture.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..1525c6330e
--- /dev/null
+++ b/pipelined/bevy_render2/src/texture/image_texture_loader.rs
@@ -0,0 +1,67 @@
+use super::texture::{ImageType, Texture, TextureError};
+use anyhow::Result;
+use bevy_asset::{AssetLoader, LoadContext, LoadedAsset};
+use bevy_utils::BoxedFuture;
+use thiserror::Error;
+
+/// 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 =
+                Texture::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..af84947532
--- /dev/null
+++ b/pipelined/bevy_render2/src/texture/mod.rs
@@ -0,0 +1,140 @@
+#[cfg(feature = "hdr")]
+mod hdr_texture_loader;
+mod image_texture_loader;
+mod sampler_descriptor;
+#[allow(clippy::module_inception)]
+mod texture;
+mod texture_descriptor;
+mod texture_dimension;
+
+pub(crate) mod image_texture_conversion;
+
+#[cfg(feature = "hdr")]
+pub use hdr_texture_loader::*;
+pub use image_texture_loader::*;
+pub use sampler_descriptor::*;
+pub use texture::*;
+pub use texture_descriptor::*;
+pub use texture_dimension::*;
+
+use crate::{
+    render_command::RenderCommandQueue,
+    render_resource::{BufferInfo, BufferUsage},
+    renderer::{RenderResourceContext, RenderResources},
+};
+use bevy_app::{App, CoreStage, Plugin};
+use bevy_asset::{AddAsset, AssetEvent, Assets, Handle};
+use bevy_ecs::prelude::*;
+use bevy_utils::HashSet;
+
+pub struct TexturePlugin;
+
+impl Plugin for TexturePlugin {
+    fn build(&self, app: &mut App) {
+        #[cfg(feature = "png")]
+        {
+            app.init_asset_loader::<ImageTextureLoader>();
+        }
+
+        app.add_system_to_stage(CoreStage::PostUpdate, texture_resource_system.system())
+            .add_asset::<Texture>();
+    }
+}
+
+// TODO: remove old system
+pub fn texture_resource_system(
+    render_resource_context: Res<RenderResources>,
+    mut render_command_queue: ResMut<RenderCommandQueue>,
+    mut textures: ResMut<Assets<Texture>>,
+    mut texture_events: EventReader<AssetEvent<Texture>>,
+) {
+    let render_resource_context = &**render_resource_context;
+    let mut changed_textures = HashSet::default();
+    for event in texture_events.iter() {
+        match event {
+            AssetEvent::Created { handle } => {
+                changed_textures.insert(handle);
+            }
+            AssetEvent::Modified { handle } => {
+                changed_textures.insert(handle);
+                remove_current_texture_resources(render_resource_context, handle, &mut textures);
+            }
+            AssetEvent::Removed { handle } => {
+                remove_current_texture_resources(render_resource_context, handle, &mut textures);
+                // if texture was modified and removed in the same update, ignore the
+                // modification events are ordered so future modification
+                // events are ok
+                changed_textures.remove(handle);
+            }
+        }
+    }
+
+    for texture_handle in changed_textures.iter() {
+        if let Some(texture) = textures.get_mut(*texture_handle) {
+            // TODO: this avoids creating new textures each frame because storing gpu data in the texture flags it as
+            // modified. this prevents hot reloading and therefore can't be used in an actual impl.
+            if texture.gpu_data.is_some() {
+                continue;
+            }
+            // TODO: free old buffers / textures / samplers
+
+            // TODO: using Into for TextureDescriptor is weird
+            let texture_descriptor: TextureDescriptor = (&*texture).into();
+            let texture_id = render_resource_context.create_texture(texture_descriptor);
+
+            let sampler_id = render_resource_context.create_sampler(&texture.sampler);
+
+            let width = texture.size.width as usize;
+            let aligned_width = render_resource_context.get_aligned_texture_size(width);
+            let format_size = texture.format.pixel_size();
+            let mut aligned_data = vec![
+                0;
+                format_size
+                    * aligned_width
+                    * texture.size.height as usize
+                    * texture.size.depth_or_array_layers as usize
+            ];
+            texture
+                .data
+                .chunks_exact(format_size * width)
+                .enumerate()
+                .for_each(|(index, row)| {
+                    let offset = index * aligned_width * format_size;
+                    aligned_data[offset..(offset + width * format_size)].copy_from_slice(row);
+                });
+            let staging_buffer_id = render_resource_context.create_buffer_with_data(
+                BufferInfo {
+                    buffer_usage: BufferUsage::COPY_SRC,
+                    ..Default::default()
+                },
+                &aligned_data,
+            );
+            texture.gpu_data = Some(GpuData {
+                texture_id,
+                sampler_id,
+            });
+
+            render_command_queue.copy_buffer_to_texture(
+                staging_buffer_id,
+                0,
+                (format_size * aligned_width) as u32,
+                texture_id,
+                [0, 0, 0],
+                0,
+                texture_descriptor.size,
+            );
+            render_command_queue.free_buffer(staging_buffer_id);
+        }
+    }
+}
+
+fn remove_current_texture_resources(
+    render_resource_context: &dyn RenderResourceContext,
+    handle: &Handle<Texture>,
+    textures: &mut Assets<Texture>,
+) {
+    if let Some(gpu_data) = textures.get_mut(handle).and_then(|t| t.gpu_data.take()) {
+        render_resource_context.remove_texture(gpu_data.texture_id);
+        render_resource_context.remove_sampler(gpu_data.sampler_id);
+    }
+}
diff --git a/pipelined/bevy_render2/src/texture/sampler_descriptor.rs b/pipelined/bevy_render2/src/texture/sampler_descriptor.rs
new file mode 100644
index 0000000000..453bf70d98
--- /dev/null
+++ b/pipelined/bevy_render2/src/texture/sampler_descriptor.rs
@@ -0,0 +1,79 @@
+use crate::pipeline::CompareFunction;
+use std::num::NonZeroU8;
+
+/// Describes a sampler
+#[derive(Debug, Copy, Clone)]
+pub struct SamplerDescriptor {
+    pub address_mode_u: AddressMode,
+    pub address_mode_v: AddressMode,
+    pub address_mode_w: AddressMode,
+    pub mag_filter: FilterMode,
+    pub min_filter: FilterMode,
+    pub mipmap_filter: FilterMode,
+    pub lod_min_clamp: f32,
+    pub lod_max_clamp: f32,
+    pub compare_function: Option<CompareFunction>,
+    pub anisotropy_clamp: Option<NonZeroU8>,
+    pub border_color: Option<SamplerBorderColor>,
+}
+
+impl SamplerDescriptor {
+    /// Sets the address mode for all dimensions of the sampler descriptor.
+    pub fn set_address_mode(&mut self, address_mode: AddressMode) {
+        self.address_mode_u = address_mode;
+        self.address_mode_v = address_mode;
+        self.address_mode_w = address_mode;
+    }
+}
+
+impl Default for SamplerDescriptor {
+    fn default() -> Self {
+        SamplerDescriptor {
+            address_mode_u: AddressMode::ClampToEdge,
+            address_mode_v: AddressMode::ClampToEdge,
+            address_mode_w: AddressMode::ClampToEdge,
+            mag_filter: FilterMode::Nearest,
+            min_filter: FilterMode::Linear,
+            mipmap_filter: FilterMode::Nearest,
+            lod_min_clamp: 0.0,
+            lod_max_clamp: std::f32::MAX,
+            compare_function: None,
+            anisotropy_clamp: None,
+            border_color: None,
+        }
+    }
+}
+
+/// How edges should be handled in texture addressing.
+#[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
+pub enum AddressMode {
+    ClampToEdge = 0,
+    Repeat = 1,
+    MirrorRepeat = 2,
+}
+
+impl Default for AddressMode {
+    fn default() -> Self {
+        AddressMode::ClampToEdge
+    }
+}
+
+/// Texel mixing mode when sampling between texels.
+#[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
+pub enum FilterMode {
+    Nearest = 0,
+    Linear = 1,
+}
+
+impl Default for FilterMode {
+    fn default() -> Self {
+        FilterMode::Nearest
+    }
+}
+
+#[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
+pub enum SamplerBorderColor {
+    TransparentBlack,
+    OpaqueBlack,
+    OpaqueWhite,
+}
diff --git a/pipelined/bevy_render2/src/texture/texture.rs b/pipelined/bevy_render2/src/texture/texture.rs
new file mode 100644
index 0000000000..0501c46247
--- /dev/null
+++ b/pipelined/bevy_render2/src/texture/texture.rs
@@ -0,0 +1,206 @@
+use super::{
+    image_texture_conversion::image_to_texture, Extent3d, SamplerDescriptor, TextureDimension,
+    TextureFormat,
+};
+use crate::render_resource::{SamplerId, TextureId};
+use bevy_reflect::TypeUuid;
+use thiserror::Error;
+
+pub const TEXTURE_ASSET_INDEX: u64 = 0;
+pub const SAMPLER_ASSET_INDEX: u64 = 1;
+
+// TODO: this shouldn't live in the Texture type
+#[derive(Debug, Clone)]
+pub struct GpuData {
+    pub texture_id: TextureId,
+    pub sampler_id: SamplerId,
+}
+
+#[derive(Debug, Clone, TypeUuid)]
+#[uuid = "6ea26da6-6cf8-4ea2-9986-1d7bf6c17d6f"]
+pub struct Texture {
+    pub data: Vec<u8>,
+    pub gpu_data: Option<GpuData>,
+    pub size: Extent3d,
+    pub format: TextureFormat,
+    pub dimension: TextureDimension,
+    pub sampler: SamplerDescriptor,
+}
+
+impl Default for Texture {
+    fn default() -> Self {
+        Texture {
+            data: Default::default(),
+            gpu_data: None,
+            size: Extent3d {
+                width: 1,
+                height: 1,
+                depth_or_array_layers: 1,
+            },
+            format: TextureFormat::Rgba8UnormSrgb,
+            dimension: TextureDimension::D2,
+            sampler: Default::default(),
+        }
+    }
+}
+
+impl Texture {
+    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",
+        );
+        Self {
+            data,
+            size,
+            format,
+            dimension,
+            ..Default::default()
+        }
+    }
+
+    pub fn new_fill(
+        size: Extent3d,
+        dimension: TextureDimension,
+        pixel: &[u8],
+        format: TextureFormat,
+    ) -> Self {
+        let mut value = Texture {
+            format,
+            dimension,
+            ..Default::default()
+        };
+        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
+    }
+
+    pub fn aspect_2d(&self) -> f32 {
+        self.size.height as f32 / self.size.width as f32
+    }
+
+    pub fn resize(&mut self, size: Extent3d) {
+        self.size = size;
+        self.data
+            .resize(size.volume() * self.format.pixel_size(), 0);
+    }
+
+    /// Changes the `size`, asserting that the total number of data elements (pixels) remains the
+    /// same.
+    pub fn reinterpret_size(&mut self, new_size: Extent3d) {
+        assert!(
+            new_size.volume() == self.size.volume(),
+            "Incompatible sizes: old = {:?} new = {:?}",
+            self.size,
+            new_size
+        );
+
+        self.size = new_size;
+    }
+
+    /// Takes a 2D texture containing vertically stacked images of the same size, and reinterprets
+    /// it as a 2D array texture, where each of the stacked images becomes one layer of the
+    /// array. This is primarily for use with the `texture2DArray` shader uniform type.
+    pub fn reinterpret_stacked_2d_as_array(&mut self, layers: u32) {
+        // Must be a stacked image, and the height must be divisible by layers.
+        assert!(self.dimension == TextureDimension::D2);
+        assert!(self.size.depth_or_array_layers == 1);
+        assert_eq!(self.size.height % layers, 0);
+
+        self.reinterpret_size(Extent3d {
+            width: self.size.width,
+            height: self.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<Texture, 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),
+}
+
+/// Type of a raw image buffer
+pub enum ImageType<'a> {
+    /// Mime type of an image, for example `"image/png"`
+    MimeType(&'a str),
+    /// Extension of an image file, for example `"png"`
+    Extension(&'a str),
+}
diff --git a/pipelined/bevy_render2/src/texture/texture_descriptor.rs b/pipelined/bevy_render2/src/texture/texture_descriptor.rs
new file mode 100644
index 0000000000..7df3bc4070
--- /dev/null
+++ b/pipelined/bevy_render2/src/texture/texture_descriptor.rs
@@ -0,0 +1,69 @@
+use super::{Extent3d, Texture, TextureDimension, TextureFormat, TextureUsage};
+
+/// Describes a texture
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+pub struct TextureDescriptor {
+    pub size: Extent3d,
+    pub mip_level_count: u32,
+    pub sample_count: u32,
+    pub dimension: TextureDimension,
+    pub format: TextureFormat,
+    pub usage: TextureUsage,
+}
+
+impl From<&Texture> for TextureDescriptor {
+    fn from(texture: &Texture) -> Self {
+        TextureDescriptor {
+            size: texture.size,
+            mip_level_count: 1,
+            sample_count: 1,
+            dimension: texture.dimension,
+            format: texture.format,
+            usage: TextureUsage::SAMPLED | TextureUsage::COPY_DST,
+        }
+    }
+}
+
+impl Default for TextureDescriptor {
+    fn default() -> Self {
+        TextureDescriptor {
+            size: Extent3d {
+                width: 1,
+                height: 1,
+                depth_or_array_layers: 1,
+            },
+            mip_level_count: 1,
+            sample_count: 1,
+            dimension: TextureDimension::D2,
+            format: TextureFormat::Rgba8UnormSrgb,
+            usage: TextureUsage::SAMPLED | TextureUsage::COPY_DST,
+        }
+    }
+}
+
+#[derive(Hash, Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd)]
+pub enum StorageTextureAccess {
+    /// The texture can only be read in the shader and it must be annotated with `readonly`.
+    ///
+    /// Example GLSL syntax:
+    /// ```cpp,ignore
+    /// layout(set=0, binding=0, r32f) readonly uniform image2D myStorageImage;
+    /// ```
+    ReadOnly,
+    /// The texture can only be written in the shader and it must be annotated with `writeonly`.
+    ///
+    /// Example GLSL syntax:
+    /// ```cpp,ignore
+    /// layout(set=0, binding=0, r32f) writeonly uniform image2D myStorageImage;
+    /// ```
+    WriteOnly,
+    /// The texture can be both read and written in the shader.
+    /// `wgpu::Features::STORAGE_TEXTURE_ACCESS_READ_WRITE` must be enabled to use this access
+    /// mode.
+    ///
+    /// Example GLSL syntax:
+    /// ```cpp,ignore
+    /// layout(set=0, binding=0, r32f) uniform image2D myStorageImage;
+    /// ```
+    ReadWrite,
+}
diff --git a/pipelined/bevy_render2/src/texture/texture_dimension.rs b/pipelined/bevy_render2/src/texture/texture_dimension.rs
new file mode 100644
index 0000000000..5791863591
--- /dev/null
+++ b/pipelined/bevy_render2/src/texture/texture_dimension.rs
@@ -0,0 +1,296 @@
+// NOTE: These are currently just copies of the wgpu types, but they might change in the future
+
+use bevy_math::Vec3;
+
+/// Dimensions of a particular texture view.
+#[derive(Copy, Clone, Debug, Hash, Eq, PartialEq, Ord, PartialOrd)]
+pub enum TextureViewDimension {
+    D1,
+    D2,
+    D2Array,
+    Cube,
+    CubeArray,
+    D3,
+}
+
+/// Dimensionality of a texture.
+#[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
+pub enum TextureDimension {
+    D1,
+    D2,
+    D3,
+}
+
+// TODO: use math type here
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct Extent3d {
+    pub width: u32,
+    pub height: u32,
+    pub depth_or_array_layers: u32,
+}
+
+impl Extent3d {
+    pub fn new(width: u32, height: u32, depth_or_array_layers: u32) -> Self {
+        Self {
+            width,
+            height,
+            depth_or_array_layers,
+        }
+    }
+
+    pub fn volume(&self) -> usize {
+        (self.width * self.height * self.depth_or_array_layers) as usize
+    }
+
+    pub fn as_vec3(&self) -> Vec3 {
+        Vec3::new(
+            self.width as f32,
+            self.height as f32,
+            self.depth_or_array_layers as f32,
+        )
+    }
+}
+
+/// Type of data shaders will read from a texture.
+#[derive(Copy, Hash, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
+pub enum TextureSampleType {
+    /// Sampling returns floats.
+    ///
+    /// If `filterable` is false, the texture can't be sampled with
+    /// a filtering sampler.
+    ///
+    /// Example GLSL syntax:
+    /// ```cpp,ignore
+    /// layout(binding = 0)
+    /// uniform texture2D t;
+    /// ```
+    Float { filterable: bool },
+    /// Sampling does the depth reference comparison.
+    ///
+    /// Example GLSL syntax:
+    /// ```cpp,ignore
+    /// layout(binding = 0)
+    /// uniform texture2DShadow t;
+    /// ```
+    Depth,
+    /// Sampling returns signed integers.
+    ///
+    /// Example GLSL syntax:
+    /// ```cpp,ignore
+    /// layout(binding = 0)
+    /// uniform itexture2D t;
+    /// ```
+    Sint,
+    /// Sampling returns unsigned integers.
+    ///
+    /// Example GLSL syntax:
+    /// ```cpp,ignore
+    /// layout(binding = 0)
+    /// uniform utexture2D t;
+    /// ```
+    Uint,
+}
+
+pub struct PixelInfo {
+    pub type_size: usize,
+    pub num_components: usize,
+}
+
+/// Underlying texture data format.
+///
+/// If there is a conversion in the format (such as srgb -> linear), The conversion listed is for
+/// loading from texture in a shader. When writing to the texture, the opposite conversion takes
+/// place.
+#[derive(Copy, Clone, Debug, Hash, Eq, PartialEq, Ord, PartialOrd)]
+pub enum TextureFormat {
+    // Normal 8 bit formats
+    R8Unorm = 0,
+    R8Snorm = 1,
+    R8Uint = 2,
+    R8Sint = 3,
+
+    // Normal 16 bit formats
+    R16Uint = 4,
+    R16Sint = 5,
+    R16Float = 6,
+    Rg8Unorm = 7,
+    Rg8Snorm = 8,
+    Rg8Uint = 9,
+    Rg8Sint = 10,
+
+    // Normal 32 bit formats
+    R32Uint = 11,
+    R32Sint = 12,
+    R32Float = 13,
+    Rg16Uint = 14,
+    Rg16Sint = 15,
+    Rg16Float = 16,
+    Rgba8Unorm = 17,
+    Rgba8UnormSrgb = 18,
+    Rgba8Snorm = 19,
+    Rgba8Uint = 20,
+    Rgba8Sint = 21,
+    Bgra8Unorm = 22,
+    Bgra8UnormSrgb = 23,
+
+    // Packed 32 bit formats
+    Rgb10a2Unorm = 24,
+    Rg11b10Float = 25,
+
+    // Normal 64 bit formats
+    Rg32Uint = 26,
+    Rg32Sint = 27,
+    Rg32Float = 28,
+    Rgba16Uint = 29,
+    Rgba16Sint = 30,
+    Rgba16Float = 31,
+
+    // Normal 128 bit formats
+    Rgba32Uint = 32,
+    Rgba32Sint = 33,
+    Rgba32Float = 34,
+
+    // Depth and stencil formats
+    Depth32Float = 35,
+    Depth24Plus = 36,
+    Depth24PlusStencil8 = 37,
+}
+
+impl TextureFormat {
+    pub 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,
+        };
+
+        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,
+        };
+
+        PixelInfo {
+            type_size,
+            num_components: components,
+        }
+    }
+
+    pub fn pixel_size(&self) -> usize {
+        let info = self.pixel_info();
+        info.type_size * info.num_components
+    }
+}
+
+impl Default for TextureFormat {
+    fn default() -> Self {
+        if cfg!(target_os = "android") {
+            // Bgra8UnormSrgb texture missing on some Android devices
+            TextureFormat::Rgba8UnormSrgb
+        } else {
+            TextureFormat::Bgra8UnormSrgb
+        }
+    }
+}
+
+bitflags::bitflags! {
+    #[repr(transparent)]
+    pub struct TextureUsage: u32 {
+        const COPY_SRC = 1;
+        const COPY_DST = 2;
+        const SAMPLED = 4;
+        const STORAGE = 8;
+        const OUTPUT_ATTACHMENT = 16;
+        const NONE = 0;
+        /// The combination of all read-only usages.
+        const READ_ALL = Self::COPY_SRC.bits | Self::SAMPLED.bits;
+        /// The combination of all write-only and read-write usages.
+        const WRITE_ALL = Self::COPY_DST.bits | Self::STORAGE.bits | Self::OUTPUT_ATTACHMENT.bits;
+        /// The combination of all usages that the are guaranteed to be be ordered by the hardware.
+        /// If a usage is not ordered, then even if it doesn't change between draw calls, there
+        /// still need to be pipeline barriers inserted for synchronization.
+        const ORDERED = Self::READ_ALL.bits | Self::OUTPUT_ATTACHMENT.bits;
+        const UNINITIALIZED = 0xFFFF;
+    }
+}
diff --git a/pipelined/bevy_sprite2/Cargo.toml b/pipelined/bevy_sprite2/Cargo.toml
new file mode 100644
index 0000000000..33460597fa
--- /dev/null
+++ b/pipelined/bevy_sprite2/Cargo.toml
@@ -0,0 +1,35 @@
+[package]
+name = "bevy_sprite2"
+version = "0.5.0"
+edition = "2018"
+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_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" }
+bevy_window = { path = "../../crates/bevy_window", version = "0.5.0" }
+
+# other
+rectangle-pack = "0.3"
+thiserror = "1.0"
+guillotiere = "0.6.0"
+serde = { version = "1", features = ["derive"] }
+parking_lot= "0.11.0"
+bytemuck = "1.5"
diff --git a/pipelined/bevy_sprite2/src/bundle.rs b/pipelined/bevy_sprite2/src/bundle.rs
new file mode 100644
index 0000000000..17c3181006
--- /dev/null
+++ b/pipelined/bevy_sprite2/src/bundle.rs
@@ -0,0 +1,24 @@
+use crate::Sprite;
+use bevy_asset::Handle;
+use bevy_ecs::bundle::Bundle;
+use bevy_render2::texture::Texture;
+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<Texture>,
+}
+
+impl Default for PipelinedSpriteBundle {
+    fn default() -> Self {
+        Self {
+            sprite: Default::default(),
+            transform: Default::default(),
+            global_transform: Default::default(),
+            texture: Default::default(),
+        }
+    }
+}
diff --git a/pipelined/bevy_sprite2/src/lib.rs b/pipelined/bevy_sprite2/src/lib.rs
new file mode 100644
index 0000000000..54eaee7540
--- /dev/null
+++ b/pipelined/bevy_sprite2/src/lib.rs
@@ -0,0 +1,47 @@
+mod bundle;
+mod render;
+mod rect;
+mod sprite;
+
+pub use rect::*;
+pub use render::*;
+pub use sprite::*;
+pub use bundle::*;
+
+use bevy_app::prelude::*;
+use bevy_ecs::prelude::IntoSystem;
+use bevy_render2::{
+    main_pass::{DrawFunctions, MainPassPlugin},
+    render_graph::RenderGraph,
+    RenderStage,
+};
+
+#[derive(Default)]
+pub struct SpritePlugin;
+
+impl Plugin for SpritePlugin {
+    fn build(&self, app: &mut App) {
+        app.register_type::<Sprite>();
+        app.add_plugin(MainPassPlugin);
+        let render_app = app.sub_app_mut(0);
+        render_app
+            .add_system_to_stage(RenderStage::Extract, render::extract_sprites.system())
+            .add_system_to_stage(RenderStage::Prepare, render::prepare_sprites.system())
+            .add_system_to_stage(RenderStage::Queue, queue_sprites.system())
+            .init_resource::<SpriteShaders>()
+            .init_resource::<SpriteBuffers>();
+        let draw_sprite = DrawSprite::new(&mut render_app.world);
+        render_app
+            .world
+            .get_resource::<DrawFunctions>()
+            .unwrap()
+            .add(draw_sprite);
+        let render_world = app.sub_app_mut(0).world.cell();
+        let mut graph = render_world.get_resource_mut::<RenderGraph>().unwrap();
+        graph.add_node("sprite", SpriteNode);
+        graph.add_node_edge("sprite", "main_pass").unwrap();
+        graph
+            .add_node_edge("render_command_queue", "main_pass")
+            .unwrap();
+    }
+}
diff --git a/pipelined/bevy_sprite2/src/rect.rs b/pipelined/bevy_sprite2/src/rect.rs
new file mode 100644
index 0000000000..06ac65658a
--- /dev/null
+++ b/pipelined/bevy_sprite2/src/rect.rs
@@ -0,0 +1,22 @@
+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
+    }
+}
diff --git a/pipelined/bevy_sprite2/src/render/mod.rs b/pipelined/bevy_sprite2/src/render/mod.rs
new file mode 100644
index 0000000000..eb86619438
--- /dev/null
+++ b/pipelined/bevy_sprite2/src/render/mod.rs
@@ -0,0 +1,394 @@
+use crate::Sprite;
+use bevy_asset::{Assets, Handle};
+use bevy_ecs::{prelude::*, system::ParamState};
+use bevy_math::{Mat4, Vec2, Vec3, Vec4Swizzles};
+use bevy_render2::{
+    camera::{CameraUniforms, Cameras},
+    main_pass::{Draw, Drawable, RenderPhase, TrackedRenderPass},
+    mesh::{shape::Quad, Indices, Mesh, VertexAttributeValues},
+    pipeline::*,
+    render_graph::{Node, ResourceSlots},
+    render_resource::{
+        BindGroupBuilder, BindGroupId, BufferUsage, BufferVec, RenderResourceBinding, SamplerId,
+        TextureId,
+    },
+    renderer::{RenderContext, RenderResources},
+    shader::{Shader, ShaderStage, ShaderStages},
+    texture::{Texture, TextureFormat},
+};
+use bevy_transform::components::GlobalTransform;
+use bevy_utils::HashMap;
+use bytemuck::{Pod, Zeroable};
+
+pub struct SpriteShaders {
+    pipeline: PipelineId,
+    pipeline_descriptor: PipelineDescriptor,
+}
+
+// TODO: this pattern for initializing the shaders / pipeline isn't ideal. this should be handled by the asset system
+impl FromWorld for SpriteShaders {
+    fn from_world(world: &mut World) -> Self {
+        let render_resources = world.get_resource::<RenderResources>().unwrap();
+        let vertex_shader = Shader::from_glsl(ShaderStage::Vertex, include_str!("sprite.vert"))
+            .get_spirv_shader(None)
+            .unwrap();
+        let fragment_shader = Shader::from_glsl(ShaderStage::Fragment, include_str!("sprite.frag"))
+            .get_spirv_shader(None)
+            .unwrap();
+
+        let vertex_layout = vertex_shader.reflect_layout(true).unwrap();
+        let fragment_layout = fragment_shader.reflect_layout(true).unwrap();
+
+        let mut pipeline_layout =
+            PipelineLayout::from_shader_layouts(&mut [vertex_layout, fragment_layout]);
+
+        let vertex = render_resources.create_shader_module(&vertex_shader);
+        let fragment = render_resources.create_shader_module(&fragment_shader);
+
+        pipeline_layout.vertex_buffer_descriptors = vec![VertexBufferLayout {
+            stride: 20,
+            name: "Vertex".into(),
+            step_mode: InputStepMode::Vertex,
+            attributes: vec![
+                VertexAttribute {
+                    name: "Vertex_Position".into(),
+                    format: VertexFormat::Float32x3,
+                    offset: 0,
+                    shader_location: 0,
+                },
+                VertexAttribute {
+                    name: "Vertex_Uv".into(),
+                    format: VertexFormat::Float32x2,
+                    offset: 12,
+                    shader_location: 1,
+                },
+            ],
+        }];
+
+        pipeline_layout.bind_groups[0].bindings[0].set_dynamic(true);
+
+        let pipeline_descriptor = PipelineDescriptor {
+            depth_stencil: None,
+            color_target_states: vec![ColorTargetState {
+                format: TextureFormat::default(),
+                blend: Some(BlendState {
+                    color: BlendComponent {
+                        src_factor: BlendFactor::SrcAlpha,
+                        dst_factor: BlendFactor::OneMinusSrcAlpha,
+                        operation: BlendOperation::Add,
+                    },
+                    alpha: BlendComponent {
+                        src_factor: BlendFactor::One,
+                        dst_factor: BlendFactor::One,
+                        operation: BlendOperation::Add,
+                    },
+                }),
+                write_mask: ColorWrite::ALL,
+            }],
+            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,
+            },
+            ..PipelineDescriptor::new(
+                ShaderStages {
+                    vertex,
+                    fragment: Some(fragment),
+                },
+                pipeline_layout,
+            )
+        };
+
+        let pipeline = render_resources.create_render_pipeline(&pipeline_descriptor);
+
+        SpriteShaders {
+            pipeline,
+            pipeline_descriptor,
+        }
+    }
+}
+
+struct ExtractedSprite {
+    transform: Mat4,
+    size: Vec2,
+    texture: TextureId,
+    sampler: SamplerId,
+}
+
+pub struct ExtractedSprites {
+    sprites: Vec<ExtractedSprite>,
+}
+
+pub fn extract_sprites(
+    mut commands: Commands,
+    textures: Res<Assets<Texture>>,
+    query: Query<(&Sprite, &GlobalTransform, &Handle<Texture>)>,
+) {
+    let mut extracted_sprites = Vec::new();
+    for (sprite, transform, handle) in query.iter() {
+        if let Some(texture) = textures.get(handle) {
+            if let Some(gpu_data) = &texture.gpu_data {
+                extracted_sprites.push(ExtractedSprite {
+                    transform: transform.compute_matrix(),
+                    size: sprite.size,
+                    texture: gpu_data.texture_id,
+                    sampler: gpu_data.sampler_id,
+                })
+            }
+        }
+    }
+
+    commands.insert_resource(ExtractedSprites {
+        sprites: extracted_sprites,
+    });
+}
+
+#[repr(C)]
+#[derive(Copy, Clone, Pod, Zeroable)]
+struct SpriteVertex {
+    pub position: [f32; 3],
+    pub uv: [f32; 2],
+}
+
+pub struct SpriteBuffers {
+    vertices: BufferVec<SpriteVertex>,
+    indices: BufferVec<u32>,
+    quad: Mesh,
+    camera_bind_group: Option<BindGroupId>,
+    texture_bind_groups: Vec<BindGroupId>,
+    dynamic_uniforms: Vec<u32>,
+}
+
+impl Default for SpriteBuffers {
+    fn default() -> Self {
+        Self {
+            vertices: BufferVec::new(BufferUsage::VERTEX),
+            indices: BufferVec::new(BufferUsage::INDEX),
+            camera_bind_group: None,
+            texture_bind_groups: Vec::new(),
+            dynamic_uniforms: Vec::new(),
+            quad: Quad {
+                size: Vec2::new(1.0, 1.0),
+                ..Default::default()
+            }
+            .into(),
+        }
+    }
+}
+
+pub fn prepare_sprites(
+    render_resources: Res<RenderResources>,
+    mut sprite_buffers: ResMut<SpriteBuffers>,
+    extracted_sprites: Res<ExtractedSprites>,
+) {
+    // dont create buffers when there are no sprites
+    if extracted_sprites.sprites.len() == 0 {
+        return;
+    }
+
+    let quad_vertex_positions = if let VertexAttributeValues::Float32x3(vertex_positions) =
+        sprite_buffers
+            .quad
+            .attribute(Mesh::ATTRIBUTE_POSITION)
+            .unwrap()
+            .clone()
+    {
+        vertex_positions
+    } else {
+        panic!("expected vec3");
+    };
+
+    let quad_vertex_uvs = if let VertexAttributeValues::Float32x2(vertex_uvs) = sprite_buffers
+        .quad
+        .attribute(Mesh::ATTRIBUTE_UV_0)
+        .unwrap()
+        .clone()
+    {
+        vertex_uvs
+    } else {
+        panic!("expected vec2");
+    };
+
+    let quad_indices = if let Indices::U32(indices) = sprite_buffers.quad.indices().unwrap() {
+        indices.clone()
+    } else {
+        panic!("expected u32 indices");
+    };
+
+    sprite_buffers.vertices.reserve_and_clear(
+        extracted_sprites.sprites.len() * quad_vertex_positions.len(),
+        &render_resources,
+    );
+    sprite_buffers.indices.reserve_and_clear(
+        extracted_sprites.sprites.len() * quad_indices.len(),
+        &render_resources,
+    );
+
+    for (i, extracted_sprite) in extracted_sprites.sprites.iter().enumerate() {
+        for (vertex_position, vertex_uv) in quad_vertex_positions.iter().zip(quad_vertex_uvs.iter())
+        {
+            let mut final_position =
+                Vec3::from(*vertex_position) * extracted_sprite.size.extend(1.0);
+            final_position = (extracted_sprite.transform * final_position.extend(1.0)).xyz();
+            sprite_buffers.vertices.push(SpriteVertex {
+                position: final_position.into(),
+                uv: *vertex_uv,
+            });
+        }
+
+        for index in quad_indices.iter() {
+            sprite_buffers
+                .indices
+                .push((i * quad_vertex_positions.len()) as u32 + *index);
+        }
+    }
+
+    sprite_buffers
+        .vertices
+        .write_to_staging_buffer(&render_resources);
+    sprite_buffers
+        .indices
+        .write_to_staging_buffer(&render_resources);
+}
+
+pub fn queue_sprites(
+    render_resources: Res<RenderResources>,
+    mut sprite_buffers: ResMut<SpriteBuffers>,
+    sprite_shaders: Res<SpriteShaders>,
+    mut transparent_phase: ResMut<RenderPhase>,
+    extracted_sprites: Res<ExtractedSprites>,
+    extracted_cameras: Res<Cameras>,
+    camera_uniforms: Query<&CameraUniforms>,
+) {
+    let camera_2d = if let Some(camera_2d) = extracted_cameras
+        .entities
+        .get(bevy_render2::camera::CAMERA_2D)
+    {
+        *camera_2d
+    } else {
+        return;
+    };
+
+    let layout = &sprite_shaders.pipeline_descriptor.layout;
+
+    if let Ok(camera_uniforms) = camera_uniforms.get(camera_2d) {
+        let camera_bind_group = BindGroupBuilder::default()
+            .add_binding(0, camera_uniforms.view_proj.clone())
+            .finish();
+
+        // TODO: this will only create the bind group if it isn't already created. this is a bit nasty
+        render_resources.create_bind_group(layout.bind_groups[0].id, &camera_bind_group);
+        sprite_buffers.camera_bind_group = Some(camera_bind_group.id);
+        sprite_buffers.dynamic_uniforms.clear();
+        if let RenderResourceBinding::Buffer {
+            dynamic_index: Some(index),
+            ..
+        } = camera_uniforms.view_proj
+        {
+            sprite_buffers.dynamic_uniforms.push(index);
+        }
+    }
+
+    // TODO: free old bind groups? clear_unused_bind_groups() currently does this for us? Moving to RAII would also do this for us?
+    sprite_buffers.texture_bind_groups.clear();
+    let mut texture_bind_group_indices = HashMap::default();
+
+    for (i, sprite) in extracted_sprites.sprites.iter().enumerate() {
+        let bind_group_index = *texture_bind_group_indices
+            .entry(sprite.texture)
+            .or_insert_with(|| {
+                let index = sprite_buffers.texture_bind_groups.len();
+                let bind_group = BindGroupBuilder::default()
+                    .add_binding(0, sprite.texture)
+                    // NOTE: this currently reuses the same sampler across all sprites using the same texture
+                    .add_binding(1, sprite.sampler)
+                    .finish();
+                render_resources.create_bind_group(layout.bind_groups[1].id, &bind_group);
+                sprite_buffers.texture_bind_groups.push(bind_group.id);
+                index
+            });
+        transparent_phase.add(Drawable {
+            draw_function: 0, // TODO: get this from DrawFunctions
+            draw_key: i,
+            sort_key: bind_group_index,
+        });
+    }
+
+    // TODO: this shouldn't happen here
+    transparent_phase.sort();
+}
+
+pub struct SpriteNode;
+
+impl Node for SpriteNode {
+    fn update(
+        &mut self,
+        world: &World,
+        render_context: &mut dyn RenderContext,
+        _input: &ResourceSlots,
+        _output: &mut ResourceSlots,
+    ) {
+        let sprite_buffers = world.get_resource::<SpriteBuffers>().unwrap();
+        sprite_buffers
+            .vertices
+            .write_to_uniform_buffer(render_context);
+        sprite_buffers
+            .indices
+            .write_to_uniform_buffer(render_context);
+    }
+}
+
+pub struct DrawSprite {
+    param_state: ParamState<(Res<'static, SpriteShaders>, Res<'static, SpriteBuffers>)>,
+}
+
+impl DrawSprite {
+    pub fn new(world: &mut World) -> Self {
+        Self {
+            param_state: ParamState::new(world),
+        }
+    }
+}
+
+impl Draw for DrawSprite {
+    fn draw(
+        &mut self,
+        world: &World,
+        pass: &mut TrackedRenderPass,
+        draw_key: usize,
+        sort_key: usize,
+    ) {
+        const INDICES: usize = 6;
+        let (sprite_shaders, sprite_buffers) = self.param_state.get(world);
+        let layout = &sprite_shaders.pipeline_descriptor.layout;
+        pass.set_pipeline(sprite_shaders.pipeline);
+        pass.set_vertex_buffer(0, sprite_buffers.vertices.buffer().unwrap(), 0);
+        pass.set_index_buffer(
+            sprite_buffers.indices.buffer().unwrap(),
+            0,
+            IndexFormat::Uint32,
+        );
+        pass.set_bind_group(
+            0,
+            layout.bind_groups[0].id,
+            sprite_buffers.camera_bind_group.unwrap(),
+            Some(&sprite_buffers.dynamic_uniforms),
+        );
+        pass.set_bind_group(
+            1,
+            layout.bind_groups[1].id,
+            sprite_buffers.texture_bind_groups[sort_key],
+            None,
+        );
+
+        pass.draw_indexed(
+            (draw_key * INDICES) as u32..(draw_key * INDICES + INDICES) as u32,
+            0,
+            0..1,
+        );
+    }
+}
diff --git a/pipelined/bevy_sprite2/src/render/sprite.frag b/pipelined/bevy_sprite2/src/render/sprite.frag
new file mode 100644
index 0000000000..1089fa5699
--- /dev/null
+++ b/pipelined/bevy_sprite2/src/render/sprite.frag
@@ -0,0 +1,11 @@
+#version 450
+
+layout(location = 0) in vec2 v_Uv;
+layout(location = 0) out vec4 o_Target;
+
+layout(set = 1, binding = 0) uniform texture2D sprite_texture;
+layout(set = 1, binding = 1) uniform sampler sprite_sampler;
+
+void main() {
+    o_Target = texture(sampler2D(sprite_texture, sprite_sampler), v_Uv);
+}
diff --git a/pipelined/bevy_sprite2/src/render/sprite.vert b/pipelined/bevy_sprite2/src/render/sprite.vert
new file mode 100644
index 0000000000..cc49fda78b
--- /dev/null
+++ b/pipelined/bevy_sprite2/src/render/sprite.vert
@@ -0,0 +1,15 @@
+#version 450
+
+layout(location = 0) in vec3 Vertex_Position;
+layout(location = 1) in vec2 Vertex_Uv;
+
+layout(location = 0) out vec2 v_Uv;
+
+layout(set = 0, binding = 0) uniform CameraViewProj {
+    mat4 ViewProj;
+};
+
+void main() {
+    v_Uv = Vertex_Uv;
+    gl_Position = ViewProj * vec4(Vertex_Position, 1.0);
+}
diff --git a/pipelined/bevy_sprite2/src/sprite.rs b/pipelined/bevy_sprite2/src/sprite.rs
new file mode 100644
index 0000000000..b4ca001c61
--- /dev/null
+++ b/pipelined/bevy_sprite2/src/sprite.rs
@@ -0,0 +1,39 @@
+use bevy_math::Vec2;
+use bevy_reflect::{Reflect, ReflectDeserialize, TypeUuid};
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Default, Clone, TypeUuid, Reflect)]
+#[uuid = "7233c597-ccfa-411f-bd59-9af349432ada"]
+#[repr(C)]
+pub struct Sprite {
+    pub size: Vec2,
+    pub flip_x: bool,
+    pub flip_y: bool,
+    pub resize_mode: SpriteResizeMode,
+}
+
+/// Determines how `Sprite` resize should be handled
+#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize, Reflect)]
+#[reflect_value(PartialEq, Serialize, Deserialize)]
+pub enum SpriteResizeMode {
+    Manual,
+    Automatic,
+}
+
+impl Default for SpriteResizeMode {
+    fn default() -> Self {
+        SpriteResizeMode::Automatic
+    }
+}
+
+impl Sprite {
+    /// Creates new `Sprite` with `SpriteResizeMode::Manual` value for `resize_mode`
+    pub fn new(size: Vec2) -> Self {
+        Self {
+            size,
+            resize_mode: SpriteResizeMode::Manual,
+            flip_x: false,
+            flip_y: false,
+        }
+    }
+}
\ No newline at end of file
diff --git a/pipelined/bevy_wgpu2/Cargo.toml b/pipelined/bevy_wgpu2/Cargo.toml
new file mode 100644
index 0000000000..b86ddf2c63
--- /dev/null
+++ b/pipelined/bevy_wgpu2/Cargo.toml
@@ -0,0 +1,37 @@
+[package]
+name = "bevy_wgpu2"
+version = "0.5.0"
+edition = "2018"
+authors = [
+    "Bevy Contributors <bevyengine@gmail.com>",
+    "Carter Anderson <mcanders1@gmail.com>",
+]
+description = "A wgpu render backend for Bevy Engine"
+homepage = "https://bevyengine.org"
+repository = "https://github.com/bevyengine/bevy"
+license = "MIT"
+keywords = ["bevy"]
+
+[features]
+default = ["bevy_winit"]
+trace = ["wgpu/trace"]
+
+[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_diagnostic = { path = "../../crates/bevy_diagnostic", version = "0.5.0" }
+bevy_ecs = { path = "../../crates/bevy_ecs", version = "0.5.0" }
+bevy_render2 = { path = "../bevy_render2", version = "0.5.0" }
+bevy_window = { path = "../../crates/bevy_window", version = "0.5.0" }
+bevy_winit = { path = "../../crates/bevy_winit", optional = true, version = "0.5.0" }
+bevy_utils = { path = "../../crates/bevy_utils", version = "0.5.0" }
+
+# other
+wgpu = "0.8"
+futures-lite = "1.4.0"
+crossbeam-channel = "0.5.0"
+crossbeam-utils = "0.8.1"
+parking_lot = "0.11.0"
+raw-window-handle = "0.3"
diff --git a/pipelined/bevy_wgpu2/src/diagnostic/mod.rs b/pipelined/bevy_wgpu2/src/diagnostic/mod.rs
new file mode 100644
index 0000000000..6037487a22
--- /dev/null
+++ b/pipelined/bevy_wgpu2/src/diagnostic/mod.rs
@@ -0,0 +1,2 @@
+mod wgpu_resource_diagnostics_plugin;
+pub use wgpu_resource_diagnostics_plugin::WgpuResourceDiagnosticsPlugin;
diff --git a/pipelined/bevy_wgpu2/src/diagnostic/wgpu_resource_diagnostics_plugin.rs b/pipelined/bevy_wgpu2/src/diagnostic/wgpu_resource_diagnostics_plugin.rs
new file mode 100644
index 0000000000..df58d2a9f0
--- /dev/null
+++ b/pipelined/bevy_wgpu2/src/diagnostic/wgpu_resource_diagnostics_plugin.rs
@@ -0,0 +1,183 @@
+use crate::WgpuRenderResourceContext;
+use bevy_app::prelude::*;
+use bevy_diagnostic::{Diagnostic, DiagnosticId, Diagnostics};
+use bevy_ecs::system::{IntoSystem, Res, ResMut};
+use bevy_render2::renderer::RenderResources;
+
+#[derive(Default)]
+pub struct WgpuResourceDiagnosticsPlugin;
+
+impl Plugin for WgpuResourceDiagnosticsPlugin {
+    fn build(&self, app: &mut App) {
+        app.add_startup_system(Self::setup_system.system())
+            .add_system(Self::diagnostic_system.system());
+    }
+}
+
+impl WgpuResourceDiagnosticsPlugin {
+    pub const BIND_GROUPS: DiagnosticId =
+        DiagnosticId::from_u128(21302464753369276741568507794995836890);
+    pub const BIND_GROUP_IDS: DiagnosticId =
+        DiagnosticId::from_u128(283571569334075937453357861280307923122);
+    pub const BIND_GROUP_LAYOUTS: DiagnosticId =
+        DiagnosticId::from_u128(96406067032931216377076410852598331304);
+    pub const BUFFERS: DiagnosticId =
+        DiagnosticId::from_u128(133146619577893994787249934474491530491);
+    pub const RENDER_PIPELINES: DiagnosticId =
+        DiagnosticId::from_u128(278527620040377353875091478462209885377);
+    pub const SAMPLERS: DiagnosticId =
+        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 =
+        DiagnosticId::from_u128(112048874168736161226721327099863374234);
+    pub const TEXTURES: DiagnosticId =
+        DiagnosticId::from_u128(305955424195390184883220102469231911115);
+    pub const TEXTURE_VIEWS: DiagnosticId =
+        DiagnosticId::from_u128(257307432866562594739240898780307437578);
+    pub const WINDOW_SURFACES: DiagnosticId =
+        DiagnosticId::from_u128(108237028251680341878766034324149135605);
+
+    pub fn setup_system(mut diagnostics: ResMut<Diagnostics>) {
+        diagnostics.add(Diagnostic::new(
+            Self::WINDOW_SURFACES,
+            "window_surfaces",
+            10,
+        ));
+
+        diagnostics.add(Diagnostic::new(Self::SWAP_CHAINS, "swap_chains", 10));
+
+        diagnostics.add(Diagnostic::new(
+            Self::SWAP_CHAIN_OUTPUTS,
+            "swap_chain_outputs",
+            10,
+        ));
+
+        diagnostics.add(Diagnostic::new(Self::BUFFERS, "buffers", 10));
+
+        diagnostics.add(Diagnostic::new(Self::TEXTURES, "textures", 10));
+
+        diagnostics.add(Diagnostic::new(Self::TEXTURE_VIEWS, "texture_views", 10));
+
+        diagnostics.add(Diagnostic::new(Self::SAMPLERS, "samplers", 10));
+
+        diagnostics.add(Diagnostic::new(Self::BIND_GROUP_IDS, "bind_group_ids", 10));
+        diagnostics.add(Diagnostic::new(Self::BIND_GROUPS, "bind_groups", 10));
+
+        diagnostics.add(Diagnostic::new(
+            Self::BIND_GROUP_LAYOUTS,
+            "bind_group_layouts",
+            10,
+        ));
+
+        diagnostics.add(Diagnostic::new(Self::SHADER_MODULES, "shader_modules", 10));
+
+        diagnostics.add(Diagnostic::new(
+            Self::RENDER_PIPELINES,
+            "render_pipelines",
+            10,
+        ));
+    }
+
+    pub fn diagnostic_system(
+        mut diagnostics: ResMut<Diagnostics>,
+        render_resources: Res<RenderResources>,
+    ) {
+        let render_resource_context = render_resources
+            .downcast_ref::<WgpuRenderResourceContext>()
+            .unwrap();
+
+        diagnostics.add_measurement(
+            Self::WINDOW_SURFACES,
+            render_resource_context
+                .resources
+                .window_surfaces
+                .read()
+                .len() as f64,
+        );
+
+        diagnostics.add_measurement(
+            Self::SWAP_CHAINS,
+            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
+                .read()
+                .len() as f64,
+        );
+
+        diagnostics.add_measurement(
+            Self::BUFFERS,
+            render_resource_context.resources.buffers.read().len() as f64,
+        );
+
+        diagnostics.add_measurement(
+            Self::TEXTURES,
+            render_resource_context.resources.textures.read().len() as f64,
+        );
+
+        diagnostics.add_measurement(
+            Self::TEXTURE_VIEWS,
+            render_resource_context.resources.texture_views.read().len() as f64,
+        );
+
+        diagnostics.add_measurement(
+            Self::SAMPLERS,
+            render_resource_context.resources.samplers.read().len() as f64,
+        );
+
+        diagnostics.add_measurement(
+            Self::BIND_GROUP_IDS,
+            render_resource_context.resources.bind_groups.read().len() as f64,
+        );
+
+        let mut bind_group_count = 0;
+        for bind_group in render_resource_context
+            .resources
+            .bind_groups
+            .read()
+            .values()
+        {
+            bind_group_count += bind_group.bind_groups.len();
+        }
+
+        diagnostics.add_measurement(Self::BIND_GROUPS, bind_group_count as f64);
+
+        diagnostics.add_measurement(
+            Self::BIND_GROUP_LAYOUTS,
+            render_resource_context
+                .resources
+                .bind_group_layouts
+                .read()
+                .len() as f64,
+        );
+
+        diagnostics.add_measurement(
+            Self::SHADER_MODULES,
+            render_resource_context
+                .resources
+                .shader_modules
+                .read()
+                .len() as f64,
+        );
+
+        diagnostics.add_measurement(
+            Self::RENDER_PIPELINES,
+            render_resource_context
+                .resources
+                .render_pipelines
+                .read()
+                .len() as f64,
+        );
+    }
+}
diff --git a/pipelined/bevy_wgpu2/src/lib.rs b/pipelined/bevy_wgpu2/src/lib.rs
new file mode 100644
index 0000000000..b20990bdef
--- /dev/null
+++ b/pipelined/bevy_wgpu2/src/lib.rs
@@ -0,0 +1,215 @@
+pub mod diagnostic;
+
+mod render_context;
+mod render_graph_executor;
+mod render_pass;
+mod render_resource_context;
+mod renderer;
+mod resources;
+mod type_converter;
+
+pub use render_context::*;
+pub use render_pass::*;
+pub use render_resource_context::*;
+pub use renderer::*;
+
+use bevy_app::prelude::*;
+use bevy_ecs::prelude::*;
+use bevy_render2::{
+    render_graph::{ExtractedWindow, ExtractedWindows, RawWindowHandleWrapper},
+    renderer::RenderResources,
+    RenderStage,
+};
+use bevy_window::Windows;
+use bevy_winit::WinitWindows;
+use futures_lite::future;
+use raw_window_handle::HasRawWindowHandle;
+use std::borrow::Cow;
+
+#[derive(Clone, Copy)]
+pub enum WgpuFeature {
+    DepthClamping,
+    TextureCompressionBc,
+    TimestampQuery,
+    PipelineStatisticsQuery,
+    MappablePrimaryBuffers,
+    SampledTextureBindingArray,
+    SampledTextureArrayDynamicIndexing,
+    SampledTextureArrayNonUniformIndexing,
+    UnsizedBindingArray,
+    MultiDrawIndirect,
+    MultiDrawIndirectCount,
+    PushConstants,
+    AddressModeClampToBorder,
+    NonFillPolygonMode,
+    TextureCompressionEtc2,
+    TextureCompressionAstcLdr,
+    TextureAdapterSpecificFormatFeatures,
+    ShaderFloat64,
+    VertexAttribute64Bit,
+}
+
+#[derive(Default, Clone)]
+pub struct WgpuFeatures {
+    pub features: Vec<WgpuFeature>,
+}
+
+#[derive(Debug, Clone)]
+pub struct WgpuLimits {
+    pub max_bind_groups: u32,
+    pub max_dynamic_uniform_buffers_per_pipeline_layout: u32,
+    pub max_dynamic_storage_buffers_per_pipeline_layout: u32,
+    pub max_sampled_textures_per_shader_stage: u32,
+    pub max_samplers_per_shader_stage: u32,
+    pub max_storage_buffers_per_shader_stage: u32,
+    pub max_storage_textures_per_shader_stage: u32,
+    pub max_uniform_buffers_per_shader_stage: u32,
+    pub max_uniform_buffer_binding_size: u32,
+    pub max_push_constant_size: u32,
+    pub max_texture_dimension_1d: u32,
+    pub max_texture_dimension_2d: u32,
+    pub max_texture_dimension_3d: u32,
+    pub max_texture_array_layers: u32,
+    pub max_storage_buffer_binding_size: u32,
+    pub max_vertex_buffers: u32,
+    pub max_vertex_attributes: u32,
+    pub max_vertex_buffer_array_stride: u32,
+}
+
+impl Default for WgpuLimits {
+    fn default() -> Self {
+        let default = wgpu::Limits::default();
+        WgpuLimits {
+            max_bind_groups: default.max_bind_groups,
+            max_dynamic_uniform_buffers_per_pipeline_layout: default
+                .max_dynamic_uniform_buffers_per_pipeline_layout,
+            max_dynamic_storage_buffers_per_pipeline_layout: default
+                .max_dynamic_storage_buffers_per_pipeline_layout,
+            max_sampled_textures_per_shader_stage: default.max_sampled_textures_per_shader_stage,
+            max_samplers_per_shader_stage: default.max_samplers_per_shader_stage,
+            max_storage_buffers_per_shader_stage: default.max_storage_buffers_per_shader_stage,
+            max_storage_textures_per_shader_stage: default.max_storage_textures_per_shader_stage,
+            max_uniform_buffers_per_shader_stage: default.max_uniform_buffers_per_shader_stage,
+            max_uniform_buffer_binding_size: default.max_uniform_buffer_binding_size,
+            max_push_constant_size: default.max_push_constant_size,
+            max_texture_dimension_1d: default.max_texture_dimension_1d,
+            max_texture_dimension_2d: default.max_texture_dimension_2d,
+            max_texture_dimension_3d: default.max_texture_dimension_3d,
+            max_texture_array_layers: default.max_texture_array_layers,
+            max_storage_buffer_binding_size: default.max_storage_buffer_binding_size,
+            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,
+        }
+    }
+}
+
+#[derive(Default)]
+pub struct WgpuPlugin;
+
+impl Plugin for WgpuPlugin {
+    fn build(&self, app: &mut App) {
+        let options = app
+            .world
+            .get_resource::<WgpuOptions>()
+            .cloned()
+            .unwrap_or_else(WgpuOptions::default);
+        let wgpu_renderer = future::block_on(WgpuRenderer::new(options));
+        let resource_context = WgpuRenderResourceContext::new(wgpu_renderer.device.clone());
+        app.world
+            .insert_resource(RenderResources::new(Box::new(resource_context.clone())));
+        let render_app = app.sub_app_mut(0);
+        render_app.insert_resource(RenderResources::new(Box::new(resource_context)));
+
+        let render_system = get_wgpu_render_system(wgpu_renderer);
+        render_app
+            .add_system_to_stage(RenderStage::Extract, extract_windows.system())
+            .add_system_to_stage(RenderStage::Render, render_system.exclusive_system());
+    }
+}
+
+pub fn get_wgpu_render_system(mut wgpu_renderer: WgpuRenderer) -> impl FnMut(&mut World) {
+    move |world| {
+        wgpu_renderer.update(world);
+    }
+}
+
+fn extract_windows(
+    mut commands: Commands,
+    winit_windows: Res<WinitWindows>,
+    windows: Res<Windows>,
+) {
+    let mut extracted_windows = ExtractedWindows::default();
+    for window in windows.iter() {
+        let winit_window = winit_windows.get_window(window.id()).unwrap();
+        extracted_windows.insert(
+            window.id(),
+            ExtractedWindow {
+                id: window.id(),
+                handle: RawWindowHandleWrapper(winit_window.raw_window_handle()),
+                physical_width: window.physical_width(),
+                physical_height: window.physical_height(),
+                vsync: window.vsync(),
+            },
+        );
+    }
+
+    commands.insert_resource(extracted_windows);
+}
+
+#[derive(Default, Clone)]
+pub struct WgpuOptions {
+    pub device_label: Option<Cow<'static, str>>,
+    pub backend: WgpuBackend,
+    pub power_pref: WgpuPowerOptions,
+    pub features: WgpuFeatures,
+    pub limits: WgpuLimits,
+}
+
+#[derive(Clone)]
+pub enum WgpuBackend {
+    Auto,
+    Vulkan,
+    Metal,
+    Dx12,
+    Dx11,
+    Gl,
+    BrowserWgpu,
+}
+
+impl WgpuBackend {
+    fn from_env() -> Self {
+        if let Ok(backend) = std::env::var("BEVY_WGPU_BACKEND") {
+            match backend.to_lowercase().as_str() {
+                "vulkan" => WgpuBackend::Vulkan,
+                "metal" => WgpuBackend::Metal,
+                "dx12" => WgpuBackend::Dx12,
+                "dx11" => WgpuBackend::Dx11,
+                "gl" => WgpuBackend::Gl,
+                "webgpu" => WgpuBackend::BrowserWgpu,
+                other => panic!("Unknown backend: {}", other),
+            }
+        } else {
+            WgpuBackend::Auto
+        }
+    }
+}
+
+impl Default for WgpuBackend {
+    fn default() -> Self {
+        Self::from_env()
+    }
+}
+
+#[derive(Clone)]
+pub enum WgpuPowerOptions {
+    HighPerformance,
+    Adaptive,
+    LowPower,
+}
+
+impl Default for WgpuPowerOptions {
+    fn default() -> Self {
+        WgpuPowerOptions::HighPerformance
+    }
+}
diff --git a/pipelined/bevy_wgpu2/src/render_context.rs b/pipelined/bevy_wgpu2/src/render_context.rs
new file mode 100644
index 0000000000..3a8cd67b00
--- /dev/null
+++ b/pipelined/bevy_wgpu2/src/render_context.rs
@@ -0,0 +1,265 @@
+use super::WgpuRenderResourceContext;
+use crate::{WgpuRenderPass, resources::WgpuResourceRefs, type_converter::WgpuInto};
+
+use bevy_render2::{
+    pass::{
+        PassDescriptor, RenderPass, RenderPassColorAttachment,
+        RenderPassDepthStencilAttachment, TextureAttachment,
+    },
+    render_resource::{BufferId, TextureId},
+    renderer::{RenderContext, RenderResourceContext},
+    texture::Extent3d,
+};
+
+use std::sync::Arc;
+
+#[derive(Debug, Default)]
+pub struct LazyCommandEncoder {
+    command_encoder: Option<wgpu::CommandEncoder>,
+}
+
+impl LazyCommandEncoder {
+    pub fn get_or_create(&mut self, device: &wgpu::Device) -> &mut wgpu::CommandEncoder {
+        match self.command_encoder {
+            Some(ref mut command_encoder) => command_encoder,
+            None => {
+                self.create(device);
+                self.command_encoder.as_mut().unwrap()
+            }
+        }
+    }
+
+    pub fn is_some(&self) -> bool {
+        self.command_encoder.is_some()
+    }
+
+    pub fn create(&mut self, device: &wgpu::Device) {
+        let command_encoder =
+            device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
+        self.command_encoder = Some(command_encoder);
+    }
+
+    pub fn take(&mut self) -> Option<wgpu::CommandEncoder> {
+        self.command_encoder.take()
+    }
+
+    pub fn set(&mut self, command_encoder: wgpu::CommandEncoder) {
+        self.command_encoder = Some(command_encoder);
+    }
+}
+
+#[derive(Debug)]
+pub struct WgpuRenderContext {
+    pub device: Arc<wgpu::Device>,
+    pub command_encoder: LazyCommandEncoder,
+    pub render_resource_context: WgpuRenderResourceContext,
+}
+
+impl WgpuRenderContext {
+    pub fn new(device: Arc<wgpu::Device>, resources: WgpuRenderResourceContext) -> Self {
+        WgpuRenderContext {
+            device,
+            render_resource_context: resources,
+            command_encoder: LazyCommandEncoder::default(),
+        }
+    }
+
+    /// Consume this context, finalize the current CommandEncoder (if it exists), and take the
+    /// current WgpuResources. This is intended to be called from a worker thread right before
+    /// synchronizing with the main thread.
+    pub fn finish(&mut self) -> Option<wgpu::CommandBuffer> {
+        self.command_encoder.take().map(|encoder| encoder.finish())
+    }
+}
+
+impl RenderContext for WgpuRenderContext {
+    fn copy_buffer_to_buffer(
+        &mut self,
+        source_buffer: BufferId,
+        source_offset: u64,
+        destination_buffer: BufferId,
+        destination_offset: u64,
+        size: u64,
+    ) {
+        self.render_resource_context.copy_buffer_to_buffer(
+            self.command_encoder.get_or_create(&self.device),
+            source_buffer,
+            source_offset,
+            destination_buffer,
+            destination_offset,
+            size,
+        );
+    }
+
+    fn copy_buffer_to_texture(
+        &mut self,
+        source_buffer: BufferId,
+        source_offset: u64,
+        source_bytes_per_row: u32,
+        destination_texture: TextureId,
+        destination_origin: [u32; 3],
+        destination_mip_level: u32,
+        size: Extent3d,
+    ) {
+        self.render_resource_context.copy_buffer_to_texture(
+            self.command_encoder.get_or_create(&self.device),
+            source_buffer,
+            source_offset,
+            source_bytes_per_row,
+            destination_texture,
+            destination_origin,
+            destination_mip_level,
+            size,
+        )
+    }
+
+    fn copy_texture_to_buffer(
+        &mut self,
+        source_texture: TextureId,
+        source_origin: [u32; 3],
+        source_mip_level: u32,
+        destination_buffer: BufferId,
+        destination_offset: u64,
+        destination_bytes_per_row: u32,
+        size: Extent3d,
+    ) {
+        self.render_resource_context.copy_texture_to_buffer(
+            self.command_encoder.get_or_create(&self.device),
+            source_texture,
+            source_origin,
+            source_mip_level,
+            destination_buffer,
+            destination_offset,
+            destination_bytes_per_row,
+            size,
+        )
+    }
+
+    fn copy_texture_to_texture(
+        &mut self,
+        source_texture: TextureId,
+        source_origin: [u32; 3],
+        source_mip_level: u32,
+        destination_texture: TextureId,
+        destination_origin: [u32; 3],
+        destination_mip_level: u32,
+        size: Extent3d,
+    ) {
+        self.render_resource_context.copy_texture_to_texture(
+            self.command_encoder.get_or_create(&self.device),
+            source_texture,
+            source_origin,
+            source_mip_level,
+            destination_texture,
+            destination_origin,
+            destination_mip_level,
+            size,
+        )
+    }
+
+    fn resources(&self) -> &dyn RenderResourceContext {
+        &self.render_resource_context
+    }
+
+    fn resources_mut(&mut self) -> &mut dyn RenderResourceContext {
+        &mut self.render_resource_context
+    }
+
+    fn begin_pass(
+        &mut self,
+        pass_descriptor: &PassDescriptor,
+        run_pass: &mut dyn FnMut(&mut dyn RenderPass),
+    ) {
+        if !self.command_encoder.is_some() {
+            self.command_encoder.create(&self.device);
+        }
+        let resource_lock = self.render_resource_context.resources.read();
+        let refs = resource_lock.refs();
+        let mut encoder = self.command_encoder.take().unwrap();
+        {
+            let render_pass = create_render_pass(pass_descriptor, &refs, &mut encoder);
+            let mut wgpu_render_pass = WgpuRenderPass {
+                render_pass,
+                render_context: self,
+                wgpu_resources: refs,
+                pipeline_descriptor: None,
+            };
+
+            run_pass(&mut wgpu_render_pass);
+        }
+
+        self.command_encoder.set(encoder);
+    }
+}
+
+pub fn create_render_pass<'a, 'b>(
+    pass_descriptor: &PassDescriptor,
+    refs: &WgpuResourceRefs<'a>,
+    encoder: &'a mut wgpu::CommandEncoder,
+) -> wgpu::RenderPass<'a> {
+    encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+        label: None,
+        color_attachments: &pass_descriptor
+            .color_attachments
+            .iter()
+            .map(|c| create_wgpu_color_attachment(refs, c))
+            .collect::<Vec<wgpu::RenderPassColorAttachment>>(),
+        depth_stencil_attachment: pass_descriptor
+            .depth_stencil_attachment
+            .as_ref()
+            .map(|d| create_wgpu_depth_stencil_attachment(refs, d)),
+    })
+}
+
+fn get_texture_view<'a>(
+    refs: &WgpuResourceRefs<'a>,
+    attachment: &TextureAttachment,
+) -> &'a wgpu::TextureView {
+    match attachment {
+        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!"),
+    }
+}
+
+fn create_wgpu_color_attachment<'a>(
+    refs: &WgpuResourceRefs<'a>,
+    color_attachment: &RenderPassColorAttachment,
+) -> wgpu::RenderPassColorAttachment<'a> {
+    let view = get_texture_view(
+        refs,
+        &color_attachment.attachment,
+    );
+
+    let resolve_target = color_attachment
+        .resolve_target
+        .as_ref()
+        .map(|target| get_texture_view(refs, &target));
+
+    wgpu::RenderPassColorAttachment {
+        ops: (&color_attachment.ops).wgpu_into(),
+        view,
+        resolve_target,
+    }
+}
+
+fn create_wgpu_depth_stencil_attachment<'a>(
+    refs: &WgpuResourceRefs<'a>,
+    depth_stencil_attachment: &RenderPassDepthStencilAttachment,
+) -> wgpu::RenderPassDepthStencilAttachment<'a> {
+    let view = get_texture_view(
+        refs,
+        &depth_stencil_attachment.attachment,
+    );
+
+    wgpu::RenderPassDepthStencilAttachment {
+        view,
+        depth_ops: depth_stencil_attachment
+            .depth_ops
+            .as_ref()
+            .map(|ops| ops.wgpu_into()),
+        stencil_ops: depth_stencil_attachment
+            .stencil_ops
+            .as_ref()
+            .map(|ops| ops.wgpu_into()),
+    }
+}
diff --git a/pipelined/bevy_wgpu2/src/render_graph_executor.rs b/pipelined/bevy_wgpu2/src/render_graph_executor.rs
new file mode 100644
index 0000000000..0c14374e8e
--- /dev/null
+++ b/pipelined/bevy_wgpu2/src/render_graph_executor.rs
@@ -0,0 +1,102 @@
+use crate::{WgpuRenderContext, WgpuRenderResourceContext};
+use bevy_ecs::world::World;
+use bevy_render2::{
+    render_graph::{Edge, NodeId, ResourceSlots, StageBorrow},
+    renderer::RenderResources,
+};
+use bevy_utils::HashMap;
+use parking_lot::RwLock;
+use std::sync::Arc;
+
+#[derive(Debug)]
+pub struct WgpuRenderGraphExecutor {
+    pub max_thread_count: usize,
+}
+
+impl WgpuRenderGraphExecutor {
+    pub fn execute(
+        &self,
+        world: &World,
+        device: Arc<wgpu::Device>,
+        queue: &mut wgpu::Queue,
+        stages: &mut [StageBorrow],
+    ) {
+        let render_resource_context = {
+            let context = world.get_resource::<RenderResources>().unwrap();
+            context
+                .downcast_ref::<WgpuRenderResourceContext>()
+                .unwrap()
+                .clone()
+        };
+        let node_outputs: Arc<RwLock<HashMap<NodeId, ResourceSlots>>> = Default::default();
+        for stage in stages.iter_mut() {
+            // TODO: sort jobs and slice by "amount of work" / weights
+            // stage.jobs.sort_by_key(|j| j.node_states.len());
+
+            let (sender, receiver) = crossbeam_channel::bounded(self.max_thread_count);
+            let chunk_size = (stage.jobs.len() + self.max_thread_count - 1) / self.max_thread_count; // divide ints rounding remainder up
+            let mut actual_thread_count = 0;
+            // crossbeam_utils::thread::scope(|s| {
+            for jobs_chunk in stage.jobs.chunks_mut(chunk_size) {
+                let sender = sender.clone();
+                let world = &*world;
+                actual_thread_count += 1;
+                let device = device.clone();
+                let render_resource_context = render_resource_context.clone();
+                let node_outputs = node_outputs.clone();
+                // s.spawn(move |_| {
+                let mut render_context = WgpuRenderContext::new(device, render_resource_context);
+                for job in jobs_chunk.iter_mut() {
+                    for node_state in job.node_states.iter_mut() {
+                        // bind inputs from connected node outputs
+                        for (i, mut input_slot) in node_state.input_slots.iter_mut().enumerate() {
+                            if let Edge::SlotEdge {
+                                output_node,
+                                output_index,
+                                ..
+                            } = node_state.edges.get_input_slot_edge(i).unwrap()
+                            {
+                                let node_outputs = node_outputs.read();
+                                let outputs = if let Some(outputs) = node_outputs.get(output_node) {
+                                    outputs
+                                } else {
+                                    panic!("Node inputs not set.")
+                                };
+
+                                let output_resource =
+                                    outputs.get(*output_index).expect("Output should be set.");
+                                input_slot.resource = Some(output_resource);
+                            } else {
+                                panic!("No edge connected to input.")
+                            }
+                        }
+                        node_state.node.update(
+                            world,
+                            &mut render_context,
+                            &node_state.input_slots,
+                            &mut node_state.output_slots,
+                        );
+
+                        node_outputs
+                            .write()
+                            .insert(node_state.id, node_state.output_slots.clone());
+                    }
+                }
+                sender.send(render_context.finish()).unwrap();
+                // });
+            }
+            // })
+            // .unwrap();
+
+            let mut command_buffers = Vec::new();
+            for _i in 0..actual_thread_count {
+                let command_buffer = receiver.recv().unwrap();
+                if let Some(command_buffer) = command_buffer {
+                    command_buffers.push(command_buffer);
+                }
+            }
+
+            queue.submit(command_buffers.drain(..));
+        }
+    }
+}
diff --git a/pipelined/bevy_wgpu2/src/render_pass.rs b/pipelined/bevy_wgpu2/src/render_pass.rs
new file mode 100644
index 0000000000..dc6a21e3de
--- /dev/null
+++ b/pipelined/bevy_wgpu2/src/render_pass.rs
@@ -0,0 +1,105 @@
+use crate::{resources::WgpuResourceRefs, type_converter::WgpuInto, WgpuRenderContext};
+use bevy_render2::{
+    pass::RenderPass,
+    pipeline::{BindGroupDescriptorId, IndexFormat, PipelineDescriptor, PipelineId},
+    render_resource::{BindGroupId, BufferId},
+    renderer::RenderContext,
+};
+use bevy_utils::tracing::trace;
+use std::ops::Range;
+
+#[derive(Debug)]
+pub struct WgpuRenderPass<'a> {
+    pub render_pass: wgpu::RenderPass<'a>,
+    pub render_context: &'a WgpuRenderContext,
+    pub wgpu_resources: WgpuResourceRefs<'a>,
+    pub pipeline_descriptor: Option<&'a PipelineDescriptor>,
+}
+
+impl<'a> RenderPass for WgpuRenderPass<'a> {
+    fn get_render_context(&self) -> &dyn RenderContext {
+        self.render_context
+    }
+
+    fn set_vertex_buffer(&mut self, start_slot: u32, buffer_id: BufferId, offset: u64) {
+        let buffer = self.wgpu_resources.buffers.get(&buffer_id).unwrap();
+        self.render_pass
+            .set_vertex_buffer(start_slot, buffer.slice(offset..));
+    }
+
+    fn set_viewport(&mut self, x: f32, y: f32, w: f32, h: f32, min_depth: f32, max_depth: f32) {
+        self.render_pass
+            .set_viewport(x, y, w, h, min_depth, max_depth);
+    }
+
+    fn set_scissor_rect(&mut self, x: u32, y: u32, w: u32, h: u32) {
+        self.render_pass.set_scissor_rect(x, y, w, h);
+    }
+
+    fn set_stencil_reference(&mut self, reference: u32) {
+        self.render_pass.set_stencil_reference(reference);
+    }
+
+    fn set_index_buffer(&mut self, buffer_id: BufferId, offset: u64, index_format: IndexFormat) {
+        let buffer = self.wgpu_resources.buffers.get(&buffer_id).unwrap();
+        self.render_pass
+            .set_index_buffer(buffer.slice(offset..), index_format.wgpu_into());
+    }
+
+    fn draw_indexed(&mut self, indices: Range<u32>, base_vertex: i32, instances: Range<u32>) {
+        self.render_pass
+            .draw_indexed(indices, base_vertex, instances);
+    }
+
+    fn draw(&mut self, vertices: Range<u32>, instances: Range<u32>) {
+        self.render_pass.draw(vertices, instances);
+    }
+
+    fn set_bind_group(
+        &mut self,
+        index: u32,
+        bind_group_descriptor_id: BindGroupDescriptorId,
+        bind_group: BindGroupId,
+        dynamic_uniform_indices: Option<&[u32]>,
+    ) {
+        if let Some(bind_group_info) = self
+            .wgpu_resources
+            .bind_groups
+            .get(&bind_group_descriptor_id)
+        {
+            if let Some(wgpu_bind_group) = bind_group_info.bind_groups.get(&bind_group) {
+                const EMPTY: &[u32] = &[];
+                let dynamic_uniform_indices =
+                    if let Some(dynamic_uniform_indices) = dynamic_uniform_indices {
+                        dynamic_uniform_indices
+                    } else {
+                        EMPTY
+                    };
+                self.wgpu_resources
+                    .used_bind_group_sender
+                    .send(bind_group)
+                    .unwrap();
+
+                trace!(
+                    "set bind group {:?} {:?}: {:?}",
+                    bind_group_descriptor_id,
+                    dynamic_uniform_indices,
+                    bind_group
+                );
+                self.render_pass
+                    .set_bind_group(index, wgpu_bind_group, dynamic_uniform_indices);
+            }
+        }
+    }
+
+    fn set_pipeline(&mut self, pipeline: PipelineId) {
+        let pipeline = self
+            .wgpu_resources
+            .render_pipelines
+            .get(&pipeline)
+            .expect(
+            "Attempted to use a pipeline that does not exist in this `RenderPass`'s `RenderContext`.",
+        );
+        self.render_pass.set_pipeline(pipeline);
+    }
+}
diff --git a/pipelined/bevy_wgpu2/src/render_resource_context.rs b/pipelined/bevy_wgpu2/src/render_resource_context.rs
new file mode 100644
index 0000000000..8515fe3821
--- /dev/null
+++ b/pipelined/bevy_wgpu2/src/render_resource_context.rs
@@ -0,0 +1,641 @@
+use crate::{
+    resources::{WgpuBindGroupInfo, WgpuResources},
+    type_converter::{OwnedWgpuVertexBufferLayout, WgpuInto},
+};
+use bevy_render2::{
+    pipeline::{
+        BindGroupDescriptor, BindGroupDescriptorId, BindingShaderStage, PipelineDescriptor,
+        PipelineId,
+    },
+    render_resource::{
+        BindGroup, BufferId, BufferInfo, BufferMapMode, RenderResourceBinding, SamplerId,
+        SwapChainDescriptor, TextureId,
+    },
+    renderer::RenderResourceContext,
+    shader::{Shader, ShaderId},
+    texture::{Extent3d, SamplerDescriptor, TextureDescriptor},
+};
+use bevy_utils::tracing::trace;
+use bevy_window::{Window, WindowId};
+use futures_lite::future;
+use std::{
+    borrow::Cow,
+    num::{NonZeroU32, NonZeroU64},
+    ops::Range,
+    sync::Arc,
+};
+use wgpu::util::DeviceExt;
+
+#[derive(Clone, Debug)]
+pub struct WgpuRenderResourceContext {
+    pub device: Arc<wgpu::Device>,
+    pub resources: WgpuResources,
+}
+
+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;
+pub const COPY_BUFFER_ALIGNMENT: usize = wgpu::COPY_BUFFER_ALIGNMENT as usize;
+pub const PUSH_CONSTANT_ALIGNMENT: u32 = wgpu::PUSH_CONSTANT_ALIGNMENT;
+
+impl WgpuRenderResourceContext {
+    pub fn new(device: Arc<wgpu::Device>) -> Self {
+        WgpuRenderResourceContext {
+            device,
+            resources: WgpuResources::default(),
+        }
+    }
+
+    pub fn set_window_surface(&self, window_id: WindowId, surface: wgpu::Surface) {
+        let mut window_surfaces = self.resources.window_surfaces.write();
+        window_surfaces.insert(window_id, surface);
+    }
+
+    pub fn contains_window_surface(&self, window_id: WindowId) -> bool {
+        self.resources
+            .window_surfaces
+            .read()
+            .contains_key(&window_id)
+    }
+
+    pub fn copy_buffer_to_buffer(
+        &self,
+        command_encoder: &mut wgpu::CommandEncoder,
+        source_buffer: BufferId,
+        source_offset: u64,
+        destination_buffer: BufferId,
+        destination_offset: u64,
+        size: u64,
+    ) {
+        let buffers = self.resources.buffers.read();
+
+        let source = buffers.get(&source_buffer).unwrap();
+        let destination = buffers.get(&destination_buffer).unwrap();
+        command_encoder.copy_buffer_to_buffer(
+            source,
+            source_offset,
+            destination,
+            destination_offset,
+            size,
+        );
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub fn copy_texture_to_texture(
+        &self,
+        command_encoder: &mut wgpu::CommandEncoder,
+        source_texture: TextureId,
+        source_origin: [u32; 3], // TODO: replace with math type
+        source_mip_level: u32,
+        destination_texture: TextureId,
+        destination_origin: [u32; 3], // TODO: replace with math type
+        destination_mip_level: u32,
+        size: Extent3d,
+    ) {
+        let textures = self.resources.textures.read();
+        let source = textures.get(&source_texture).unwrap();
+        let destination = textures.get(&destination_texture).unwrap();
+        command_encoder.copy_texture_to_texture(
+            wgpu::ImageCopyTexture {
+                texture: source,
+                mip_level: source_mip_level,
+                origin: wgpu::Origin3d {
+                    x: source_origin[0],
+                    y: source_origin[1],
+                    z: source_origin[2],
+                },
+            },
+            wgpu::ImageCopyTexture {
+                texture: destination,
+                mip_level: destination_mip_level,
+                origin: wgpu::Origin3d {
+                    x: destination_origin[0],
+                    y: destination_origin[1],
+                    z: destination_origin[2],
+                },
+            },
+            size.wgpu_into(),
+        )
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub fn copy_texture_to_buffer(
+        &self,
+        command_encoder: &mut wgpu::CommandEncoder,
+        source_texture: TextureId,
+        source_origin: [u32; 3], // TODO: replace with math type
+        source_mip_level: u32,
+        destination_buffer: BufferId,
+        destination_offset: u64,
+        destination_bytes_per_row: u32,
+        size: Extent3d,
+    ) {
+        let buffers = self.resources.buffers.read();
+        let textures = self.resources.textures.read();
+
+        let source = textures.get(&source_texture).unwrap();
+        let destination = buffers.get(&destination_buffer).unwrap();
+        command_encoder.copy_texture_to_buffer(
+            wgpu::ImageCopyTexture {
+                texture: source,
+                mip_level: source_mip_level,
+                origin: wgpu::Origin3d {
+                    x: source_origin[0],
+                    y: source_origin[1],
+                    z: source_origin[2],
+                },
+            },
+            wgpu::ImageCopyBuffer {
+                buffer: destination,
+                layout: wgpu::ImageDataLayout {
+                    offset: destination_offset,
+                    bytes_per_row: NonZeroU32::new(destination_bytes_per_row),
+                    rows_per_image: NonZeroU32::new(size.height),
+                },
+            },
+            size.wgpu_into(),
+        );
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub fn copy_buffer_to_texture(
+        &self,
+        command_encoder: &mut wgpu::CommandEncoder,
+        source_buffer: BufferId,
+        source_offset: u64,
+        source_bytes_per_row: u32,
+        destination_texture: TextureId,
+        destination_origin: [u32; 3], // TODO: replace with math type
+        destination_mip_level: u32,
+        size: Extent3d,
+    ) {
+        let buffers = self.resources.buffers.read();
+        let textures = self.resources.textures.read();
+
+        let source = buffers.get(&source_buffer).unwrap();
+        let destination = textures.get(&destination_texture).unwrap();
+        command_encoder.copy_buffer_to_texture(
+            wgpu::ImageCopyBuffer {
+                buffer: source,
+                layout: wgpu::ImageDataLayout {
+                    offset: source_offset,
+                    bytes_per_row: NonZeroU32::new(source_bytes_per_row),
+                    rows_per_image: NonZeroU32::new(size.height),
+                },
+            },
+            wgpu::ImageCopyTexture {
+                texture: destination,
+                mip_level: destination_mip_level,
+                origin: wgpu::Origin3d {
+                    x: destination_origin[0],
+                    y: destination_origin[1],
+                    z: destination_origin[2],
+                },
+            },
+            size.wgpu_into(),
+        );
+    }
+
+    pub fn create_bind_group_layout(&self, descriptor: &BindGroupDescriptor) {
+        if self
+            .resources
+            .bind_group_layouts
+            .read()
+            .get(&descriptor.id)
+            .is_some()
+        {
+            return;
+        }
+
+        let mut bind_group_layouts = self.resources.bind_group_layouts.write();
+        // TODO: consider re-checking existence here
+        let bind_group_layout_entries = descriptor
+            .bindings
+            .iter()
+            .map(|binding| {
+                let shader_stage = if binding.shader_stage
+                    == BindingShaderStage::VERTEX | BindingShaderStage::FRAGMENT
+                {
+                    wgpu::ShaderStage::VERTEX | wgpu::ShaderStage::FRAGMENT
+                } else if binding.shader_stage == BindingShaderStage::VERTEX {
+                    wgpu::ShaderStage::VERTEX
+                } else if binding.shader_stage == BindingShaderStage::FRAGMENT {
+                    wgpu::ShaderStage::FRAGMENT
+                } else {
+                    panic!("Invalid binding shader stage.")
+                };
+                wgpu::BindGroupLayoutEntry {
+                    binding: binding.index,
+                    visibility: shader_stage,
+                    ty: (&binding.bind_type).wgpu_into(),
+                    count: None,
+                }
+            })
+            .collect::<Vec<wgpu::BindGroupLayoutEntry>>();
+        let wgpu_descriptor = wgpu::BindGroupLayoutDescriptor {
+            entries: bind_group_layout_entries.as_slice(),
+            label: None,
+        };
+        let bind_group_layout = self.device.create_bind_group_layout(&wgpu_descriptor);
+        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();
+
+        let window_swap_chain = window_swap_chains.get_mut(&window_id)?;
+        let next_texture = window_swap_chain.get_current_frame().ok()?;
+        let id = TextureId::new();
+        swap_chain_outputs.insert(id, next_texture);
+        Some(id)
+    }
+}
+
+impl RenderResourceContext for WgpuRenderResourceContext {
+    fn create_sampler(&self, sampler_descriptor: &SamplerDescriptor) -> SamplerId {
+        let mut samplers = self.resources.samplers.write();
+
+        let descriptor: wgpu::SamplerDescriptor = (*sampler_descriptor).wgpu_into();
+        let sampler = self.device.create_sampler(&descriptor);
+
+        let id = SamplerId::new();
+        samplers.insert(id, sampler);
+        id
+    }
+
+    fn create_texture(&self, texture_descriptor: TextureDescriptor) -> TextureId {
+        let mut textures = self.resources.textures.write();
+        let mut texture_views = self.resources.texture_views.write();
+        let mut texture_descriptors = self.resources.texture_descriptors.write();
+
+        let descriptor: wgpu::TextureDescriptor = (&texture_descriptor).wgpu_into();
+        let texture = self.device.create_texture(&descriptor);
+        let texture_view = texture.create_view(&wgpu::TextureViewDescriptor::default());
+
+        let id = TextureId::new();
+        texture_descriptors.insert(id, texture_descriptor);
+        texture_views.insert(id, texture_view);
+        textures.insert(id, texture);
+        id
+    }
+
+    fn create_buffer(&self, buffer_info: BufferInfo) -> BufferId {
+        // TODO: consider moving this below "create" for efficiency
+        let mut buffer_infos = self.resources.buffer_infos.write();
+        let mut buffers = self.resources.buffers.write();
+
+        let buffer = self.device.create_buffer(&wgpu::BufferDescriptor {
+            label: None,
+            size: buffer_info.size as u64,
+            usage: buffer_info.buffer_usage.wgpu_into(),
+            mapped_at_creation: buffer_info.mapped_at_creation,
+        });
+
+        let id = BufferId::new();
+        buffer_infos.insert(id, buffer_info);
+        buffers.insert(id, Arc::new(buffer));
+        id
+    }
+
+    fn create_buffer_with_data(&self, mut buffer_info: BufferInfo, data: &[u8]) -> BufferId {
+        // TODO: consider moving this below "create" for efficiency
+        let mut buffer_infos = self.resources.buffer_infos.write();
+        let mut buffers = self.resources.buffers.write();
+
+        buffer_info.size = data.len();
+        let buffer = self
+            .device
+            .create_buffer_init(&wgpu::util::BufferInitDescriptor {
+                contents: data,
+                label: None,
+                usage: buffer_info.buffer_usage.wgpu_into(),
+            });
+
+        let id = BufferId::new();
+        buffer_infos.insert(id, buffer_info);
+        buffers.insert(id, Arc::new(buffer));
+        id
+    }
+
+    fn remove_buffer(&self, buffer: BufferId) {
+        let mut buffer_infos = self.resources.buffer_infos.write();
+        let mut buffers = self.resources.buffers.write();
+
+        buffers.remove(&buffer);
+        buffer_infos.remove(&buffer);
+    }
+
+    fn remove_texture(&self, texture: TextureId) {
+        let mut textures = self.resources.textures.write();
+        let mut texture_views = self.resources.texture_views.write();
+        let mut texture_descriptors = self.resources.texture_descriptors.write();
+
+        textures.remove(&texture);
+        texture_views.remove(&texture);
+        texture_descriptors.remove(&texture);
+    }
+
+    fn remove_sampler(&self, sampler: SamplerId) {
+        let mut samplers = self.resources.samplers.write();
+        samplers.remove(&sampler);
+    }
+
+    fn create_shader_module(&self, shader: &Shader) -> ShaderId {
+        let mut shader_modules = self.resources.shader_modules.write();
+        let spirv: Cow<[u32]> = shader.get_spirv(None).unwrap().into();
+        let shader_module = self
+            .device
+            .create_shader_module(&wgpu::ShaderModuleDescriptor {
+                label: None,
+                source: wgpu::ShaderSource::SpirV(spirv),
+                flags: Default::default(),
+            });
+        let id = ShaderId::new();
+        shader_modules.insert(id, shader_module);
+        id
+    }
+
+    fn create_swap_chain(&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 = 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);
+    }
+
+    fn next_swap_chain_texture(&self, descriptor: &SwapChainDescriptor) -> TextureId {
+        if let Some(texture_id) = self.try_next_swap_chain_texture(descriptor.window_id) {
+            texture_id
+        } else {
+            {
+                let surfaces = self.resources.window_surfaces.read();
+                let swap_chain_descriptor: wgpu::SwapChainDescriptor = descriptor.wgpu_into();
+                let mut window_swap_chains = self.resources.window_swap_chains.write();
+                let surface = surfaces
+                    .get(&descriptor.window_id)
+                    .expect("No surface found for window.");
+                let swap_chain = self
+                    .device
+                    .create_swap_chain(surface, &swap_chain_descriptor);
+
+                window_swap_chains.insert(descriptor.window_id, swap_chain);
+            }
+            self.try_next_swap_chain_texture(descriptor.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_all_swap_chain_textures(&self) {
+        let mut swap_chain_outputs = self.resources.swap_chain_frames.write();
+        swap_chain_outputs.clear();
+    }
+
+    fn create_render_pipeline(&self, pipeline_descriptor: &PipelineDescriptor) -> PipelineId {
+        let layout = &pipeline_descriptor.layout;
+        for bind_group_descriptor in layout.bind_groups.iter() {
+            self.create_bind_group_layout(&bind_group_descriptor);
+        }
+
+        let bind_group_layouts = self.resources.bind_group_layouts.read();
+        // setup and collect bind group layouts
+        let bind_group_layouts = layout
+            .bind_groups
+            .iter()
+            .map(|bind_group| bind_group_layouts.get(&bind_group.id).unwrap())
+            .collect::<Vec<&wgpu::BindGroupLayout>>();
+
+        let pipeline_layout = self
+            .device
+            .create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+                label: None,
+                bind_group_layouts: bind_group_layouts.as_slice(),
+                push_constant_ranges: &[],
+            });
+
+        let owned_vertex_buffer_descriptors = layout
+            .vertex_buffer_descriptors
+            .iter()
+            .map(|v| v.wgpu_into())
+            .collect::<Vec<OwnedWgpuVertexBufferLayout>>();
+
+        let color_states = pipeline_descriptor
+            .color_target_states
+            .iter()
+            .map(|c| c.wgpu_into())
+            .collect::<Vec<wgpu::ColorTargetState>>();
+
+        let shader_modules = self.resources.shader_modules.read();
+        let vertex_shader_module = shader_modules
+            .get(&pipeline_descriptor.shader_stages.vertex)
+            .unwrap();
+
+        let fragment_shader_module = pipeline_descriptor
+            .shader_stages
+            .fragment
+            .as_ref()
+            .map(|fragment_handle| shader_modules.get(fragment_handle).unwrap());
+        let render_pipeline_descriptor = wgpu::RenderPipelineDescriptor {
+            label: None,
+            layout: Some(&pipeline_layout),
+            vertex: wgpu::VertexState {
+                module: &vertex_shader_module,
+                entry_point: "main",
+                buffers: &owned_vertex_buffer_descriptors
+                    .iter()
+                    .map(|v| v.into())
+                    .collect::<Vec<wgpu::VertexBufferLayout>>(),
+            },
+            fragment: pipeline_descriptor
+                .shader_stages
+                .fragment
+                .as_ref()
+                .map(|_| wgpu::FragmentState {
+                    entry_point: "main",
+                    module: fragment_shader_module.as_ref().unwrap(),
+                    targets: color_states.as_slice(),
+                }),
+            primitive: pipeline_descriptor.primitive.clone().wgpu_into(),
+            depth_stencil: pipeline_descriptor
+                .depth_stencil
+                .clone()
+                .map(|depth_stencil| depth_stencil.wgpu_into()),
+            multisample: pipeline_descriptor.multisample.clone().wgpu_into(),
+        };
+
+        let render_pipeline = self
+            .device
+            .create_render_pipeline(&render_pipeline_descriptor);
+        let mut render_pipelines = self.resources.render_pipelines.write();
+        let id = PipelineId::new();
+        render_pipelines.insert(id, render_pipeline);
+        id
+    }
+
+    fn bind_group_descriptor_exists(
+        &self,
+        bind_group_descriptor_id: BindGroupDescriptorId,
+    ) -> bool {
+        let bind_group_layouts = self.resources.bind_group_layouts.read();
+        bind_group_layouts.get(&bind_group_descriptor_id).is_some()
+    }
+
+    fn create_bind_group(
+        &self,
+        bind_group_descriptor_id: BindGroupDescriptorId,
+        bind_group: &BindGroup,
+    ) {
+        if !self
+            .resources
+            .has_bind_group(bind_group_descriptor_id, bind_group.id)
+        {
+            trace!(
+                "start creating bind group for RenderResourceSet {:?}",
+                bind_group.id
+            );
+            let texture_views = self.resources.texture_views.read();
+            let samplers = self.resources.samplers.read();
+            let buffers = self.resources.buffers.read();
+            let bind_group_layouts = self.resources.bind_group_layouts.read();
+            let mut bind_groups = self.resources.bind_groups.write();
+
+            let entries = bind_group
+                .indexed_bindings
+                .iter()
+                .map(|indexed_binding| {
+                    let wgpu_resource = match &indexed_binding.entry {
+                        RenderResourceBinding::Texture(resource) => {
+                            let texture_view = texture_views
+                                .get(&resource)
+                                .unwrap_or_else(|| panic!("{:?}", resource));
+                            wgpu::BindingResource::TextureView(texture_view)
+                        }
+                        RenderResourceBinding::Sampler(resource) => {
+                            let sampler = samplers.get(&resource).unwrap();
+                            wgpu::BindingResource::Sampler(sampler)
+                        }
+                        RenderResourceBinding::Buffer { buffer, range, .. } => {
+                            let wgpu_buffer = buffers.get(&buffer).unwrap();
+                            let size = NonZeroU64::new(range.end - range.start)
+                                .expect("Size of the buffer needs to be greater than 0!");
+                            wgpu::BindingResource::Buffer(wgpu::BufferBinding {
+                                buffer: wgpu_buffer,
+                                offset: range.start,
+                                size: Some(size),
+                            })
+                        }
+                    };
+                    wgpu::BindGroupEntry {
+                        binding: indexed_binding.index,
+                        resource: wgpu_resource,
+                    }
+                })
+                .collect::<Vec<wgpu::BindGroupEntry>>();
+
+            let bind_group_layout = bind_group_layouts.get(&bind_group_descriptor_id).unwrap();
+            let wgpu_bind_group_descriptor = wgpu::BindGroupDescriptor {
+                label: None,
+                layout: bind_group_layout,
+                entries: entries.as_slice(),
+            };
+            let wgpu_bind_group = self.device.create_bind_group(&wgpu_bind_group_descriptor);
+
+            let bind_group_info = bind_groups
+                .entry(bind_group_descriptor_id)
+                .or_insert_with(WgpuBindGroupInfo::default);
+            bind_group_info
+                .bind_groups
+                .insert(bind_group.id, wgpu_bind_group);
+            trace!(
+                "created bind group for RenderResourceSet {:?}",
+                bind_group.id
+            );
+        }
+    }
+
+    fn clear_bind_groups(&self) {
+        self.resources.bind_groups.write().clear();
+    }
+
+    fn remove_stale_bind_groups(&self) {
+        self.resources.remove_stale_bind_groups();
+    }
+
+    fn get_buffer_info(&self, buffer: BufferId) -> Option<BufferInfo> {
+        self.resources.buffer_infos.read().get(&buffer).cloned()
+    }
+
+    fn write_mapped_buffer(
+        &self,
+        id: BufferId,
+        range: Range<u64>,
+        write: &mut dyn FnMut(&mut [u8], &dyn RenderResourceContext),
+    ) {
+        let buffer = {
+            let buffers = self.resources.buffers.read();
+            buffers.get(&id).unwrap().clone()
+        };
+        let buffer_slice = buffer.slice(range);
+        let mut data = buffer_slice.get_mapped_range_mut();
+        write(&mut data, self);
+    }
+
+    fn read_mapped_buffer(
+        &self,
+        id: BufferId,
+        range: Range<u64>,
+        read: &dyn Fn(&[u8], &dyn RenderResourceContext),
+    ) {
+        let buffer = {
+            let buffers = self.resources.buffers.read();
+            buffers.get(&id).unwrap().clone()
+        };
+        let buffer_slice = buffer.slice(range);
+        let data = buffer_slice.get_mapped_range();
+        read(&data, self);
+    }
+
+    fn map_buffer(&self, id: BufferId, mode: BufferMapMode) {
+        let buffers = self.resources.buffers.read();
+        let buffer = buffers.get(&id).unwrap();
+        let buffer_slice = buffer.slice(..);
+        let wgpu_mode = match mode {
+            BufferMapMode::Read => wgpu::MapMode::Read,
+            BufferMapMode::Write => wgpu::MapMode::Write,
+        };
+        let data = buffer_slice.map_async(wgpu_mode);
+        self.device.poll(wgpu::Maintain::Wait);
+        if future::block_on(data).is_err() {
+            panic!("Failed to map buffer to host.");
+        }
+    }
+
+    fn unmap_buffer(&self, id: BufferId) {
+        let buffers = self.resources.buffers.read();
+        let buffer = buffers.get(&id).unwrap();
+        buffer.unmap();
+    }
+
+    fn get_aligned_texture_size(&self, size: usize) -> usize {
+        (size + COPY_BYTES_PER_ROW_ALIGNMENT - 1) & !(COPY_BYTES_PER_ROW_ALIGNMENT - 1)
+    }
+
+    fn get_aligned_uniform_size(&self, size: usize, dynamic: bool) -> usize {
+        if dynamic {
+            (size + BIND_BUFFER_ALIGNMENT - 1) & !(BIND_BUFFER_ALIGNMENT - 1)
+        } else {
+            size
+        }
+    }
+}
diff --git a/pipelined/bevy_wgpu2/src/renderer.rs b/pipelined/bevy_wgpu2/src/renderer.rs
new file mode 100644
index 0000000000..6408da8c92
--- /dev/null
+++ b/pipelined/bevy_wgpu2/src/renderer.rs
@@ -0,0 +1,112 @@
+use crate::{
+    render_graph_executor::WgpuRenderGraphExecutor, type_converter::WgpuInto, WgpuBackend,
+    WgpuOptions, WgpuPowerOptions, WgpuRenderResourceContext,
+};
+use bevy_ecs::world::{Mut, World};
+use bevy_render2::{
+    render_graph::{DependentNodeStager, ExtractedWindows, RenderGraph, RenderGraphStager},
+    renderer::RenderResources,
+};
+use std::sync::Arc;
+
+pub struct WgpuRenderer {
+    pub instance: wgpu::Instance,
+    pub device: Arc<wgpu::Device>,
+    pub queue: wgpu::Queue,
+    pub initialized: bool,
+}
+
+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,
+        };
+        let instance = wgpu::Instance::new(backend);
+
+        let adapter = instance
+            .request_adapter(&wgpu::RequestAdapterOptions {
+                power_preference: match options.power_pref {
+                    WgpuPowerOptions::HighPerformance => wgpu::PowerPreference::HighPerformance,
+                    WgpuPowerOptions::Adaptive => wgpu::PowerPreference::LowPower,
+                    WgpuPowerOptions::LowPower => wgpu::PowerPreference::LowPower,
+                },
+                compatible_surface: None,
+            })
+            .await
+            .expect("Unable to find a GPU! Make sure you have installed required drivers!");
+
+        #[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(
+                &wgpu::DeviceDescriptor {
+                    label: options.device_label.as_ref().map(|a| a.as_ref()),
+                    features: options.features.wgpu_into(),
+                    limits: options.limits.wgpu_into(),
+                },
+                trace_path,
+            )
+            .await
+            .unwrap();
+        let device = Arc::new(device);
+        WgpuRenderer {
+            instance,
+            device,
+            queue,
+            initialized: false,
+        }
+    }
+
+    pub fn handle_new_windows(&mut self, world: &mut World) {
+        let world = world.cell();
+        let mut render_resources = world.get_resource_mut::<RenderResources>().unwrap();
+        let render_resource_context = render_resources
+            .downcast_mut::<WgpuRenderResourceContext>()
+            .unwrap();
+        let extracted_windows = world.get_resource::<ExtractedWindows>().unwrap();
+        for (id, window) in extracted_windows.iter() {
+            if !render_resource_context.contains_window_surface(*id) {
+                let surface = unsafe { self.instance.create_surface(&window.handle) };
+                render_resource_context.set_window_surface(*id, surface);
+            }
+        }
+    }
+
+    pub fn run_graph(&mut self, world: &mut World) {
+        world.resource_scope(|world, mut render_graph: Mut<RenderGraph>| {
+            // stage nodes
+            let mut stager = DependentNodeStager::loose_grouping();
+            let stages = stager.get_stages(&render_graph).unwrap();
+            let mut borrowed = stages.borrow(&mut render_graph);
+
+            // execute stages
+            let graph_executor = WgpuRenderGraphExecutor {
+                max_thread_count: 2,
+            };
+            graph_executor.execute(world, self.device.clone(), &mut self.queue, &mut borrowed);
+        })
+    }
+
+    pub fn update(&mut self, world: &mut World) {
+        self.handle_new_windows(world);
+        self.run_graph(world);
+
+        let render_resources = world.get_resource::<RenderResources>().unwrap();
+        render_resources.drop_all_swap_chain_textures();
+        render_resources.remove_stale_bind_groups();
+    }
+}
diff --git a/pipelined/bevy_wgpu2/src/resources.rs b/pipelined/bevy_wgpu2/src/resources.rs
new file mode 100644
index 0000000000..14e7024f1b
--- /dev/null
+++ b/pipelined/bevy_wgpu2/src/resources.rs
@@ -0,0 +1,181 @@
+use bevy_render2::{
+    pipeline::{BindGroupDescriptorId, PipelineId},
+    render_resource::{BindGroupId, BufferId, BufferInfo, SamplerId, TextureId},
+    shader::ShaderId,
+    texture::TextureDescriptor,
+};
+use bevy_utils::HashMap;
+use bevy_window::WindowId;
+use crossbeam_channel::{Receiver, Sender, TryRecvError};
+use parking_lot::{RwLock, RwLockReadGuard};
+use std::sync::Arc;
+
+#[derive(Debug, Default)]
+pub struct WgpuBindGroupInfo {
+    pub bind_groups: HashMap<BindGroupId, wgpu::BindGroup>,
+}
+
+/// Grabs a read lock on all wgpu resources. When paired with WgpuResourceRefs, this allows
+/// you to pass in wgpu resources to wgpu::RenderPass<'a> with the appropriate lifetime. This is
+/// accomplished by grabbing a WgpuResourcesReadLock _before_ creating a wgpu::RenderPass, getting a
+/// WgpuResourcesRefs, and storing that in the pass.
+///
+/// This is only a problem because RwLockReadGuard.read() erases the guard's lifetime and creates a
+/// new anonymous lifetime. If you call RwLockReadGuard.read() during a pass, the reference will
+/// have an anonymous lifetime that lives for less than the pass, which violates the lifetime
+/// constraints in place.
+///
+/// The biggest implication of this design (other than the additional boilerplate here) is that
+/// beginning a render pass blocks writes to these resources. This means that if the pass attempts
+/// to write any resource, a deadlock will occur. WgpuResourceRefs only has immutable references, so
+/// the only way to make a deadlock happen is to access WgpuResources directly in the pass. It also
+/// means that other threads attempting to write resources will need to wait for pass encoding to
+/// finish. Almost all writes should occur before passes start, so this hopefully won't be a
+/// problem.
+///
+/// It is worth comparing the performance of this to transactional / copy-based approaches. This
+/// lock based design guarantees consistency, doesn't perform redundant allocations, and only blocks
+/// when a write is occurring. A copy based approach would never block, but would require more
+/// allocations / state-synchronization, which I expect will be more expensive. It would also be
+/// "eventually consistent" instead of "strongly consistent".
+///
+/// Single threaded implementations don't need to worry about these lifetimes constraints at all.
+/// RenderPasses can use a RenderContext's WgpuResources directly. RenderContext already has a
+/// lifetime greater than the RenderPass.
+#[derive(Debug)]
+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 render_pipelines: RwLockReadGuard<'a, HashMap<PipelineId, wgpu::RenderPipeline>>,
+    pub bind_groups: RwLockReadGuard<'a, HashMap<BindGroupDescriptorId, WgpuBindGroupInfo>>,
+    pub used_bind_group_sender: Sender<BindGroupId>,
+}
+
+impl<'a> WgpuResourcesReadLock<'a> {
+    pub fn refs(&'a self) -> WgpuResourceRefs<'a> {
+        WgpuResourceRefs {
+            buffers: &self.buffers,
+            textures: &self.textures,
+            swap_chain_frames: &self.swap_chain_frames,
+            render_pipelines: &self.render_pipelines,
+            bind_groups: &self.bind_groups,
+            used_bind_group_sender: &self.used_bind_group_sender,
+        }
+    }
+}
+
+/// Stores read only references to WgpuResource collections. See WgpuResourcesReadLock docs for
+/// context on why this exists
+#[derive(Debug)]
+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 render_pipelines: &'a HashMap<PipelineId, wgpu::RenderPipeline>,
+    pub bind_groups: &'a HashMap<BindGroupDescriptorId, WgpuBindGroupInfo>,
+    pub used_bind_group_sender: &'a Sender<BindGroupId>,
+}
+
+#[derive(Default, Clone, Debug)]
+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 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>>>,
+    pub samplers: Arc<RwLock<HashMap<SamplerId, wgpu::Sampler>>>,
+    pub shader_modules: Arc<RwLock<HashMap<ShaderId, wgpu::ShaderModule>>>,
+    pub render_pipelines: Arc<RwLock<HashMap<PipelineId, wgpu::RenderPipeline>>>,
+    pub bind_groups: Arc<RwLock<HashMap<BindGroupDescriptorId, WgpuBindGroupInfo>>>,
+    pub bind_group_layouts: Arc<RwLock<HashMap<BindGroupDescriptorId, wgpu::BindGroupLayout>>>,
+    pub bind_group_counter: BindGroupCounter,
+}
+
+impl WgpuResources {
+    pub fn read(&self) -> WgpuResourcesReadLock {
+        WgpuResourcesReadLock {
+            buffers: self.buffers.read(),
+            textures: self.texture_views.read(),
+            swap_chain_frames: self.swap_chain_frames.read(),
+            render_pipelines: self.render_pipelines.read(),
+            bind_groups: self.bind_groups.read(),
+            used_bind_group_sender: self.bind_group_counter.used_bind_group_sender.clone(),
+        }
+    }
+
+    pub fn has_bind_group(
+        &self,
+        bind_group_descriptor_id: BindGroupDescriptorId,
+        bind_group_id: BindGroupId,
+    ) -> bool {
+        if let Some(bind_group_info) = self.bind_groups.read().get(&bind_group_descriptor_id) {
+            bind_group_info.bind_groups.get(&bind_group_id).is_some()
+        } else {
+            false
+        }
+    }
+
+    pub fn remove_stale_bind_groups(&self) {
+        let mut bind_groups = self.bind_groups.write();
+        self.bind_group_counter
+            .remove_stale_bind_groups(&mut bind_groups);
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct BindGroupCounter {
+    pub used_bind_group_sender: Sender<BindGroupId>,
+    pub used_bind_group_receiver: Receiver<BindGroupId>,
+    pub bind_group_usage_counts: Arc<RwLock<HashMap<BindGroupId, u64>>>,
+}
+
+impl BindGroupCounter {
+    pub fn remove_stale_bind_groups(
+        &self,
+        bind_groups: &mut HashMap<BindGroupDescriptorId, WgpuBindGroupInfo>,
+    ) {
+        let mut bind_group_usage_counts = self.bind_group_usage_counts.write();
+        loop {
+            let bind_group = match self.used_bind_group_receiver.try_recv() {
+                Ok(bind_group) => bind_group,
+                Err(TryRecvError::Empty) => break,
+                Err(TryRecvError::Disconnected) => panic!("used bind group channel disconnected"),
+            };
+
+            let count = bind_group_usage_counts.entry(bind_group).or_insert(0);
+            // free every two frames
+            *count = 2;
+        }
+
+        for info in bind_groups.values_mut() {
+            info.bind_groups.retain(|id, _| {
+                let retain = {
+                    // if a value hasn't been counted yet, give it two frames of leeway
+                    let count = bind_group_usage_counts.entry(*id).or_insert(2);
+                    *count -= 1;
+                    *count > 0
+                };
+                if !retain {
+                    bind_group_usage_counts.remove(&id);
+                }
+
+                retain
+            })
+        }
+    }
+}
+
+impl Default for BindGroupCounter {
+    fn default() -> Self {
+        let (send, recv) = crossbeam_channel::unbounded();
+        BindGroupCounter {
+            used_bind_group_sender: send,
+            used_bind_group_receiver: recv,
+            bind_group_usage_counts: Default::default(),
+        }
+    }
+}
diff --git a/pipelined/bevy_wgpu2/src/type_converter.rs b/pipelined/bevy_wgpu2/src/type_converter.rs
new file mode 100644
index 0000000000..e57cdbf1db
--- /dev/null
+++ b/pipelined/bevy_wgpu2/src/type_converter.rs
@@ -0,0 +1,745 @@
+use crate::{WgpuFeature, WgpuFeatures, WgpuLimits};
+use bevy_render2::{
+    color::Color,
+    pass::{LoadOp, Operations},
+    pipeline::{
+        BindType, BlendFactor, BlendOperation, BlendState, ColorTargetState, ColorWrite,
+        CompareFunction, DepthBiasState, DepthStencilState, Face, FrontFace, IndexFormat,
+        InputStepMode, MultisampleState, PolygonMode, PrimitiveState, PrimitiveTopology,
+        StencilFaceState, StencilOperation, StencilState, VertexAttribute, VertexBufferLayout,
+        VertexFormat,
+    },
+    render_resource::{BufferUsage, SwapChainDescriptor},
+    texture::{
+        AddressMode, Extent3d, FilterMode, SamplerBorderColor, SamplerDescriptor,
+        StorageTextureAccess, TextureDescriptor, TextureDimension, TextureFormat,
+        TextureSampleType, TextureUsage, TextureViewDimension,
+    },
+};
+use bevy_window::Window;
+use wgpu::BufferBindingType;
+
+pub trait WgpuFrom<T> {
+    fn from(val: T) -> Self;
+}
+
+pub trait WgpuInto<U> {
+    fn wgpu_into(self) -> U;
+}
+
+impl<T, U> WgpuInto<U> for T
+where
+    U: WgpuFrom<T>,
+{
+    fn wgpu_into(self) -> U {
+        U::from(self)
+    }
+}
+
+impl WgpuFrom<VertexFormat> for wgpu::VertexFormat {
+    fn from(val: VertexFormat) -> Self {
+        match val {
+            VertexFormat::Uint8x2 => wgpu::VertexFormat::Uint8x2,
+            VertexFormat::Uint8x4 => wgpu::VertexFormat::Uint8x4,
+            VertexFormat::Sint8x2 => wgpu::VertexFormat::Sint8x2,
+            VertexFormat::Sint8x4 => wgpu::VertexFormat::Sint8x4,
+            VertexFormat::Unorm8x2 => wgpu::VertexFormat::Unorm8x2,
+            VertexFormat::Unorm8x4 => wgpu::VertexFormat::Unorm8x4,
+            VertexFormat::Snorm8x2 => wgpu::VertexFormat::Snorm8x2,
+            VertexFormat::Snorm8x4 => wgpu::VertexFormat::Snorm8x4,
+            VertexFormat::Uint16x2 => wgpu::VertexFormat::Uint16x2,
+            VertexFormat::Uint16x4 => wgpu::VertexFormat::Uint16x4,
+            VertexFormat::Sint16x2 => wgpu::VertexFormat::Sint16x2,
+            VertexFormat::Sint16x4 => wgpu::VertexFormat::Sint16x4,
+            VertexFormat::Unorm16x2 => wgpu::VertexFormat::Unorm16x2,
+            VertexFormat::Unorm16x4 => wgpu::VertexFormat::Unorm16x4,
+            VertexFormat::Snorm16x2 => wgpu::VertexFormat::Snorm16x2,
+            VertexFormat::Snorm16x4 => wgpu::VertexFormat::Snorm16x4,
+            VertexFormat::Float16x2 => wgpu::VertexFormat::Float16x2,
+            VertexFormat::Float16x4 => wgpu::VertexFormat::Float16x4,
+            VertexFormat::Float32 => wgpu::VertexFormat::Float32,
+            VertexFormat::Float32x2 => wgpu::VertexFormat::Float32x2,
+            VertexFormat::Float32x3 => wgpu::VertexFormat::Float32x3,
+            VertexFormat::Float32x4 => wgpu::VertexFormat::Float32x4,
+            VertexFormat::Uint32 => wgpu::VertexFormat::Uint32,
+            VertexFormat::Uint32x2 => wgpu::VertexFormat::Uint32x2,
+            VertexFormat::Uint32x3 => wgpu::VertexFormat::Uint32x3,
+            VertexFormat::Uint32x4 => wgpu::VertexFormat::Uint32x4,
+            VertexFormat::Sint32 => wgpu::VertexFormat::Sint32,
+            VertexFormat::Sint32x2 => wgpu::VertexFormat::Sint32x2,
+            VertexFormat::Sint32x3 => wgpu::VertexFormat::Sint32x3,
+            VertexFormat::Sint32x4 => wgpu::VertexFormat::Sint32x4,
+        }
+    }
+}
+
+impl WgpuFrom<&VertexAttribute> for wgpu::VertexAttribute {
+    fn from(val: &VertexAttribute) -> Self {
+        wgpu::VertexAttribute {
+            format: val.format.wgpu_into(),
+            offset: val.offset,
+            shader_location: val.shader_location,
+        }
+    }
+}
+
+impl WgpuFrom<InputStepMode> for wgpu::InputStepMode {
+    fn from(val: InputStepMode) -> Self {
+        match val {
+            InputStepMode::Vertex => wgpu::InputStepMode::Vertex,
+            InputStepMode::Instance => wgpu::InputStepMode::Instance,
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct OwnedWgpuVertexBufferLayout {
+    pub array_stride: wgpu::BufferAddress,
+    pub step_mode: wgpu::InputStepMode,
+    pub attributes: Vec<wgpu::VertexAttribute>,
+}
+
+impl WgpuFrom<&VertexBufferLayout> for OwnedWgpuVertexBufferLayout {
+    fn from(val: &VertexBufferLayout) -> OwnedWgpuVertexBufferLayout {
+        let attributes = val
+            .attributes
+            .iter()
+            .map(|a| a.wgpu_into())
+            .collect::<Vec<wgpu::VertexAttribute>>();
+
+        OwnedWgpuVertexBufferLayout {
+            step_mode: val.step_mode.wgpu_into(),
+            array_stride: val.stride,
+            attributes,
+        }
+    }
+}
+
+impl<'a> From<&'a OwnedWgpuVertexBufferLayout> for wgpu::VertexBufferLayout<'a> {
+    fn from(val: &'a OwnedWgpuVertexBufferLayout) -> Self {
+        wgpu::VertexBufferLayout {
+            attributes: &val.attributes,
+            step_mode: val.step_mode,
+            array_stride: val.array_stride,
+        }
+    }
+}
+
+impl WgpuFrom<Color> for wgpu::Color {
+    fn from(color: Color) -> Self {
+        let linear = color.as_linear_rgba_f32();
+        wgpu::Color {
+            r: linear[0] as f64,
+            g: linear[1] as f64,
+            b: linear[2] as f64,
+            a: linear[3] as f64,
+        }
+    }
+}
+
+impl WgpuFrom<BufferUsage> for wgpu::BufferUsage {
+    fn from(val: BufferUsage) -> Self {
+        wgpu::BufferUsage::from_bits(val.bits()).unwrap()
+    }
+}
+
+impl WgpuFrom<&LoadOp<Color>> for wgpu::LoadOp<wgpu::Color> {
+    fn from(val: &LoadOp<Color>) -> Self {
+        match val {
+            LoadOp::Clear(value) => wgpu::LoadOp::Clear((*value).wgpu_into()),
+            LoadOp::Load => wgpu::LoadOp::Load,
+        }
+    }
+}
+
+impl WgpuFrom<&LoadOp<f32>> for wgpu::LoadOp<f32> {
+    fn from(val: &LoadOp<f32>) -> Self {
+        match val {
+            LoadOp::Clear(value) => wgpu::LoadOp::Clear(*value),
+            LoadOp::Load => wgpu::LoadOp::Load,
+        }
+    }
+}
+
+impl WgpuFrom<&LoadOp<u32>> for wgpu::LoadOp<u32> {
+    fn from(val: &LoadOp<u32>) -> Self {
+        match val {
+            LoadOp::Clear(value) => wgpu::LoadOp::Clear(*value),
+            LoadOp::Load => wgpu::LoadOp::Load,
+        }
+    }
+}
+
+impl<'a, T, U> WgpuFrom<&'a Operations<T>> for wgpu::Operations<U>
+where
+    wgpu::LoadOp<U>: WgpuFrom<&'a LoadOp<T>>,
+{
+    fn from(val: &'a Operations<T>) -> Self {
+        Self {
+            load: (&val.load).wgpu_into(),
+            store: val.store,
+        }
+    }
+}
+
+impl WgpuFrom<&BindType> for wgpu::BindingType {
+    fn from(bind_type: &BindType) -> Self {
+        match bind_type {
+            BindType::Uniform {
+                has_dynamic_offset, ..
+            } => 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),
+            },
+            BindType::StorageBuffer {
+                has_dynamic_offset,
+                readonly,
+            } => wgpu::BindingType::Buffer {
+                ty: BufferBindingType::Storage {
+                    read_only: *readonly,
+                },
+                has_dynamic_offset: *has_dynamic_offset,
+                min_binding_size: bind_type.get_uniform_size().and_then(wgpu::BufferSize::new),
+            },
+            BindType::Texture {
+                view_dimension,
+                multisampled,
+                sample_type,
+            } => wgpu::BindingType::Texture {
+                view_dimension: (*view_dimension).wgpu_into(),
+                multisampled: *multisampled,
+                sample_type: (*sample_type).wgpu_into(),
+            },
+            BindType::Sampler {
+                comparison,
+                filtering,
+            } => wgpu::BindingType::Sampler {
+                filtering: *filtering,
+                comparison: *comparison,
+            },
+            BindType::StorageTexture {
+                view_dimension,
+                format,
+                access,
+            } => wgpu::BindingType::StorageTexture {
+                access: (*access).wgpu_into(),
+                view_dimension: (*view_dimension).wgpu_into(),
+                format: (*format).wgpu_into(),
+            },
+        }
+    }
+}
+
+impl WgpuFrom<TextureSampleType> for wgpu::TextureSampleType {
+    fn from(texture_component_type: TextureSampleType) -> Self {
+        match texture_component_type {
+            TextureSampleType::Float { filterable } => {
+                wgpu::TextureSampleType::Float { filterable }
+            }
+            TextureSampleType::Sint => wgpu::TextureSampleType::Sint,
+            TextureSampleType::Uint => wgpu::TextureSampleType::Uint,
+            TextureSampleType::Depth => wgpu::TextureSampleType::Depth,
+        }
+    }
+}
+
+impl WgpuFrom<StorageTextureAccess> for wgpu::StorageTextureAccess {
+    fn from(storage_texture_access: StorageTextureAccess) -> Self {
+        match storage_texture_access {
+            StorageTextureAccess::ReadOnly => wgpu::StorageTextureAccess::ReadOnly,
+            StorageTextureAccess::WriteOnly => wgpu::StorageTextureAccess::WriteOnly,
+            StorageTextureAccess::ReadWrite => wgpu::StorageTextureAccess::ReadWrite,
+        }
+    }
+}
+
+impl WgpuFrom<Extent3d> for wgpu::Extent3d {
+    fn from(val: Extent3d) -> Self {
+        wgpu::Extent3d {
+            height: val.height,
+            width: val.width,
+            depth_or_array_layers: val.depth_or_array_layers,
+        }
+    }
+}
+
+impl WgpuFrom<&TextureDescriptor> for wgpu::TextureDescriptor<'_> {
+    fn from(texture_descriptor: &TextureDescriptor) -> Self {
+        wgpu::TextureDescriptor {
+            label: None,
+            size: texture_descriptor.size.wgpu_into(),
+            mip_level_count: texture_descriptor.mip_level_count,
+            sample_count: texture_descriptor.sample_count,
+            dimension: texture_descriptor.dimension.wgpu_into(),
+            format: texture_descriptor.format.wgpu_into(),
+            usage: texture_descriptor.usage.wgpu_into(),
+        }
+    }
+}
+
+impl WgpuFrom<TextureViewDimension> for wgpu::TextureViewDimension {
+    fn from(dimension: TextureViewDimension) -> Self {
+        match dimension {
+            TextureViewDimension::D1 => wgpu::TextureViewDimension::D1,
+            TextureViewDimension::D2 => wgpu::TextureViewDimension::D2,
+            TextureViewDimension::D2Array => wgpu::TextureViewDimension::D2Array,
+            TextureViewDimension::Cube => wgpu::TextureViewDimension::Cube,
+            TextureViewDimension::CubeArray => wgpu::TextureViewDimension::CubeArray,
+            TextureViewDimension::D3 => wgpu::TextureViewDimension::D3,
+        }
+    }
+}
+
+impl WgpuFrom<TextureDimension> for wgpu::TextureDimension {
+    fn from(dimension: TextureDimension) -> Self {
+        match dimension {
+            TextureDimension::D1 => wgpu::TextureDimension::D1,
+            TextureDimension::D2 => wgpu::TextureDimension::D2,
+            TextureDimension::D3 => wgpu::TextureDimension::D3,
+        }
+    }
+}
+
+impl WgpuFrom<TextureFormat> for wgpu::TextureFormat {
+    fn from(val: TextureFormat) -> Self {
+        match val {
+            TextureFormat::R8Unorm => wgpu::TextureFormat::R8Unorm,
+            TextureFormat::R8Snorm => wgpu::TextureFormat::R8Snorm,
+            TextureFormat::R8Uint => wgpu::TextureFormat::R8Uint,
+            TextureFormat::R8Sint => wgpu::TextureFormat::R8Sint,
+            TextureFormat::R16Uint => wgpu::TextureFormat::R16Uint,
+            TextureFormat::R16Sint => wgpu::TextureFormat::R16Sint,
+            TextureFormat::R16Float => wgpu::TextureFormat::R16Float,
+            TextureFormat::Rg8Unorm => wgpu::TextureFormat::Rg8Unorm,
+            TextureFormat::Rg8Snorm => wgpu::TextureFormat::Rg8Snorm,
+            TextureFormat::Rg8Uint => wgpu::TextureFormat::Rg8Uint,
+            TextureFormat::Rg8Sint => wgpu::TextureFormat::Rg8Sint,
+            TextureFormat::R32Uint => wgpu::TextureFormat::R32Uint,
+            TextureFormat::R32Sint => wgpu::TextureFormat::R32Sint,
+            TextureFormat::R32Float => wgpu::TextureFormat::R32Float,
+            TextureFormat::Rg16Uint => wgpu::TextureFormat::Rg16Uint,
+            TextureFormat::Rg16Sint => wgpu::TextureFormat::Rg16Sint,
+            TextureFormat::Rg16Float => wgpu::TextureFormat::Rg16Float,
+            TextureFormat::Rgba8Unorm => wgpu::TextureFormat::Rgba8Unorm,
+            TextureFormat::Rgba8UnormSrgb => wgpu::TextureFormat::Rgba8UnormSrgb,
+            TextureFormat::Rgba8Snorm => wgpu::TextureFormat::Rgba8Snorm,
+            TextureFormat::Rgba8Uint => wgpu::TextureFormat::Rgba8Uint,
+            TextureFormat::Rgba8Sint => wgpu::TextureFormat::Rgba8Sint,
+            TextureFormat::Bgra8Unorm => wgpu::TextureFormat::Bgra8Unorm,
+            TextureFormat::Bgra8UnormSrgb => wgpu::TextureFormat::Bgra8UnormSrgb,
+            TextureFormat::Rgb10a2Unorm => wgpu::TextureFormat::Rgb10a2Unorm,
+            TextureFormat::Rg11b10Float => wgpu::TextureFormat::Rg11b10Float,
+            TextureFormat::Rg32Uint => wgpu::TextureFormat::Rg32Uint,
+            TextureFormat::Rg32Sint => wgpu::TextureFormat::Rg32Sint,
+            TextureFormat::Rg32Float => wgpu::TextureFormat::Rg32Float,
+            TextureFormat::Rgba16Uint => wgpu::TextureFormat::Rgba16Uint,
+            TextureFormat::Rgba16Sint => wgpu::TextureFormat::Rgba16Sint,
+            TextureFormat::Rgba16Float => wgpu::TextureFormat::Rgba16Float,
+            TextureFormat::Rgba32Uint => wgpu::TextureFormat::Rgba32Uint,
+            TextureFormat::Rgba32Sint => wgpu::TextureFormat::Rgba32Sint,
+            TextureFormat::Rgba32Float => wgpu::TextureFormat::Rgba32Float,
+            TextureFormat::Depth32Float => wgpu::TextureFormat::Depth32Float,
+            TextureFormat::Depth24Plus => wgpu::TextureFormat::Depth24Plus,
+            TextureFormat::Depth24PlusStencil8 => wgpu::TextureFormat::Depth24PlusStencil8,
+        }
+    }
+}
+
+impl WgpuFrom<TextureUsage> for wgpu::TextureUsage {
+    fn from(val: TextureUsage) -> Self {
+        wgpu::TextureUsage::from_bits(val.bits()).unwrap()
+    }
+}
+
+impl WgpuFrom<&StencilState> for wgpu::StencilState {
+    fn from(val: &StencilState) -> Self {
+        wgpu::StencilState {
+            back: (&val.back).wgpu_into(),
+            front: (&val.front).wgpu_into(),
+            read_mask: val.read_mask,
+            write_mask: val.write_mask,
+        }
+    }
+}
+
+impl WgpuFrom<DepthStencilState> for wgpu::DepthStencilState {
+    fn from(val: DepthStencilState) -> Self {
+        wgpu::DepthStencilState {
+            depth_compare: val.depth_compare.wgpu_into(),
+            depth_write_enabled: val.depth_write_enabled,
+            format: val.format.wgpu_into(),
+            stencil: (&val.stencil).wgpu_into(),
+            bias: val.bias.wgpu_into(),
+        }
+    }
+}
+
+impl WgpuFrom<MultisampleState> for wgpu::MultisampleState {
+    fn from(val: MultisampleState) -> Self {
+        wgpu::MultisampleState {
+            count: val.count,
+            mask: val.mask,
+            alpha_to_coverage_enabled: val.alpha_to_coverage_enabled,
+        }
+    }
+}
+
+impl WgpuFrom<&StencilFaceState> for wgpu::StencilFaceState {
+    fn from(val: &StencilFaceState) -> Self {
+        wgpu::StencilFaceState {
+            compare: val.compare.wgpu_into(),
+            depth_fail_op: val.depth_fail_op.wgpu_into(),
+            fail_op: val.fail_op.wgpu_into(),
+            pass_op: val.pass_op.wgpu_into(),
+        }
+    }
+}
+
+impl WgpuFrom<CompareFunction> for wgpu::CompareFunction {
+    fn from(val: CompareFunction) -> Self {
+        match val {
+            CompareFunction::Never => wgpu::CompareFunction::Never,
+            CompareFunction::Less => wgpu::CompareFunction::Less,
+            CompareFunction::Equal => wgpu::CompareFunction::Equal,
+            CompareFunction::LessEqual => wgpu::CompareFunction::LessEqual,
+            CompareFunction::Greater => wgpu::CompareFunction::Greater,
+            CompareFunction::NotEqual => wgpu::CompareFunction::NotEqual,
+            CompareFunction::GreaterEqual => wgpu::CompareFunction::GreaterEqual,
+            CompareFunction::Always => wgpu::CompareFunction::Always,
+        }
+    }
+}
+
+static COMPARE_FUNCTION_NEVER: &wgpu::CompareFunction = &wgpu::CompareFunction::Never;
+static COMPARE_FUNCTION_LESS: &wgpu::CompareFunction = &wgpu::CompareFunction::Less;
+static COMPARE_FUNCTION_EQUAL: &wgpu::CompareFunction = &wgpu::CompareFunction::Equal;
+static COMPARE_FUNCTION_LESSEQUAL: &wgpu::CompareFunction = &wgpu::CompareFunction::LessEqual;
+static COMPARE_FUNCTION_GREATER: &wgpu::CompareFunction = &wgpu::CompareFunction::Greater;
+static COMPARE_FUNCTION_NOTEQUAL: &wgpu::CompareFunction = &wgpu::CompareFunction::NotEqual;
+static COMPARE_FUNCTION_GREATEREQUAL: &wgpu::CompareFunction = &wgpu::CompareFunction::GreaterEqual;
+static COMPARE_FUNCTION_ALWAYS: &wgpu::CompareFunction = &wgpu::CompareFunction::Always;
+
+impl WgpuFrom<CompareFunction> for &'static wgpu::CompareFunction {
+    fn from(val: CompareFunction) -> Self {
+        match val {
+            CompareFunction::Never => COMPARE_FUNCTION_NEVER,
+            CompareFunction::Less => COMPARE_FUNCTION_LESS,
+            CompareFunction::Equal => COMPARE_FUNCTION_EQUAL,
+            CompareFunction::LessEqual => COMPARE_FUNCTION_LESSEQUAL,
+            CompareFunction::Greater => COMPARE_FUNCTION_GREATER,
+            CompareFunction::NotEqual => COMPARE_FUNCTION_NOTEQUAL,
+            CompareFunction::GreaterEqual => COMPARE_FUNCTION_GREATEREQUAL,
+            CompareFunction::Always => COMPARE_FUNCTION_ALWAYS,
+        }
+    }
+}
+
+impl WgpuFrom<StencilOperation> for wgpu::StencilOperation {
+    fn from(val: StencilOperation) -> Self {
+        match val {
+            StencilOperation::Keep => wgpu::StencilOperation::Keep,
+            StencilOperation::Zero => wgpu::StencilOperation::Zero,
+            StencilOperation::Replace => wgpu::StencilOperation::Replace,
+            StencilOperation::Invert => wgpu::StencilOperation::Invert,
+            StencilOperation::IncrementClamp => wgpu::StencilOperation::IncrementClamp,
+            StencilOperation::DecrementClamp => wgpu::StencilOperation::DecrementClamp,
+            StencilOperation::IncrementWrap => wgpu::StencilOperation::IncrementWrap,
+            StencilOperation::DecrementWrap => wgpu::StencilOperation::DecrementWrap,
+        }
+    }
+}
+
+impl WgpuFrom<PrimitiveTopology> for wgpu::PrimitiveTopology {
+    fn from(val: PrimitiveTopology) -> Self {
+        match val {
+            PrimitiveTopology::PointList => wgpu::PrimitiveTopology::PointList,
+            PrimitiveTopology::LineList => wgpu::PrimitiveTopology::LineList,
+            PrimitiveTopology::LineStrip => wgpu::PrimitiveTopology::LineStrip,
+            PrimitiveTopology::TriangleList => wgpu::PrimitiveTopology::TriangleList,
+            PrimitiveTopology::TriangleStrip => wgpu::PrimitiveTopology::TriangleStrip,
+        }
+    }
+}
+
+impl WgpuFrom<FrontFace> for wgpu::FrontFace {
+    fn from(val: FrontFace) -> Self {
+        match val {
+            FrontFace::Ccw => wgpu::FrontFace::Ccw,
+            FrontFace::Cw => wgpu::FrontFace::Cw,
+        }
+    }
+}
+
+impl WgpuFrom<Face> for wgpu::Face {
+    fn from(val: Face) -> Self {
+        match val {
+            Face::Front => wgpu::Face::Front,
+            Face::Back => wgpu::Face::Back,
+        }
+    }
+}
+
+impl WgpuFrom<PolygonMode> for wgpu::PolygonMode {
+    fn from(val: PolygonMode) -> wgpu::PolygonMode {
+        match val {
+            PolygonMode::Fill => wgpu::PolygonMode::Fill,
+            PolygonMode::Line => wgpu::PolygonMode::Line,
+            PolygonMode::Point => wgpu::PolygonMode::Point,
+        }
+    }
+}
+
+impl WgpuFrom<DepthBiasState> for wgpu::DepthBiasState {
+    fn from(val: DepthBiasState) -> Self {
+        wgpu::DepthBiasState {
+            constant: val.constant,
+            slope_scale: val.slope_scale,
+            clamp: val.clamp,
+        }
+    }
+}
+
+impl WgpuFrom<&ColorTargetState> for wgpu::ColorTargetState {
+    fn from(val: &ColorTargetState) -> Self {
+        wgpu::ColorTargetState {
+            format: val.format.wgpu_into(),
+            write_mask: val.write_mask.wgpu_into(),
+            blend: val.blend.map(|blend| blend.wgpu_into()),
+        }
+    }
+}
+
+impl WgpuFrom<PrimitiveState> for wgpu::PrimitiveState {
+    fn from(val: PrimitiveState) -> Self {
+        wgpu::PrimitiveState {
+            topology: val.topology.wgpu_into(),
+            strip_index_format: val
+                .strip_index_format
+                .map(|index_format| index_format.wgpu_into()),
+            front_face: val.front_face.wgpu_into(),
+            cull_mode: val.cull_mode.map(|face| face.wgpu_into()),
+            polygon_mode: val.polygon_mode.wgpu_into(),
+            clamp_depth: val.clamp_depth,
+            conservative: val.conservative,
+        }
+    }
+}
+
+impl WgpuFrom<ColorWrite> for wgpu::ColorWrite {
+    fn from(val: ColorWrite) -> Self {
+        wgpu::ColorWrite::from_bits(val.bits()).unwrap()
+    }
+}
+
+impl WgpuFrom<BlendState> for wgpu::BlendState {
+    fn from(val: BlendState) -> Self {
+        wgpu::BlendState {
+            color: wgpu::BlendComponent {
+                src_factor: val.color.src_factor.wgpu_into(),
+                dst_factor: val.color.dst_factor.wgpu_into(),
+                operation: val.color.operation.wgpu_into(),
+            },
+            alpha: wgpu::BlendComponent {
+                src_factor: val.alpha.src_factor.wgpu_into(),
+                dst_factor: val.alpha.dst_factor.wgpu_into(),
+                operation: val.alpha.operation.wgpu_into(),
+            },
+        }
+    }
+}
+
+impl WgpuFrom<BlendFactor> for wgpu::BlendFactor {
+    fn from(val: BlendFactor) -> Self {
+        match val {
+            BlendFactor::Zero => wgpu::BlendFactor::Zero,
+            BlendFactor::One => wgpu::BlendFactor::One,
+            BlendFactor::Src => wgpu::BlendFactor::Src,
+            BlendFactor::OneMinusSrc => wgpu::BlendFactor::OneMinusSrc,
+            BlendFactor::SrcAlpha => wgpu::BlendFactor::SrcAlpha,
+            BlendFactor::OneMinusSrcAlpha => wgpu::BlendFactor::OneMinusSrcAlpha,
+            BlendFactor::Dst => wgpu::BlendFactor::Dst,
+            BlendFactor::OneMinusDst => wgpu::BlendFactor::OneMinusDst,
+            BlendFactor::DstAlpha => wgpu::BlendFactor::DstAlpha,
+            BlendFactor::OneMinusDstAlpha => wgpu::BlendFactor::OneMinusDstAlpha,
+            BlendFactor::SrcAlphaSaturated => wgpu::BlendFactor::SrcAlphaSaturated,
+            BlendFactor::Constant => wgpu::BlendFactor::Constant,
+            BlendFactor::OneMinusConstant => wgpu::BlendFactor::OneMinusConstant,
+        }
+    }
+}
+
+impl WgpuFrom<BlendOperation> for wgpu::BlendOperation {
+    fn from(val: BlendOperation) -> Self {
+        match val {
+            BlendOperation::Add => wgpu::BlendOperation::Add,
+            BlendOperation::Subtract => wgpu::BlendOperation::Subtract,
+            BlendOperation::ReverseSubtract => wgpu::BlendOperation::ReverseSubtract,
+            BlendOperation::Min => wgpu::BlendOperation::Min,
+            BlendOperation::Max => wgpu::BlendOperation::Max,
+        }
+    }
+}
+
+impl WgpuFrom<IndexFormat> for wgpu::IndexFormat {
+    fn from(val: IndexFormat) -> Self {
+        match val {
+            IndexFormat::Uint16 => wgpu::IndexFormat::Uint16,
+            IndexFormat::Uint32 => wgpu::IndexFormat::Uint32,
+        }
+    }
+}
+
+impl WgpuFrom<SamplerDescriptor> for wgpu::SamplerDescriptor<'_> {
+    fn from(sampler_descriptor: SamplerDescriptor) -> Self {
+        wgpu::SamplerDescriptor {
+            label: None,
+            address_mode_u: sampler_descriptor.address_mode_u.wgpu_into(),
+            address_mode_v: sampler_descriptor.address_mode_v.wgpu_into(),
+            address_mode_w: sampler_descriptor.address_mode_w.wgpu_into(),
+            mag_filter: sampler_descriptor.mag_filter.wgpu_into(),
+            min_filter: sampler_descriptor.min_filter.wgpu_into(),
+            mipmap_filter: sampler_descriptor.mipmap_filter.wgpu_into(),
+            lod_min_clamp: sampler_descriptor.lod_min_clamp,
+            lod_max_clamp: sampler_descriptor.lod_max_clamp,
+            compare: sampler_descriptor.compare_function.map(|c| c.wgpu_into()),
+            anisotropy_clamp: sampler_descriptor.anisotropy_clamp,
+            border_color: sampler_descriptor
+                .border_color
+                .map(|border_color| border_color.wgpu_into()),
+        }
+    }
+}
+
+impl WgpuFrom<AddressMode> for wgpu::AddressMode {
+    fn from(val: AddressMode) -> Self {
+        match val {
+            AddressMode::ClampToEdge => wgpu::AddressMode::ClampToEdge,
+            AddressMode::Repeat => wgpu::AddressMode::Repeat,
+            AddressMode::MirrorRepeat => wgpu::AddressMode::MirrorRepeat,
+        }
+    }
+}
+
+impl WgpuFrom<FilterMode> for wgpu::FilterMode {
+    fn from(val: FilterMode) -> Self {
+        match val {
+            FilterMode::Nearest => wgpu::FilterMode::Nearest,
+            FilterMode::Linear => wgpu::FilterMode::Linear,
+        }
+    }
+}
+
+impl WgpuFrom<SamplerBorderColor> for wgpu::SamplerBorderColor {
+    fn from(val: SamplerBorderColor) -> Self {
+        match val {
+            SamplerBorderColor::TransparentBlack => wgpu::SamplerBorderColor::TransparentBlack,
+            SamplerBorderColor::OpaqueBlack => wgpu::SamplerBorderColor::OpaqueBlack,
+            SamplerBorderColor::OpaqueWhite => wgpu::SamplerBorderColor::OpaqueWhite,
+        }
+    }
+}
+
+impl WgpuFrom<&Window> for wgpu::SwapChainDescriptor {
+    fn from(window: &Window) -> Self {
+        wgpu::SwapChainDescriptor {
+            usage: wgpu::TextureUsage::RENDER_ATTACHMENT,
+            format: TextureFormat::default().wgpu_into(),
+            width: window.physical_width(),
+            height: window.physical_height(),
+            present_mode: if window.vsync() {
+                wgpu::PresentMode::Fifo
+            } else {
+                wgpu::PresentMode::Immediate
+            },
+        }
+    }
+}
+
+impl WgpuFrom<&SwapChainDescriptor> for wgpu::SwapChainDescriptor {
+    fn from(descriptor: &SwapChainDescriptor) -> Self {
+        wgpu::SwapChainDescriptor {
+            usage: wgpu::TextureUsage::RENDER_ATTACHMENT,
+            format: TextureFormat::default().wgpu_into(),
+            width: descriptor.width,
+            height: descriptor.height,
+            present_mode: if descriptor.vsync {
+                wgpu::PresentMode::Fifo
+            } else {
+                wgpu::PresentMode::Immediate
+            },
+        }
+    }
+}
+
+impl WgpuFrom<WgpuFeature> for wgpu::Features {
+    fn from(value: WgpuFeature) -> Self {
+        match value {
+            WgpuFeature::DepthClamping => wgpu::Features::DEPTH_CLAMPING,
+            WgpuFeature::TextureCompressionBc => wgpu::Features::TEXTURE_COMPRESSION_BC,
+            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::TextureCompressionEtc2 => wgpu::Features::TEXTURE_COMPRESSION_ETC2,
+            WgpuFeature::TextureCompressionAstcLdr => wgpu::Features::TEXTURE_COMPRESSION_ASTC_LDR,
+            WgpuFeature::TextureAdapterSpecificFormatFeatures => {
+                wgpu::Features::TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES
+            }
+            WgpuFeature::ShaderFloat64 => wgpu::Features::SHADER_FLOAT64,
+            WgpuFeature::VertexAttribute64Bit => wgpu::Features::VERTEX_ATTRIBUTE_64BIT,
+        }
+    }
+}
+
+impl WgpuFrom<WgpuFeatures> for wgpu::Features {
+    fn from(features: WgpuFeatures) -> Self {
+        features
+            .features
+            .iter()
+            .fold(wgpu::Features::empty(), |wgpu_features, feature| {
+                wgpu_features | (*feature).wgpu_into()
+            })
+    }
+}
+
+impl WgpuFrom<WgpuLimits> for wgpu::Limits {
+    fn from(val: WgpuLimits) -> Self {
+        wgpu::Limits {
+            max_bind_groups: val.max_bind_groups,
+            max_dynamic_uniform_buffers_per_pipeline_layout: val
+                .max_dynamic_uniform_buffers_per_pipeline_layout,
+            max_dynamic_storage_buffers_per_pipeline_layout: val
+                .max_dynamic_storage_buffers_per_pipeline_layout,
+            max_sampled_textures_per_shader_stage: val.max_sampled_textures_per_shader_stage,
+            max_samplers_per_shader_stage: val.max_samplers_per_shader_stage,
+            max_storage_buffers_per_shader_stage: val.max_storage_buffers_per_shader_stage,
+            max_storage_textures_per_shader_stage: val.max_storage_textures_per_shader_stage,
+            max_uniform_buffers_per_shader_stage: val.max_uniform_buffers_per_shader_stage,
+            max_uniform_buffer_binding_size: val.max_uniform_buffer_binding_size,
+            max_push_constant_size: val.max_push_constant_size,
+            max_texture_dimension_1d: val.max_texture_dimension_1d,
+            max_texture_dimension_2d: val.max_texture_dimension_2d,
+            max_texture_dimension_3d: val.max_texture_dimension_3d,
+            max_texture_array_layers: val.max_texture_array_layers,
+            max_storage_buffer_binding_size: val.max_storage_buffer_binding_size,
+            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,
+        }
+    }
+}
diff --git a/pipelined/changes.md b/pipelined/changes.md
new file mode 100644
index 0000000000..bd374ca125
--- /dev/null
+++ b/pipelined/changes.md
@@ -0,0 +1,10 @@
+* Remove AppBuilder
+* Add SubApps
+* `Res<Box<dyn RenderResourceContext>>` -> `Res<RenderResources>`
+* Removed RenderResourceBindings
+* Made shaders and pipelines proper render resources (removes dependency on bevy_asset and is generally a cleaner api)
+* Removed RenderResources / RenderResource traits
+* Decoupled swap chain from Window in Renderer api
+* Removed RenderResourceBindings
+* Removed asset tracking from render resources
+* Removed cruft from RenderResource api
\ No newline at end of file
diff --git a/src/lib.rs b/src/lib.rs
index dc2e9ef25a..cf314d3e20 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -15,7 +15,7 @@
 //! use bevy::prelude::*;
 //!
 //! fn main() {
-//!    App::build()
+//!    App::new()
 //!        .add_system(hello_world_system.system())
 //!        .run();
 //! }