diff --git a/crates/bevy_derive/src/id.rs b/crates/bevy_derive/src/id.rs
new file mode 100644
index 0000000000000..41f06842d1c5b
--- /dev/null
+++ b/crates/bevy_derive/src/id.rs
@@ -0,0 +1,26 @@
+use proc_macro::TokenStream;
+use quote::quote;
+use syn::{parse_macro_input, DeriveInput};
+
+pub fn derive_id(input: TokenStream) -> TokenStream {
+    let ast = parse_macro_input!(input as DeriveInput);
+
+    let struct_name = &ast.ident;
+    let error_message = format!("The system ran out of unique `{}`s.", struct_name);
+    let (_impl_generics, type_generics, where_clause) = &ast.generics.split_for_impl();
+
+    TokenStream::from(quote! {
+        impl #struct_name #type_generics #where_clause {
+            pub fn new() -> Self {
+                use std::sync::atomic::{AtomicU64, Ordering};
+                static COUNTER: AtomicU64 = AtomicU64::new(0);
+                COUNTER
+                    .fetch_update(Ordering::Relaxed, Ordering::Relaxed, |val| {
+                        val.checked_add(1)
+                    })
+                    .map(Self)
+                    .expect(#error_message)
+            }
+        }
+    })
+}
diff --git a/crates/bevy_derive/src/lib.rs b/crates/bevy_derive/src/lib.rs
index 7f21428fc2a7a..c7dea3cba041e 100644
--- a/crates/bevy_derive/src/lib.rs
+++ b/crates/bevy_derive/src/lib.rs
@@ -4,6 +4,7 @@ mod app_plugin;
 mod bevy_main;
 mod bytes;
 mod enum_variant_meta;
+mod id;
 mod modules;
 mod render_resource;
 mod render_resources;
@@ -70,3 +71,8 @@ pub fn derive_app_label(input: TokenStream) -> TokenStream {
     trait_path.segments.push(format_ident!("AppLabel").into());
     derive_label(input, trait_path)
 }
+
+#[proc_macro_derive(Id)]
+pub fn derive_id(input: TokenStream) -> TokenStream {
+    id::derive_id(input)
+}
diff --git a/crates/bevy_ecs/src/system/system.rs b/crates/bevy_ecs/src/system/system.rs
index eabf476730340..d33d513f86998 100644
--- a/crates/bevy_ecs/src/system/system.rs
+++ b/crates/bevy_ecs/src/system/system.rs
@@ -1,4 +1,4 @@
-use bevy_utils::tracing::warn;
+use bevy_utils::{tracing::warn, Id, IdType};
 
 use crate::{
     archetype::{Archetype, ArchetypeComponentId},
@@ -9,16 +9,8 @@ use crate::{
 use std::borrow::Cow;
 
 /// A [`System`] identifier.
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-pub struct SystemId(pub usize);
-
-impl SystemId {
-    /// Creates a new random `SystemId`.
-    #[allow(clippy::new_without_default)]
-    pub fn new() -> Self {
-        SystemId(rand::random::<usize>())
-    }
-}
+#[derive(Id, Copy, Clone, Hash, Eq, PartialEq, Debug)]
+pub struct SystemId(IdType);
 
 /// An ECS system that can be added to a [Schedule](crate::schedule::Schedule)
 ///
diff --git a/crates/bevy_ecs/src/world/mod.rs b/crates/bevy_ecs/src/world/mod.rs
index f4a542b7f13a6..08bbe65ec970f 100644
--- a/crates/bevy_ecs/src/world/mod.rs
+++ b/crates/bevy_ecs/src/world/mod.rs
@@ -19,18 +19,19 @@ use crate::{
     query::{FilterFetch, QueryState, WorldQuery},
     storage::{Column, SparseSet, Storages},
 };
+use bevy_utils::{Id, IdType};
 use std::{
     any::TypeId,
     fmt,
     sync::atomic::{AtomicU32, Ordering},
 };
 
-#[derive(Copy, Clone, PartialEq, Eq, Debug)]
-pub struct WorldId(u64);
+#[derive(Id, Copy, Clone, Hash, Eq, PartialEq, Debug)]
+pub struct WorldId(IdType);
 
 impl Default for WorldId {
     fn default() -> Self {
-        WorldId(rand::random())
+        WorldId::new()
     }
 }
 
diff --git a/crates/bevy_utils/src/id.rs b/crates/bevy_utils/src/id.rs
new file mode 100644
index 0000000000000..8da5c5fae9063
--- /dev/null
+++ b/crates/bevy_utils/src/id.rs
@@ -0,0 +1,2 @@
+pub use bevy_derive::Id;
+pub type IdType = u64;
diff --git a/crates/bevy_utils/src/lib.rs b/crates/bevy_utils/src/lib.rs
index c6b5f25359052..f689b207384d5 100644
--- a/crates/bevy_utils/src/lib.rs
+++ b/crates/bevy_utils/src/lib.rs
@@ -1,9 +1,11 @@
 mod enum_variant_meta;
+mod id;
 pub mod label;
 pub mod slab;
 
 pub use ahash::AHasher;
 pub use enum_variant_meta::*;
+pub use id::*;
 pub use instant::{Duration, Instant};
 pub use tracing;
 pub use uuid::Uuid;
diff --git a/crates/bevy_window/src/window.rs b/crates/bevy_window/src/window.rs
index 38de0e3fce27f..c3c6e7e0be883 100644
--- a/crates/bevy_window/src/window.rs
+++ b/crates/bevy_window/src/window.rs
@@ -1,17 +1,13 @@
 use bevy_math::{IVec2, Vec2};
-use bevy_utils::{tracing::warn, Uuid};
+use bevy_utils::{tracing::warn, Id, IdType};
 use raw_window_handle::RawWindowHandle;
 
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
-pub struct WindowId(Uuid);
+#[derive(Id, Copy, Clone, Hash, Eq, PartialEq, Debug)]
+pub struct WindowId(pub IdType);
 
 impl WindowId {
-    pub fn new() -> Self {
-        WindowId(Uuid::new_v4())
-    }
-
     pub fn primary() -> Self {
-        WindowId(Uuid::from_u128(0))
+        WindowId(0)
     }
 
     pub fn is_primary(&self) -> bool {
@@ -25,7 +21,7 @@ use crate::raw_window_handle::RawWindowHandleWrapper;
 
 impl fmt::Display for WindowId {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.0.to_simple().fmt(f)
+        self.0.fmt(f)
     }
 }
 
diff --git a/examples/shader/custom_shader_pipelined.rs b/examples/shader/custom_shader_pipelined.rs
index 9fb9d118e4034..bbde7279c2640 100644
--- a/examples/shader/custom_shader_pipelined.rs
+++ b/examples/shader/custom_shader_pipelined.rs
@@ -19,7 +19,7 @@ use bevy::{
             AddRenderCommand, DrawFunctions, RenderCommand, RenderPhase, TrackedRenderPass,
         },
         render_resource::*,
-        renderer::RenderDevice,
+        renderer::GpuDevice,
         shader::Shader,
         texture::BevyDefault,
         view::ExtractedView,
@@ -44,7 +44,7 @@ pub struct GpuCustomMaterial {
 impl RenderAsset for CustomMaterial {
     type ExtractedAsset = CustomMaterial;
     type PreparedAsset = GpuCustomMaterial;
-    type Param = (SRes<RenderDevice>, SRes<CustomPipeline>);
+    type Param = (SRes<GpuDevice>, SRes<CustomPipeline>);
     fn extract_asset(&self) -> Self::ExtractedAsset {
         self.clone()
     }
@@ -129,11 +129,11 @@ pub struct CustomPipeline {
 // TODO: this pattern for initializing the shaders / pipeline isn't ideal. this should be handled by the asset system
 impl FromWorld for CustomPipeline {
     fn from_world(world: &mut World) -> Self {
-        let render_device = world.get_resource::<RenderDevice>().unwrap();
+        let gpu_device = world.get_resource::<GpuDevice>().unwrap();
         let shader = Shader::from_wgsl(include_str!("../../assets/shaders/custom.wgsl"));
-        let shader_module = render_device.create_shader_module(&shader);
+        let shader_module = gpu_device.create_shader_module(&shader);
 
-        let material_layout = render_device.create_bind_group_layout(&BindGroupLayoutDescriptor {
+        let material_layout = gpu_device.create_bind_group_layout(&BindGroupLayoutDescriptor {
             entries: &[BindGroupLayoutEntry {
                 binding: 0,
                 visibility: ShaderStage::FRAGMENT,
@@ -148,7 +148,7 @@ impl FromWorld for CustomPipeline {
         });
         let pbr_pipeline = world.get_resource::<PbrShaders>().unwrap();
 
-        let pipeline_layout = render_device.create_pipeline_layout(&PipelineLayoutDescriptor {
+        let pipeline_layout = gpu_device.create_pipeline_layout(&PipelineLayoutDescriptor {
             label: None,
             push_constant_ranges: &[],
             bind_group_layouts: &[
@@ -158,7 +158,7 @@ impl FromWorld for CustomPipeline {
             ],
         });
 
-        let pipeline = render_device.create_render_pipeline(&RenderPipelineDescriptor {
+        let pipeline = gpu_device.create_render_pipeline(&RenderPipelineDescriptor {
             label: None,
             vertex: VertexState {
                 buffers: &[VertexBufferLayout {
@@ -238,8 +238,8 @@ impl FromWorld for CustomPipeline {
         });
 
         CustomPipeline {
-            pipeline,
             material_layout,
+            pipeline,
         }
     }
 }
diff --git a/pipelined/bevy_core_pipeline/src/lib.rs b/pipelined/bevy_core_pipeline/src/lib.rs
index 5276df1fc057a..9d074f0e6c6f6 100644
--- a/pipelined/bevy_core_pipeline/src/lib.rs
+++ b/pipelined/bevy_core_pipeline/src/lib.rs
@@ -16,7 +16,7 @@ use bevy_render2::{
     render_graph::{EmptyNode, RenderGraph, SlotInfo, SlotType},
     render_phase::{sort_phase_system, DrawFunctionId, DrawFunctions, PhaseItem, RenderPhase},
     render_resource::*,
-    renderer::RenderDevice,
+    renderer::GpuDevice,
     texture::{Image, TextureCache},
     view::ExtractedView,
     RenderApp, RenderStage, RenderWorld,
@@ -228,12 +228,12 @@ pub fn extract_core_pipeline_camera_phases(
 pub fn prepare_core_views_system(
     mut commands: Commands,
     mut texture_cache: ResMut<TextureCache>,
-    render_device: Res<RenderDevice>,
+    gpu_device: Res<GpuDevice>,
     views: Query<(Entity, &ExtractedView), With<RenderPhase<Transparent3d>>>,
 ) {
     for (entity, view) in views.iter() {
         let cached_texture = texture_cache.get(
-            &render_device,
+            &gpu_device,
             TextureDescriptor {
                 label: None,
                 size: Extent3d {
diff --git a/pipelined/bevy_core_pipeline/src/main_pass_2d.rs b/pipelined/bevy_core_pipeline/src/main_pass_2d.rs
index 32996fc728807..188f2bf4b802d 100644
--- a/pipelined/bevy_core_pipeline/src/main_pass_2d.rs
+++ b/pipelined/bevy_core_pipeline/src/main_pass_2d.rs
@@ -4,7 +4,7 @@ use bevy_render2::{
     render_graph::{Node, NodeRunError, RenderGraphContext, SlotInfo, SlotType},
     render_phase::{DrawFunctions, RenderPhase, TrackedRenderPass},
     render_resource::{LoadOp, Operations, RenderPassColorAttachment, RenderPassDescriptor},
-    renderer::RenderContext,
+    renderer::GpuContext,
     view::ExtractedView,
 };
 
@@ -38,7 +38,7 @@ impl Node for MainPass2dNode {
     fn run(
         &self,
         graph: &mut RenderGraphContext,
-        render_context: &mut RenderContext,
+        gpu_context: &mut GpuContext,
         world: &World,
     ) -> Result<(), NodeRunError> {
         let color_attachment_texture = graph.get_input_texture(Self::IN_COLOR_ATTACHMENT)?;
@@ -66,7 +66,7 @@ impl Node for MainPass2dNode {
             .get_manual(world, view_entity)
             .expect("view entity should exist");
 
-        let render_pass = render_context
+        let render_pass = gpu_context
             .command_encoder
             .begin_render_pass(&pass_descriptor);
 
diff --git a/pipelined/bevy_core_pipeline/src/main_pass_3d.rs b/pipelined/bevy_core_pipeline/src/main_pass_3d.rs
index c2c0fc08a6fa0..ff9bd44a51bec 100644
--- a/pipelined/bevy_core_pipeline/src/main_pass_3d.rs
+++ b/pipelined/bevy_core_pipeline/src/main_pass_3d.rs
@@ -7,7 +7,7 @@ use bevy_render2::{
         LoadOp, Operations, RenderPassColorAttachment, RenderPassDepthStencilAttachment,
         RenderPassDescriptor,
     },
-    renderer::RenderContext,
+    renderer::GpuContext,
     view::ExtractedView,
 };
 
@@ -43,7 +43,7 @@ impl Node for MainPass3dNode {
     fn run(
         &self,
         graph: &mut RenderGraphContext,
-        render_context: &mut RenderContext,
+        gpu_context: &mut GpuContext,
         world: &World,
     ) -> Result<(), NodeRunError> {
         let color_attachment_texture = graph.get_input_texture(Self::IN_COLOR_ATTACHMENT)?;
@@ -79,7 +79,7 @@ impl Node for MainPass3dNode {
             .get_manual(world, view_entity)
             .expect("view entity should exist");
 
-        let render_pass = render_context
+        let render_pass = gpu_context
             .command_encoder
             .begin_render_pass(&pass_descriptor);
         let mut draw_functions = draw_functions.write();
diff --git a/pipelined/bevy_core_pipeline/src/main_pass_driver.rs b/pipelined/bevy_core_pipeline/src/main_pass_driver.rs
index 2e0736c3febb5..d86ead81b4d58 100644
--- a/pipelined/bevy_core_pipeline/src/main_pass_driver.rs
+++ b/pipelined/bevy_core_pipeline/src/main_pass_driver.rs
@@ -3,7 +3,7 @@ use bevy_ecs::world::World;
 use bevy_render2::{
     camera::{CameraPlugin, ExtractedCamera, ExtractedCameraNames},
     render_graph::{Node, NodeRunError, RenderGraphContext, SlotValue},
-    renderer::RenderContext,
+    renderer::GpuContext,
     view::ExtractedWindows,
 };
 
@@ -13,7 +13,7 @@ impl Node for MainPassDriverNode {
     fn run(
         &self,
         graph: &mut RenderGraphContext,
-        _render_context: &mut RenderContext,
+        _gpu_context: &mut GpuContext,
         world: &World,
     ) -> Result<(), NodeRunError> {
         let extracted_cameras = world.get_resource::<ExtractedCameraNames>().unwrap();
diff --git a/pipelined/bevy_pbr2/src/material.rs b/pipelined/bevy_pbr2/src/material.rs
index ec40936b2aea9..02995e964ae29 100644
--- a/pipelined/bevy_pbr2/src/material.rs
+++ b/pipelined/bevy_pbr2/src/material.rs
@@ -7,7 +7,7 @@ use bevy_render2::{
     color::Color,
     render_asset::{PrepareAssetError, RenderAsset, RenderAssetPlugin, RenderAssets},
     render_resource::{BindGroup, Buffer, BufferInitDescriptor, BufferUsage, Sampler, TextureView},
-    renderer::RenderDevice,
+    renderer::GpuDevice,
     texture::Image,
 };
 use crevice::std140::{AsStd140, Std140};
@@ -144,11 +144,7 @@ pub struct GpuStandardMaterial {
 impl RenderAsset for StandardMaterial {
     type ExtractedAsset = StandardMaterial;
     type PreparedAsset = GpuStandardMaterial;
-    type Param = (
-        SRes<RenderDevice>,
-        SRes<PbrShaders>,
-        SRes<RenderAssets<Image>>,
-    );
+    type Param = (SRes<GpuDevice>, SRes<PbrShaders>, SRes<RenderAssets<Image>>);
 
     fn extract_asset(&self) -> Self::ExtractedAsset {
         self.clone()
diff --git a/pipelined/bevy_pbr2/src/render/light.rs b/pipelined/bevy_pbr2/src/render/light.rs
index 5321093ae3cc4..d298186b2123d 100644
--- a/pipelined/bevy_pbr2/src/render/light.rs
+++ b/pipelined/bevy_pbr2/src/render/light.rs
@@ -21,7 +21,7 @@ use bevy_render2::{
         Draw, DrawFunctionId, DrawFunctions, PhaseItem, RenderPhase, TrackedRenderPass,
     },
     render_resource::*,
-    renderer::{RenderContext, RenderDevice, RenderQueue},
+    renderer::{GpuContext, GpuDevice, GpuQueue},
     shader::Shader,
     texture::*,
     view::{ExtractedView, ViewUniformOffset, ViewUniforms},
@@ -112,12 +112,12 @@ pub struct ShadowShaders {
 // TODO: this pattern for initializing the shaders / pipeline isn't ideal. this should be handled by the asset system
 impl FromWorld for ShadowShaders {
     fn from_world(world: &mut World) -> Self {
-        let render_device = world.get_resource::<RenderDevice>().unwrap();
+        let gpu_device = world.get_resource::<GpuDevice>().unwrap();
         let pbr_shaders = world.get_resource::<PbrShaders>().unwrap();
         let shader = Shader::from_wgsl(include_str!("depth.wgsl"));
-        let shader_module = render_device.create_shader_module(&shader);
+        let shader_module = gpu_device.create_shader_module(&shader);
 
-        let view_layout = render_device.create_bind_group_layout(&BindGroupLayoutDescriptor {
+        let view_layout = gpu_device.create_bind_group_layout(&BindGroupLayoutDescriptor {
             entries: &[
                 // View
                 BindGroupLayoutEntry {
@@ -136,13 +136,13 @@ impl FromWorld for ShadowShaders {
             label: None,
         });
 
-        let pipeline_layout = render_device.create_pipeline_layout(&PipelineLayoutDescriptor {
+        let pipeline_layout = gpu_device.create_pipeline_layout(&PipelineLayoutDescriptor {
             label: None,
             push_constant_ranges: &[],
             bind_group_layouts: &[&view_layout, &pbr_shaders.mesh_layout],
         });
 
-        let pipeline = render_device.create_render_pipeline(&RenderPipelineDescriptor {
+        let pipeline = gpu_device.create_render_pipeline(&RenderPipelineDescriptor {
             label: None,
             vertex: VertexState {
                 buffers: &[VertexBufferLayout {
@@ -206,7 +206,7 @@ impl FromWorld for ShadowShaders {
             shader_module,
             pipeline,
             view_layout,
-            point_light_sampler: render_device.create_sampler(&SamplerDescriptor {
+            point_light_sampler: gpu_device.create_sampler(&SamplerDescriptor {
                 address_mode_u: AddressMode::ClampToEdge,
                 address_mode_v: AddressMode::ClampToEdge,
                 address_mode_w: AddressMode::ClampToEdge,
@@ -216,7 +216,7 @@ impl FromWorld for ShadowShaders {
                 compare: Some(CompareFunction::GreaterEqual),
                 ..Default::default()
             }),
-            directional_light_sampler: render_device.create_sampler(&SamplerDescriptor {
+            directional_light_sampler: gpu_device.create_sampler(&SamplerDescriptor {
                 address_mode_u: AddressMode::ClampToEdge,
                 address_mode_v: AddressMode::ClampToEdge,
                 address_mode_w: AddressMode::ClampToEdge,
@@ -381,8 +381,8 @@ pub struct LightMeta {
 pub fn prepare_lights(
     mut commands: Commands,
     mut texture_cache: ResMut<TextureCache>,
-    render_device: Res<RenderDevice>,
-    render_queue: Res<RenderQueue>,
+    gpu_device: Res<GpuDevice>,
+    gpu_queue: Res<GpuQueue>,
     mut light_meta: ResMut<LightMeta>,
     views: Query<Entity, With<RenderPhase<Transparent3d>>>,
     ambient_light: Res<ExtractedAmbientLight>,
@@ -394,13 +394,13 @@ pub fn prepare_lights(
     // PERF: view.iter().count() could be views.iter().len() if we implemented ExactSizeIterator for archetype-only filters
     light_meta
         .view_gpu_lights
-        .reserve_and_clear(views.iter().count(), &render_device);
+        .reserve_and_clear(views.iter().count(), &gpu_device);
 
     let ambient_color = ambient_light.color.as_rgba_linear() * ambient_light.brightness;
     // set up light data for each view
     for entity in views.iter() {
         let point_light_depth_texture = texture_cache.get(
-            &render_device,
+            &gpu_device,
             TextureDescriptor {
                 size: Extent3d {
                     width: point_light_shadow_map.size as u32,
@@ -416,7 +416,7 @@ pub fn prepare_lights(
             },
         );
         let directional_light_depth_texture = texture_cache.get(
-            &render_device,
+            &gpu_device,
             TextureDescriptor {
                 size: Extent3d {
                     width: directional_light_shadow_map.size as u32,
@@ -613,18 +613,18 @@ pub fn prepare_lights(
         });
     }
 
-    light_meta.view_gpu_lights.write_buffer(&render_queue);
+    light_meta.view_gpu_lights.write_buffer(&gpu_queue);
 }
 
 pub fn queue_shadow_view_bind_group(
-    render_device: Res<RenderDevice>,
+    gpu_device: Res<GpuDevice>,
     shadow_shaders: Res<ShadowShaders>,
     mut light_meta: ResMut<LightMeta>,
     view_uniforms: Res<ViewUniforms>,
 ) {
     if let Some(view_binding) = view_uniforms.uniforms.binding() {
         light_meta.shadow_view_bind_group =
-            Some(render_device.create_bind_group(&BindGroupDescriptor {
+            Some(gpu_device.create_bind_group(&BindGroupDescriptor {
                 entries: &[BindGroupEntry {
                     binding: 0,
                     resource: view_binding,
@@ -710,7 +710,7 @@ impl Node for ShadowPassNode {
     fn run(
         &self,
         graph: &mut RenderGraphContext,
-        render_context: &mut RenderContext,
+        gpu_context: &mut GpuContext,
         world: &World,
     ) -> Result<(), NodeRunError> {
         let view_entity = graph.get_input_entity(Self::IN_VIEW)?;
@@ -735,7 +735,7 @@ impl Node for ShadowPassNode {
 
                 let draw_functions = world.get_resource::<DrawFunctions<Shadow>>().unwrap();
 
-                let render_pass = render_context
+                let render_pass = gpu_context
                     .command_encoder
                     .begin_render_pass(&pass_descriptor);
                 let mut draw_functions = draw_functions.write();
diff --git a/pipelined/bevy_pbr2/src/render/mod.rs b/pipelined/bevy_pbr2/src/render/mod.rs
index 19354e0cd3fc4..bd6a27170aa13 100644
--- a/pipelined/bevy_pbr2/src/render/mod.rs
+++ b/pipelined/bevy_pbr2/src/render/mod.rs
@@ -16,7 +16,7 @@ use bevy_render2::{
     render_component::{ComponentUniforms, DynamicUniformIndex},
     render_phase::{DrawFunctions, RenderCommand, RenderPhase, TrackedRenderPass},
     render_resource::*,
-    renderer::{RenderDevice, RenderQueue},
+    renderer::{GpuDevice, GpuQueue},
     shader::Shader,
     texture::{BevyDefault, GpuImage, Image, TextureFormatPixelInfo},
     view::{ExtractedView, ViewUniformOffset, ViewUniforms},
@@ -127,11 +127,11 @@ pub struct PbrShaders {
 // TODO: this pattern for initializing the shaders / pipeline isn't ideal. this should be handled by the asset system
 impl FromWorld for PbrShaders {
     fn from_world(world: &mut World) -> Self {
-        let render_device = world.get_resource::<RenderDevice>().unwrap();
+        let gpu_device = world.get_resource::<GpuDevice>().unwrap();
         let shader = Shader::from_wgsl(include_str!("pbr.wgsl"));
-        let shader_module = render_device.create_shader_module(&shader);
+        let shader_module = gpu_device.create_shader_module(&shader);
 
-        let view_layout = render_device.create_bind_group_layout(&BindGroupLayoutDescriptor {
+        let view_layout = gpu_device.create_bind_group_layout(&BindGroupLayoutDescriptor {
             entries: &[
                 // View
                 BindGroupLayoutEntry {
@@ -205,7 +205,7 @@ impl FromWorld for PbrShaders {
             label: None,
         });
 
-        let material_layout = render_device.create_bind_group_layout(&BindGroupLayoutDescriptor {
+        let material_layout = gpu_device.create_bind_group_layout(&BindGroupLayoutDescriptor {
             entries: &[
                 BindGroupLayoutEntry {
                     binding: 0,
@@ -307,7 +307,7 @@ impl FromWorld for PbrShaders {
             label: None,
         });
 
-        let mesh_layout = render_device.create_bind_group_layout(&BindGroupLayoutDescriptor {
+        let mesh_layout = gpu_device.create_bind_group_layout(&BindGroupLayoutDescriptor {
             entries: &[BindGroupLayoutEntry {
                 binding: 0,
                 visibility: ShaderStage::VERTEX | ShaderStage::FRAGMENT,
@@ -323,13 +323,13 @@ impl FromWorld for PbrShaders {
             label: None,
         });
 
-        let pipeline_layout = render_device.create_pipeline_layout(&PipelineLayoutDescriptor {
+        let pipeline_layout = gpu_device.create_pipeline_layout(&PipelineLayoutDescriptor {
             label: None,
             push_constant_ranges: &[],
             bind_group_layouts: &[&view_layout, &material_layout, &mesh_layout],
         });
 
-        let pipeline = render_device.create_render_pipeline(&RenderPipelineDescriptor {
+        let pipeline = gpu_device.create_render_pipeline(&RenderPipelineDescriptor {
             label: None,
             vertex: VertexState {
                 buffers: &[VertexBufferLayout {
@@ -416,12 +416,12 @@ impl FromWorld for PbrShaders {
                 &[255u8; 4],
                 TextureFormat::bevy_default(),
             );
-            let texture = render_device.create_texture(&image.texture_descriptor);
-            let sampler = render_device.create_sampler(&image.sampler_descriptor);
+            let texture = gpu_device.create_texture(&image.texture_descriptor);
+            let sampler = gpu_device.create_sampler(&image.sampler_descriptor);
 
             let format_size = image.texture_descriptor.format.pixel_size();
-            let render_queue = world.get_resource_mut::<RenderQueue>().unwrap();
-            render_queue.write_texture(
+            let gpu_queue = world.get_resource_mut::<GpuQueue>().unwrap();
+            gpu_queue.write_texture(
                 ImageCopyTexture {
                     texture: &texture,
                     mip_level: 0,
@@ -466,12 +466,12 @@ pub struct TransformBindGroup {
 pub fn queue_transform_bind_group(
     mut commands: Commands,
     pbr_shaders: Res<PbrShaders>,
-    render_device: Res<RenderDevice>,
+    gpu_device: Res<GpuDevice>,
     transform_uniforms: Res<ComponentUniforms<MeshUniform>>,
 ) {
     if let Some(binding) = transform_uniforms.uniforms().binding() {
         commands.insert_resource(TransformBindGroup {
-            value: render_device.create_bind_group(&BindGroupDescriptor {
+            value: gpu_device.create_bind_group(&BindGroupDescriptor {
                 entries: &[BindGroupEntry {
                     binding: 0,
                     resource: binding,
@@ -491,7 +491,7 @@ pub struct PbrViewBindGroup {
 pub fn queue_meshes(
     mut commands: Commands,
     transparent_3d_draw_functions: Res<DrawFunctions<Transparent3d>>,
-    render_device: Res<RenderDevice>,
+    gpu_device: Res<GpuDevice>,
     pbr_shaders: Res<PbrShaders>,
     shadow_shaders: Res<ShadowShaders>,
     light_meta: Res<LightMeta>,
@@ -513,7 +513,7 @@ pub fn queue_meshes(
         light_meta.view_gpu_lights.binding(),
     ) {
         for (entity, view, view_lights, mut transparent_phase) in views.iter_mut() {
-            let view_bind_group = render_device.create_bind_group(&BindGroupDescriptor {
+            let view_bind_group = gpu_device.create_bind_group(&BindGroupDescriptor {
                 entries: &[
                     BindGroupEntry {
                         binding: 0,
diff --git a/pipelined/bevy_render2/src/mesh/mesh/mod.rs b/pipelined/bevy_render2/src/mesh/mesh/mod.rs
index 4c2caa9c4d3ac..884fc78028316 100644
--- a/pipelined/bevy_render2/src/mesh/mesh/mod.rs
+++ b/pipelined/bevy_render2/src/mesh/mesh/mod.rs
@@ -3,7 +3,7 @@ mod conversions;
 use crate::{
     render_asset::{PrepareAssetError, RenderAsset},
     render_resource::Buffer,
-    renderer::RenderDevice,
+    renderer::GpuDevice,
 };
 use bevy_core::cast_slice;
 use bevy_ecs::system::{lifetimeless::SRes, SystemParamItem};
@@ -541,7 +541,7 @@ pub struct GpuIndexInfo {
 impl RenderAsset for Mesh {
     type ExtractedAsset = Mesh;
     type PreparedAsset = GpuMesh;
-    type Param = SRes<RenderDevice>;
+    type Param = SRes<GpuDevice>;
 
     fn extract_asset(&self) -> Self::ExtractedAsset {
         self.clone()
diff --git a/pipelined/bevy_render2/src/render_component.rs b/pipelined/bevy_render2/src/render_component.rs
index 1a81cb2fa1c9d..80a889bc602bd 100644
--- a/pipelined/bevy_render2/src/render_component.rs
+++ b/pipelined/bevy_render2/src/render_component.rs
@@ -1,6 +1,6 @@
 use crate::{
     render_resource::DynamicUniformVec,
-    renderer::{RenderDevice, RenderQueue},
+    renderer::{GpuDevice, GpuQueue},
     RenderApp, RenderStage,
 };
 use bevy_app::{App, Plugin};
@@ -85,8 +85,8 @@ impl<C: Component + AsStd140> Default for ComponentUniforms<C> {
 
 fn prepare_uniform_components<C: Component>(
     mut commands: Commands,
-    render_device: Res<RenderDevice>,
-    render_queue: Res<RenderQueue>,
+    gpu_device: Res<GpuDevice>,
+    gpu_queue: Res<GpuQueue>,
     mut component_uniforms: ResMut<ComponentUniforms<C>>,
     components: Query<(Entity, &C)>,
 ) where
@@ -95,7 +95,7 @@ fn prepare_uniform_components<C: Component>(
     let len = components.iter().len();
     component_uniforms
         .uniforms
-        .reserve_and_clear(len, &render_device);
+        .reserve_and_clear(len, &gpu_device);
     for (entity, component) in components.iter() {
         commands
             .get_or_spawn(entity)
@@ -105,7 +105,7 @@ fn prepare_uniform_components<C: Component>(
             });
     }
 
-    component_uniforms.uniforms.write_buffer(&render_queue);
+    component_uniforms.uniforms.write_buffer(&gpu_queue);
 }
 
 pub struct ExtractComponentPlugin<C, F = ()>(PhantomData<fn() -> (C, F)>);
diff --git a/pipelined/bevy_render2/src/render_graph/graph.rs b/pipelined/bevy_render2/src/render_graph/graph.rs
index 23d6c40932d4a..cc766e515508d 100644
--- a/pipelined/bevy_render2/src/render_graph/graph.rs
+++ b/pipelined/bevy_render2/src/render_graph/graph.rs
@@ -3,7 +3,7 @@ use crate::{
         Edge, Node, NodeId, NodeLabel, NodeRunError, NodeState, RenderGraphContext,
         RenderGraphError, SlotInfo, SlotLabel,
     },
-    renderer::RenderContext,
+    renderer::GpuContext,
 };
 use bevy_ecs::prelude::World;
 use bevy_utils::HashMap;
@@ -342,7 +342,7 @@ impl Node for GraphInputNode {
     fn run(
         &self,
         graph: &mut RenderGraphContext,
-        _render_context: &mut RenderContext,
+        _gpu_context: &mut GpuContext,
         _world: &World,
     ) -> Result<(), NodeRunError> {
         for i in 0..graph.inputs().len() {
@@ -360,7 +360,7 @@ mod tests {
             Edge, Node, NodeId, NodeRunError, RenderGraph, RenderGraphContext, RenderGraphError,
             SlotInfo, SlotType,
         },
-        renderer::RenderContext,
+        renderer::GpuContext,
     };
     use bevy_ecs::world::World;
     use bevy_utils::HashSet;
@@ -397,7 +397,7 @@ mod tests {
         fn run(
             &self,
             _: &mut RenderGraphContext,
-            _: &mut RenderContext,
+            _: &mut GpuContext,
             _: &World,
         ) -> Result<(), NodeRunError> {
             Ok(())
@@ -470,7 +470,7 @@ mod tests {
             fn run(
                 &self,
                 _: &mut RenderGraphContext,
-                _: &mut RenderContext,
+                _: &mut GpuContext,
                 _: &World,
             ) -> Result<(), NodeRunError> {
                 Ok(())
diff --git a/pipelined/bevy_render2/src/render_graph/node.rs b/pipelined/bevy_render2/src/render_graph/node.rs
index 5aefa90b7dac8..e60127c624611 100644
--- a/pipelined/bevy_render2/src/render_graph/node.rs
+++ b/pipelined/bevy_render2/src/render_graph/node.rs
@@ -3,27 +3,16 @@ use crate::{
         Edge, InputSlotError, OutputSlotError, RenderGraphContext, RenderGraphError,
         RunSubGraphError, SlotInfo, SlotInfos,
     },
-    renderer::RenderContext,
+    renderer::GpuContext,
 };
 use bevy_ecs::world::World;
-use bevy_utils::Uuid;
+use bevy_utils::{Id, IdType};
 use downcast_rs::{impl_downcast, Downcast};
 use std::{borrow::Cow, fmt::Debug};
 use thiserror::Error;
 
-#[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
-    }
-}
+#[derive(Id, Copy, Clone, Hash, Eq, PartialEq, Debug)]
+pub struct NodeId(IdType);
 
 pub trait Node: Downcast + Send + Sync + 'static {
     fn input(&self) -> Vec<SlotInfo> {
@@ -41,7 +30,7 @@ pub trait Node: Downcast + Send + Sync + 'static {
     fn run(
         &self,
         graph: &mut RenderGraphContext,
-        render_context: &mut RenderContext,
+        gpu_context: &mut GpuContext,
         world: &World,
     ) -> Result<(), NodeRunError>;
 }
@@ -229,7 +218,7 @@ impl Node for EmptyNode {
     fn run(
         &self,
         _graph: &mut RenderGraphContext,
-        _render_context: &mut RenderContext,
+        _gpu_context: &mut GpuContext,
         _world: &World,
     ) -> Result<(), NodeRunError> {
         Ok(())
diff --git a/pipelined/bevy_render2/src/render_resource/bind_group.rs b/pipelined/bevy_render2/src/render_resource/bind_group.rs
index c1d514da38dab..49a2076f94a42 100644
--- a/pipelined/bevy_render2/src/render_resource/bind_group.rs
+++ b/pipelined/bevy_render2/src/render_resource/bind_group.rs
@@ -1,8 +1,8 @@
-use bevy_reflect::Uuid;
+use bevy_utils::{Id, IdType};
 use std::sync::Arc;
 
-#[derive(Copy, Clone, Hash, Eq, PartialEq, Debug)]
-pub struct BindGroupId(Uuid);
+#[derive(Id, Copy, Clone, Hash, Eq, PartialEq, Debug)]
+pub struct BindGroupId(IdType);
 
 #[derive(Clone, Debug)]
 pub struct BindGroup {
@@ -25,7 +25,7 @@ impl BindGroup {
 impl From<wgpu::BindGroup> for BindGroup {
     fn from(value: wgpu::BindGroup) -> Self {
         BindGroup {
-            id: BindGroupId(Uuid::new_v4()),
+            id: BindGroupId::new(),
             value: Arc::new(value),
         }
     }
diff --git a/pipelined/bevy_render2/src/render_resource/buffer.rs b/pipelined/bevy_render2/src/render_resource/buffer.rs
index a902af5834975..a28afab768efb 100644
--- a/pipelined/bevy_render2/src/render_resource/buffer.rs
+++ b/pipelined/bevy_render2/src/render_resource/buffer.rs
@@ -1,11 +1,11 @@
-use bevy_utils::Uuid;
+use bevy_utils::{Id, IdType};
 use std::{
     ops::{Bound, Deref, RangeBounds},
     sync::Arc,
 };
 
-#[derive(Copy, Clone, Hash, Eq, PartialEq, Debug)]
-pub struct BufferId(Uuid);
+#[derive(Id, Copy, Clone, Hash, Eq, PartialEq, Debug)]
+pub struct BufferId(IdType);
 
 #[derive(Clone, Debug)]
 pub struct Buffer {
@@ -41,7 +41,7 @@ impl Buffer {
 impl From<wgpu::Buffer> for Buffer {
     fn from(value: wgpu::Buffer) -> Self {
         Buffer {
-            id: BufferId(Uuid::new_v4()),
+            id: BufferId::new(),
             value: Arc::new(value),
         }
     }
diff --git a/pipelined/bevy_render2/src/render_resource/buffer_vec.rs b/pipelined/bevy_render2/src/render_resource/buffer_vec.rs
index 274cfb225fda6..ccaf711a0010d 100644
--- a/pipelined/bevy_render2/src/render_resource/buffer_vec.rs
+++ b/pipelined/bevy_render2/src/render_resource/buffer_vec.rs
@@ -1,4 +1,4 @@
-use crate::{render_resource::Buffer, renderer::RenderDevice};
+use crate::{render_resource::Buffer, renderer::GpuDevice};
 use bevy_core::{cast_slice, Pod};
 use wgpu::BufferUsage;
 
@@ -59,17 +59,17 @@ impl<T: Pod> BufferVec<T> {
         }
     }
 
-    pub fn reserve(&mut self, capacity: usize, device: &RenderDevice) {
+    pub fn reserve(&mut self, capacity: usize, gpu_device: &GpuDevice) {
         if capacity > self.capacity {
             self.capacity = capacity;
             let size = (self.item_size * capacity) as wgpu::BufferAddress;
-            self.staging_buffer = Some(device.create_buffer(&wgpu::BufferDescriptor {
+            self.staging_buffer = Some(gpu_device.create_buffer(&wgpu::BufferDescriptor {
                 label: None,
                 size,
                 usage: BufferUsage::COPY_SRC | BufferUsage::MAP_WRITE,
                 mapped_at_creation: false,
             }));
-            self.buffer = Some(device.create_buffer(&wgpu::BufferDescriptor {
+            self.buffer = Some(gpu_device.create_buffer(&wgpu::BufferDescriptor {
                 label: None,
                 size,
                 usage: BufferUsage::COPY_DST | self.buffer_usage,
@@ -78,16 +78,16 @@ impl<T: Pod> BufferVec<T> {
         }
     }
 
-    pub fn reserve_and_clear(&mut self, capacity: usize, device: &RenderDevice) {
+    pub fn reserve_and_clear(&mut self, capacity: usize, gpu_device: &GpuDevice) {
         self.clear();
-        self.reserve(capacity, device);
+        self.reserve(capacity, gpu_device);
     }
 
-    pub fn write_to_staging_buffer(&self, render_device: &RenderDevice) {
+    pub fn write_to_staging_buffer(&self, gpu_device: &GpuDevice) {
         if let Some(staging_buffer) = &self.staging_buffer {
             let end = (self.values.len() * self.item_size) as u64;
             let slice = staging_buffer.slice(0..end);
-            render_device.map_buffer(&slice, wgpu::MapMode::Write);
+            gpu_device.map_buffer(&slice, wgpu::MapMode::Write);
             {
                 let mut data = slice.get_mapped_range_mut();
                 let bytes: &[u8] = cast_slice(&self.values);
diff --git a/pipelined/bevy_render2/src/render_resource/pipeline.rs b/pipelined/bevy_render2/src/render_resource/pipeline.rs
index 22c493301c555..3a396576bf8e4 100644
--- a/pipelined/bevy_render2/src/render_resource/pipeline.rs
+++ b/pipelined/bevy_render2/src/render_resource/pipeline.rs
@@ -1,8 +1,8 @@
-use bevy_reflect::Uuid;
+use bevy_utils::{Id, IdType};
 use std::{ops::Deref, sync::Arc};
 
-#[derive(Copy, Clone, Hash, Eq, PartialEq, Debug)]
-pub struct RenderPipelineId(Uuid);
+#[derive(Id, Copy, Clone, Hash, Eq, PartialEq, Debug)]
+pub struct RenderPipelineId(IdType);
 
 #[derive(Clone, Debug)]
 pub struct RenderPipeline {
@@ -20,7 +20,7 @@ impl RenderPipeline {
 impl From<wgpu::RenderPipeline> for RenderPipeline {
     fn from(value: wgpu::RenderPipeline) -> Self {
         RenderPipeline {
-            id: RenderPipelineId(Uuid::new_v4()),
+            id: RenderPipelineId::new(),
             value: Arc::new(value),
         }
     }
@@ -35,8 +35,8 @@ impl Deref for RenderPipeline {
     }
 }
 
-#[derive(Copy, Clone, Hash, Eq, PartialEq, Debug)]
-pub struct ComputePipelineId(Uuid);
+#[derive(Id, Copy, Clone, Hash, Eq, PartialEq, Debug)]
+pub struct ComputePipelineId(IdType);
 
 #[derive(Clone, Debug)]
 pub struct ComputePipeline {
@@ -54,7 +54,7 @@ impl ComputePipeline {
 impl From<wgpu::ComputePipeline> for ComputePipeline {
     fn from(value: wgpu::ComputePipeline) -> Self {
         ComputePipeline {
-            id: ComputePipelineId(Uuid::new_v4()),
+            id: ComputePipelineId::new(),
             value: Arc::new(value),
         }
     }
diff --git a/pipelined/bevy_render2/src/render_resource/texture.rs b/pipelined/bevy_render2/src/render_resource/texture.rs
index 8c778598cffd7..0d06d9fd6af75 100644
--- a/pipelined/bevy_render2/src/render_resource/texture.rs
+++ b/pipelined/bevy_render2/src/render_resource/texture.rs
@@ -1,8 +1,8 @@
-use bevy_utils::Uuid;
+use bevy_utils::{Id, IdType};
 use std::{ops::Deref, sync::Arc};
 
-#[derive(Copy, Clone, Hash, Eq, PartialEq, Debug)]
-pub struct TextureId(Uuid);
+#[derive(Id, Copy, Clone, Hash, Eq, PartialEq, Debug)]
+pub struct TextureId(IdType);
 
 #[derive(Clone, Debug)]
 pub struct Texture {
@@ -24,7 +24,7 @@ impl Texture {
 impl From<wgpu::Texture> for Texture {
     fn from(value: wgpu::Texture) -> Self {
         Texture {
-            id: TextureId(Uuid::new_v4()),
+            id: TextureId::new(),
             value: Arc::new(value),
         }
     }
@@ -39,8 +39,8 @@ impl Deref for Texture {
     }
 }
 
-#[derive(Copy, Clone, Hash, Eq, PartialEq, Debug)]
-pub struct TextureViewId(Uuid);
+#[derive(Id, Copy, Clone, Hash, Eq, PartialEq, Debug)]
+pub struct TextureViewId(IdType);
 
 #[derive(Clone, Debug)]
 pub enum TextureViewValue {
@@ -64,7 +64,7 @@ impl TextureView {
 impl From<wgpu::TextureView> for TextureView {
     fn from(value: wgpu::TextureView) -> Self {
         TextureView {
-            id: TextureViewId(Uuid::new_v4()),
+            id: TextureViewId::new(),
             value: TextureViewValue::TextureView(Arc::new(value)),
         }
     }
@@ -73,7 +73,7 @@ impl From<wgpu::TextureView> for TextureView {
 impl From<wgpu::SwapChainFrame> for TextureView {
     fn from(value: wgpu::SwapChainFrame) -> Self {
         TextureView {
-            id: TextureViewId(Uuid::new_v4()),
+            id: TextureViewId::new(),
             value: TextureViewValue::SwapChainFrame(Arc::new(value)),
         }
     }
@@ -91,8 +91,8 @@ impl Deref for TextureView {
     }
 }
 
-#[derive(Copy, Clone, Hash, Eq, PartialEq, Debug)]
-pub struct SamplerId(Uuid);
+#[derive(Id, Copy, Clone, Hash, Eq, PartialEq, Debug)]
+pub struct SamplerId(IdType);
 
 #[derive(Clone, Debug)]
 pub struct Sampler {
@@ -110,7 +110,7 @@ impl Sampler {
 impl From<wgpu::Sampler> for Sampler {
     fn from(value: wgpu::Sampler) -> Self {
         Sampler {
-            id: SamplerId(Uuid::new_v4()),
+            id: SamplerId::new(),
             value: Arc::new(value),
         }
     }
@@ -141,7 +141,7 @@ impl SwapChainFrame {
 impl From<wgpu::SwapChainFrame> for SwapChainFrame {
     fn from(value: wgpu::SwapChainFrame) -> Self {
         Self {
-            id: TextureViewId(Uuid::new_v4()),
+            id: TextureViewId::new(),
             value: Arc::new(value),
         }
     }
diff --git a/pipelined/bevy_render2/src/render_resource/uniform_vec.rs b/pipelined/bevy_render2/src/render_resource/uniform_vec.rs
index 1d6658514673f..2dcdd0a4423ba 100644
--- a/pipelined/bevy_render2/src/render_resource/uniform_vec.rs
+++ b/pipelined/bevy_render2/src/render_resource/uniform_vec.rs
@@ -1,6 +1,6 @@
 use crate::{
     render_resource::Buffer,
-    renderer::{RenderDevice, RenderQueue},
+    renderer::{GpuDevice, GpuQueue},
 };
 use crevice::std140::{self, AsStd140, DynamicUniform, Std140};
 use std::num::NonZeroU64;
@@ -70,12 +70,12 @@ impl<T: AsStd140> UniformVec<T> {
         }
     }
 
-    pub fn reserve(&mut self, capacity: usize, device: &RenderDevice) {
+    pub fn reserve(&mut self, capacity: usize, gpu_device: &GpuDevice) {
         if capacity > self.capacity {
             self.capacity = capacity;
             let size = self.item_size * capacity;
             self.scratch.resize(size, 0);
-            self.uniform_buffer = Some(device.create_buffer(&BufferDescriptor {
+            self.uniform_buffer = Some(gpu_device.create_buffer(&BufferDescriptor {
                 label: None,
                 size: size as wgpu::BufferAddress,
                 usage: BufferUsage::COPY_DST | BufferUsage::UNIFORM,
@@ -84,12 +84,12 @@ impl<T: AsStd140> UniformVec<T> {
         }
     }
 
-    pub fn reserve_and_clear(&mut self, capacity: usize, device: &RenderDevice) {
+    pub fn reserve_and_clear(&mut self, capacity: usize, gpu_device: &GpuDevice) {
         self.clear();
-        self.reserve(capacity, device);
+        self.reserve(capacity, gpu_device);
     }
 
-    pub fn write_buffer(&mut self, queue: &RenderQueue) {
+    pub fn write_buffer(&mut self, queue: &GpuQueue) {
         if let Some(uniform_buffer) = &self.uniform_buffer {
             let range = 0..self.item_size * self.values.len();
             let mut writer = std140::Writer::new(&mut self.scratch[range.clone()]);
@@ -147,17 +147,17 @@ impl<T: AsStd140> DynamicUniformVec<T> {
     }
 
     #[inline]
-    pub fn reserve(&mut self, capacity: usize, device: &RenderDevice) {
-        self.uniform_vec.reserve(capacity, device);
+    pub fn reserve(&mut self, capacity: usize, gpu_device: &GpuDevice) {
+        self.uniform_vec.reserve(capacity, gpu_device);
     }
 
     #[inline]
-    pub fn reserve_and_clear(&mut self, capacity: usize, device: &RenderDevice) {
-        self.uniform_vec.reserve_and_clear(capacity, device);
+    pub fn reserve_and_clear(&mut self, capacity: usize, gpu_device: &GpuDevice) {
+        self.uniform_vec.reserve_and_clear(capacity, gpu_device);
     }
 
     #[inline]
-    pub fn write_buffer(&mut self, queue: &RenderQueue) {
+    pub fn write_buffer(&mut self, queue: &GpuQueue) {
         self.uniform_vec.write_buffer(queue);
     }
 
diff --git a/pipelined/bevy_render2/src/renderer/render_device.rs b/pipelined/bevy_render2/src/renderer/gpu_device.rs
similarity index 98%
rename from pipelined/bevy_render2/src/renderer/render_device.rs
rename to pipelined/bevy_render2/src/renderer/gpu_device.rs
index 2cb437c1222ee..6d4ed4c192e75 100644
--- a/pipelined/bevy_render2/src/renderer/render_device.rs
+++ b/pipelined/bevy_render2/src/renderer/gpu_device.rs
@@ -7,17 +7,17 @@ use crate::render_resource::{
 use std::sync::Arc;
 
 #[derive(Clone)]
-pub struct RenderDevice {
+pub struct GpuDevice {
     device: Arc<wgpu::Device>,
 }
 
-impl From<Arc<wgpu::Device>> for RenderDevice {
+impl From<Arc<wgpu::Device>> for GpuDevice {
     fn from(device: Arc<wgpu::Device>) -> Self {
         Self { device }
     }
 }
 
-impl RenderDevice {
+impl GpuDevice {
     /// List all features that may be used with this device.
     ///
     /// Functions may panic if you use unsupported features.
diff --git a/pipelined/bevy_render2/src/renderer/graph_runner.rs b/pipelined/bevy_render2/src/renderer/graph_runner.rs
index 3336c75ba7f4f..8c9af6c90494e 100644
--- a/pipelined/bevy_render2/src/renderer/graph_runner.rs
+++ b/pipelined/bevy_render2/src/renderer/graph_runner.rs
@@ -12,7 +12,7 @@ use crate::{
         Edge, NodeId, NodeRunError, NodeState, RenderGraph, RenderGraphContext, SlotLabel,
         SlotType, SlotValue,
     },
-    renderer::{RenderContext, RenderDevice},
+    renderer::{GpuContext, GpuDevice},
 };
 
 pub(crate) struct RenderGraphRunner;
@@ -45,26 +45,26 @@ pub enum RenderGraphRunnerError {
 impl RenderGraphRunner {
     pub fn run(
         graph: &RenderGraph,
-        render_device: RenderDevice,
+        gpu_device: GpuDevice,
         queue: &wgpu::Queue,
         world: &World,
     ) -> Result<(), RenderGraphRunnerError> {
         let command_encoder =
-            render_device.create_command_encoder(&wgpu::CommandEncoderDescriptor::default());
-        let mut render_context = RenderContext {
-            render_device,
+            gpu_device.create_command_encoder(&wgpu::CommandEncoderDescriptor::default());
+        let mut gpu_context = GpuContext {
+            gpu_device,
             command_encoder,
         };
 
         {
             let span = info_span!("run_graph");
             let _guard = span.enter();
-            Self::run_graph(graph, None, &mut render_context, world, &[])?;
+            Self::run_graph(graph, None, &mut gpu_context, world, &[])?;
         }
         {
             let span = info_span!("submit_graph_commands");
             let _guard = span.enter();
-            queue.submit(vec![render_context.command_encoder.finish()]);
+            queue.submit(vec![gpu_context.command_encoder.finish()]);
         }
         Ok(())
     }
@@ -72,7 +72,7 @@ impl RenderGraphRunner {
     fn run_graph(
         graph: &RenderGraph,
         graph_name: Option<Cow<'static, str>>,
-        render_context: &mut RenderContext,
+        render_context: &mut GpuContext,
         world: &World,
         inputs: &[SlotValue],
     ) -> Result<(), RenderGraphRunnerError> {
diff --git a/pipelined/bevy_render2/src/renderer/mod.rs b/pipelined/bevy_render2/src/renderer/mod.rs
index 91bb42a08b5a1..37fb0e1f0ed97 100644
--- a/pipelined/bevy_render2/src/renderer/mod.rs
+++ b/pipelined/bevy_render2/src/renderer/mod.rs
@@ -1,39 +1,28 @@
+mod gpu_device;
 mod graph_runner;
-mod render_device;
 
-use bevy_utils::tracing::info;
+pub use gpu_device::*;
 pub use graph_runner::*;
-pub use render_device::*;
 
 use crate::render_graph::RenderGraph;
 use bevy_ecs::prelude::*;
+use bevy_utils::tracing::info;
 use std::sync::Arc;
 use wgpu::{BackendBit, CommandEncoder, DeviceDescriptor, Instance, Queue, RequestAdapterOptions};
 
-pub fn render_system(world: &mut World) {
-    world.resource_scope(|world, mut graph: Mut<RenderGraph>| {
-        graph.update(world);
-    });
-    let graph = world.get_resource::<RenderGraph>().unwrap();
-    let render_device = world.get_resource::<RenderDevice>().unwrap();
-    let render_queue = world.get_resource::<RenderQueue>().unwrap();
-    RenderGraphRunner::run(
-        graph,
-        render_device.clone(), // TODO: is this clone really necessary?
-        render_queue,
-        world,
-    )
-    .unwrap();
-}
+pub type GpuQueue = Arc<Queue>;
+pub type GpuInstance = Instance;
 
-pub type RenderQueue = Arc<Queue>;
-pub type RenderInstance = Instance;
+pub struct GpuContext {
+    pub gpu_device: GpuDevice,
+    pub command_encoder: CommandEncoder,
+}
 
 pub async fn initialize_renderer(
     backends: BackendBit,
     request_adapter_options: &RequestAdapterOptions<'_>,
     device_descriptor: &DeviceDescriptor<'_>,
-) -> (RenderInstance, RenderDevice, RenderQueue) {
+) -> (GpuInstance, GpuDevice, GpuQueue) {
     let instance = wgpu::Instance::new(backends);
 
     let adapter = instance
@@ -60,10 +49,21 @@ pub async fn initialize_renderer(
         .unwrap();
     let device = Arc::new(device);
     let queue = Arc::new(queue);
-    (instance, RenderDevice::from(device), queue)
+    (instance, GpuDevice::from(device), queue)
 }
 
-pub struct RenderContext {
-    pub render_device: RenderDevice,
-    pub command_encoder: CommandEncoder,
+pub fn render_system(world: &mut World) {
+    world.resource_scope(|world, mut graph: Mut<RenderGraph>| {
+        graph.update(world);
+    });
+    let graph = world.get_resource::<RenderGraph>().unwrap();
+    let gpu_device = world.get_resource::<GpuDevice>().unwrap();
+    let gpu_queue = world.get_resource::<GpuQueue>().unwrap();
+    RenderGraphRunner::run(
+        graph,
+        gpu_device.clone(), // TODO: is this clone really necessary?
+        gpu_queue,
+        world,
+    )
+    .unwrap();
 }
diff --git a/pipelined/bevy_render2/src/shader/shader.rs b/pipelined/bevy_render2/src/shader/shader.rs
index ace300da63a0d..f6ffbf276d56d 100644
--- a/pipelined/bevy_render2/src/shader/shader.rs
+++ b/pipelined/bevy_render2/src/shader/shader.rs
@@ -1,20 +1,13 @@
 use bevy_asset::{AssetLoader, LoadContext, LoadedAsset};
-use bevy_reflect::{TypeUuid, Uuid};
-use bevy_utils::{tracing::error, BoxedFuture};
+use bevy_reflect::TypeUuid;
+use bevy_utils::{tracing::error, BoxedFuture, Id, IdType};
 use naga::{valid::ModuleInfo, Module, ShaderStage};
 use std::{borrow::Cow, collections::HashMap, marker::Copy};
 use thiserror::Error;
 use wgpu::{ShaderFlags, ShaderModuleDescriptor, ShaderSource};
 
-#[derive(Copy, Clone, Hash, Eq, PartialEq, Debug)]
-pub struct ShaderId(Uuid);
-
-impl ShaderId {
-    #[allow(clippy::new_without_default)]
-    pub fn new() -> Self {
-        ShaderId(Uuid::new_v4())
-    }
-}
+#[derive(Id, Copy, Clone, Hash, Eq, PartialEq, Debug)]
+pub struct ShaderId(IdType);
 
 #[derive(Error, Debug)]
 pub enum ShaderReflectError {
diff --git a/pipelined/bevy_render2/src/texture/image.rs b/pipelined/bevy_render2/src/texture/image.rs
index 1be9671c92806..b0ffaaf00a29a 100644
--- a/pipelined/bevy_render2/src/texture/image.rs
+++ b/pipelined/bevy_render2/src/texture/image.rs
@@ -2,7 +2,7 @@ use super::image_texture_conversion::image_to_texture;
 use crate::{
     render_asset::{PrepareAssetError, RenderAsset},
     render_resource::{Sampler, Texture, TextureView},
-    renderer::{RenderDevice, RenderQueue},
+    renderer::{GpuDevice, GpuQueue},
     texture::BevyDefault,
 };
 use bevy_ecs::system::{lifetimeless::SRes, SystemParamItem};
@@ -350,7 +350,7 @@ pub struct GpuImage {
 impl RenderAsset for Image {
     type ExtractedAsset = Image;
     type PreparedAsset = GpuImage;
-    type Param = (SRes<RenderDevice>, SRes<RenderQueue>);
+    type Param = (SRes<GpuDevice>, SRes<GpuQueue>);
 
     fn extract_asset(&self) -> Self::ExtractedAsset {
         self.clone()
diff --git a/pipelined/bevy_render2/src/texture/texture_cache.rs b/pipelined/bevy_render2/src/texture/texture_cache.rs
index 3b9ebe7b1a494..b0a2475d01917 100644
--- a/pipelined/bevy_render2/src/texture/texture_cache.rs
+++ b/pipelined/bevy_render2/src/texture/texture_cache.rs
@@ -1,6 +1,6 @@
 use crate::{
     render_resource::{Texture, TextureView},
-    renderer::RenderDevice,
+    renderer::GpuDevice,
 };
 use bevy_ecs::prelude::ResMut;
 use bevy_utils::HashMap;
@@ -26,7 +26,7 @@ pub struct TextureCache {
 impl TextureCache {
     pub fn get(
         &mut self,
-        render_device: &RenderDevice,
+        gpu_device: &GpuDevice,
         descriptor: TextureDescriptor<'static>,
     ) -> CachedTexture {
         match self.textures.entry(descriptor) {
@@ -42,7 +42,7 @@ impl TextureCache {
                     }
                 }
 
-                let texture = render_device.create_texture(&entry.key().clone());
+                let texture = gpu_device.create_texture(&entry.key().clone());
                 let default_view = texture.create_view(&TextureViewDescriptor::default());
                 entry.get_mut().push(CachedTextureMeta {
                     texture: texture.clone(),
@@ -56,7 +56,7 @@ impl TextureCache {
                 }
             }
             std::collections::hash_map::Entry::Vacant(entry) => {
-                let texture = render_device.create_texture(entry.key());
+                let texture = gpu_device.create_texture(entry.key());
                 let default_view = texture.create_view(&TextureViewDescriptor::default());
                 entry.insert(vec![CachedTextureMeta {
                     texture: texture.clone(),
diff --git a/pipelined/bevy_render2/src/view/mod.rs b/pipelined/bevy_render2/src/view/mod.rs
index 94d98bba85019..71c775fcbbde6 100644
--- a/pipelined/bevy_render2/src/view/mod.rs
+++ b/pipelined/bevy_render2/src/view/mod.rs
@@ -4,7 +4,7 @@ pub use window::*;
 
 use crate::{
     render_resource::DynamicUniformVec,
-    renderer::{RenderDevice, RenderQueue},
+    renderer::{GpuDevice, GpuQueue},
     RenderApp, RenderStage,
 };
 use bevy_app::{App, Plugin};
@@ -48,14 +48,14 @@ pub struct ViewUniformOffset {
 
 fn prepare_views(
     mut commands: Commands,
-    render_device: Res<RenderDevice>,
-    render_queue: Res<RenderQueue>,
+    gpu_device: Res<GpuDevice>,
+    gpu_queue: Res<GpuQueue>,
     mut view_uniforms: ResMut<ViewUniforms>,
     mut extracted_views: Query<(Entity, &ExtractedView)>,
 ) {
     view_uniforms
         .uniforms
-        .reserve_and_clear(extracted_views.iter_mut().len(), &render_device);
+        .reserve_and_clear(extracted_views.iter_mut().len(), &gpu_device);
     for (entity, camera) in extracted_views.iter() {
         let projection = camera.projection;
         let view_uniforms = ViewUniformOffset {
@@ -69,5 +69,5 @@ fn prepare_views(
         commands.entity(entity).insert(view_uniforms);
     }
 
-    view_uniforms.uniforms.write_buffer(&render_queue);
+    view_uniforms.uniforms.write_buffer(&gpu_queue);
 }
diff --git a/pipelined/bevy_render2/src/view/window.rs b/pipelined/bevy_render2/src/view/window.rs
index 82d5bc6047657..a433ba6656ad5 100644
--- a/pipelined/bevy_render2/src/view/window.rs
+++ b/pipelined/bevy_render2/src/view/window.rs
@@ -1,6 +1,6 @@
 use crate::{
     render_resource::TextureView,
-    renderer::{RenderDevice, RenderInstance},
+    renderer::{GpuDevice, GpuInstance},
     texture::BevyDefault,
     RenderApp, RenderStage, RenderWorld,
 };
@@ -109,8 +109,8 @@ pub fn prepare_windows(
     _marker: NonSend<NonSendMarker>,
     mut windows: ResMut<ExtractedWindows>,
     mut window_surfaces: ResMut<WindowSurfaces>,
-    render_device: Res<RenderDevice>,
-    render_instance: Res<RenderInstance>,
+    gpu_device: Res<GpuDevice>,
+    gpu_instance: Res<GpuInstance>,
 ) {
     let window_surfaces = window_surfaces.deref_mut();
     for window in windows.windows.values_mut() {
@@ -119,7 +119,7 @@ pub fn prepare_windows(
             .entry(window.id)
             .or_insert_with(|| unsafe {
                 // NOTE: On some OSes this MUST be called from the main thread.
-                render_instance.create_surface(&window.handle.get_handle())
+                gpu_instance.create_surface(&window.handle.get_handle())
             });
 
         let swap_chain_descriptor = wgpu::SwapChainDescriptor {
@@ -137,20 +137,19 @@ pub fn prepare_windows(
         if window.size_changed {
             window_surfaces.swap_chains.insert(
                 window.id,
-                render_device.create_swap_chain(surface, &swap_chain_descriptor),
+                gpu_device.create_swap_chain(surface, &swap_chain_descriptor),
             );
         }
 
         let swap_chain = window_surfaces
             .swap_chains
             .entry(window.id)
-            .or_insert_with(|| render_device.create_swap_chain(surface, &swap_chain_descriptor));
+            .or_insert_with(|| gpu_device.create_swap_chain(surface, &swap_chain_descriptor));
 
         let frame = match swap_chain.get_current_frame() {
             Ok(swap_chain_frame) => swap_chain_frame,
             Err(wgpu::SwapChainError::Outdated) => {
-                let new_swap_chain =
-                    render_device.create_swap_chain(surface, &swap_chain_descriptor);
+                let new_swap_chain = gpu_device.create_swap_chain(surface, &swap_chain_descriptor);
                 let frame = new_swap_chain
                     .get_current_frame()
                     .expect("Error recreating swap chain");
diff --git a/pipelined/bevy_sprite2/src/render/mod.rs b/pipelined/bevy_sprite2/src/render/mod.rs
index 01d08bc1f5dff..ce58fe693fca4 100644
--- a/pipelined/bevy_sprite2/src/render/mod.rs
+++ b/pipelined/bevy_sprite2/src/render/mod.rs
@@ -15,7 +15,7 @@ use bevy_render2::{
     render_graph::{Node, NodeRunError, RenderGraphContext},
     render_phase::{Draw, DrawFunctions, RenderPhase, TrackedRenderPass},
     render_resource::*,
-    renderer::{RenderContext, RenderDevice},
+    renderer::{GpuContext, GpuDevice},
     shader::Shader,
     texture::{BevyDefault, Image},
     view::{ViewUniformOffset, ViewUniforms},
@@ -33,11 +33,11 @@ pub struct SpriteShaders {
 // 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_device = world.get_resource::<RenderDevice>().unwrap();
+        let gpu_device = world.get_resource::<GpuDevice>().unwrap();
         let shader = Shader::from_wgsl(include_str!("sprite.wgsl"));
-        let shader_module = render_device.create_shader_module(&shader);
+        let shader_module = gpu_device.create_shader_module(&shader);
 
-        let view_layout = render_device.create_bind_group_layout(&BindGroupLayoutDescriptor {
+        let view_layout = gpu_device.create_bind_group_layout(&BindGroupLayoutDescriptor {
             entries: &[BindGroupLayoutEntry {
                 binding: 0,
                 visibility: ShaderStage::VERTEX | ShaderStage::FRAGMENT,
@@ -53,7 +53,7 @@ impl FromWorld for SpriteShaders {
             label: None,
         });
 
-        let material_layout = render_device.create_bind_group_layout(&BindGroupLayoutDescriptor {
+        let material_layout = gpu_device.create_bind_group_layout(&BindGroupLayoutDescriptor {
             entries: &[
                 BindGroupLayoutEntry {
                     binding: 0,
@@ -78,13 +78,13 @@ impl FromWorld for SpriteShaders {
             label: None,
         });
 
-        let pipeline_layout = render_device.create_pipeline_layout(&PipelineLayoutDescriptor {
+        let pipeline_layout = gpu_device.create_pipeline_layout(&PipelineLayoutDescriptor {
             label: None,
             push_constant_ranges: &[],
             bind_group_layouts: &[&view_layout, &material_layout],
         });
 
-        let pipeline = render_device.create_render_pipeline(&RenderPipelineDescriptor {
+        let pipeline = gpu_device.create_render_pipeline(&RenderPipelineDescriptor {
             label: None,
             depth_stencil: None,
             vertex: VertexState {
@@ -245,7 +245,7 @@ impl Default for SpriteMeta {
 }
 
 pub fn prepare_sprites(
-    render_device: Res<RenderDevice>,
+    gpu_device: Res<GpuDevice>,
     mut sprite_meta: ResMut<SpriteMeta>,
     mut extracted_sprites: Query<&mut ExtractedSprite>,
 ) {
@@ -275,11 +275,11 @@ pub fn prepare_sprites(
 
     sprite_meta.vertices.reserve_and_clear(
         extracted_sprite_len * quad_vertex_positions.len(),
-        &render_device,
+        &gpu_device,
     );
     sprite_meta
         .indices
-        .reserve_and_clear(extracted_sprite_len * quad_indices.len(), &render_device);
+        .reserve_and_clear(extracted_sprite_len * quad_indices.len(), &gpu_device);
 
     for (i, mut extracted_sprite) in extracted_sprites.iter_mut().enumerate() {
         let sprite_rect = extracted_sprite.rect;
@@ -312,8 +312,8 @@ pub fn prepare_sprites(
         }
     }
 
-    sprite_meta.vertices.write_to_staging_buffer(&render_device);
-    sprite_meta.indices.write_to_staging_buffer(&render_device);
+    sprite_meta.vertices.write_to_staging_buffer(&gpu_device);
+    sprite_meta.indices.write_to_staging_buffer(&gpu_device);
 }
 
 #[derive(Default)]
@@ -324,7 +324,7 @@ pub struct ImageBindGroups {
 #[allow(clippy::too_many_arguments)]
 pub fn queue_sprites(
     draw_functions: Res<DrawFunctions<Transparent2d>>,
-    render_device: Res<RenderDevice>,
+    gpu_device: Res<GpuDevice>,
     mut sprite_meta: ResMut<SpriteMeta>,
     view_uniforms: Res<ViewUniforms>,
     sprite_shaders: Res<SpriteShaders>,
@@ -334,7 +334,7 @@ pub fn queue_sprites(
     mut views: Query<&mut RenderPhase<Transparent2d>>,
 ) {
     if let Some(view_binding) = view_uniforms.uniforms.binding() {
-        sprite_meta.view_bind_group = Some(render_device.create_bind_group(&BindGroupDescriptor {
+        sprite_meta.view_bind_group = Some(gpu_device.create_bind_group(&BindGroupDescriptor {
             entries: &[BindGroupEntry {
                 binding: 0,
                 resource: view_binding,
@@ -350,7 +350,7 @@ pub fn queue_sprites(
                     .entry(sprite.handle.clone_weak())
                     .or_insert_with(|| {
                         let gpu_image = gpu_images.get(&sprite.handle).unwrap();
-                        render_device.create_bind_group(&BindGroupDescriptor {
+                        gpu_device.create_bind_group(&BindGroupDescriptor {
                             entries: &[
                                 BindGroupEntry {
                                     binding: 0,
@@ -382,16 +382,16 @@ impl Node for SpriteNode {
     fn run(
         &self,
         _graph: &mut RenderGraphContext,
-        render_context: &mut RenderContext,
+        gpu_context: &mut GpuContext,
         world: &World,
     ) -> Result<(), NodeRunError> {
         let sprite_buffers = world.get_resource::<SpriteMeta>().unwrap();
         sprite_buffers
             .vertices
-            .write_to_buffer(&mut render_context.command_encoder);
+            .write_to_buffer(&mut gpu_context.command_encoder);
         sprite_buffers
             .indices
-            .write_to_buffer(&mut render_context.command_encoder);
+            .write_to_buffer(&mut gpu_context.command_encoder);
         Ok(())
     }
 }