diff --git a/zsw-egui/src/lib.rs b/zsw-egui/src/lib.rs
index c2ffebe..26cea7f 100644
--- a/zsw-egui/src/lib.rs
+++ b/zsw-egui/src/lib.rs
@@ -10,7 +10,7 @@ use {
 	tokio::sync::Mutex,
 	tracing as _,
 	winit::window::Window,
-	zsw_wgpu::{FrameRender, WgpuRenderer, WgpuShared},
+	zsw_wgpu::{FrameRender, WgpuRenderer, Wgpu},
 	app_error::Context, zsw_util::AppError,
 };
 
@@ -29,10 +29,10 @@ impl fmt::Debug for EguiRenderer {
 impl EguiRenderer {
 	/// Creates a new egui renderer
 	#[must_use]
-	pub fn new(wgpu_renderer: &WgpuRenderer, wgpu_shared: &WgpuShared) -> Self {
+	pub fn new(wgpu_renderer: &WgpuRenderer, wgpu: &Wgpu) -> Self {
 		// Create the egui render pass
 		let render_pass =
-			egui_wgpu_backend::RenderPass::new(&wgpu_shared.device, wgpu_renderer.surface_config().format, 1);
+			egui_wgpu_backend::RenderPass::new(&wgpu.device, wgpu_renderer.surface_config().format, 1);
 
 		Self { render_pass }
 	}
@@ -42,7 +42,7 @@ impl EguiRenderer {
 		&mut self,
 		frame: &mut FrameRender,
 		window: &Window,
-		wgpu_shared: &WgpuShared,
+		wgpu: &Wgpu,
 		paint_jobs: &[egui::ClippedPrimitive],
 		textures_delta: Option<egui::TexturesDelta>,
 	) -> Result<(), AppError> {
@@ -57,13 +57,13 @@ impl EguiRenderer {
 		// If we have any textures delta, update them
 		if let Some(textures_delta) = textures_delta.as_ref() {
 			self.render_pass
-				.add_textures(&wgpu_shared.device, &wgpu_shared.queue, textures_delta)
+				.add_textures(&wgpu.device, &wgpu.queue, textures_delta)
 				.context("Unable to update textures")?;
 		}
 
 		// Update buffers
 		self.render_pass
-			.update_buffers(&wgpu_shared.device, &wgpu_shared.queue, paint_jobs, &screen_descriptor);
+			.update_buffers(&wgpu.device, &wgpu.queue, paint_jobs, &screen_descriptor);
 
 		// Record all render passes.
 		self.render_pass
diff --git a/zsw-wgpu/src/lib.rs b/zsw-wgpu/src/lib.rs
index f4bb933..d51fc26 100644
--- a/zsw-wgpu/src/lib.rs
+++ b/zsw-wgpu/src/lib.rs
@@ -12,9 +12,9 @@ pub use renderer::{FrameRender, WgpuRenderer};
 // Imports
 use {app_error::Context, tokio::sync::OnceCell, zsw_util::AppError};
 
-/// Wgpu shared
+/// Wgpu
 #[derive(Debug)]
-pub struct WgpuShared {
+pub struct Wgpu {
 	/// Instance
 	pub instance: wgpu::Instance,
 
@@ -34,34 +34,33 @@ pub struct WgpuShared {
 	pub empty_texture_view: wgpu::TextureView,
 }
 
-/// Shared
+/// Wgpu
 // TODO: Is it a good idea to make this a global?
 //       Realistically, we can only have one per process anyway,
 //       so this models that correctly, but it might be bad API.
-static SHARED: OnceCell<WgpuShared> = OnceCell::const_new();
+static WGPU: OnceCell<Wgpu> = OnceCell::const_new();
 
-/// Gets or creates the shared state
-pub async fn get_or_create_shared() -> Result<&'static WgpuShared, AppError> {
-	SHARED
-		.get_or_try_init(async || {
-			let instance = self::create_instance().context("Unable to create instance")?;
-			let adapter = self::create_adapter(&instance)
-				.await
-				.context("Unable to create adaptor")?;
-			let (device, queue) = self::create_device(&adapter).await.context("Unable to create device")?;
+/// Gets or creates the wgpu
+pub async fn get_or_create() -> Result<&'static Wgpu, AppError> {
+	WGPU.get_or_try_init(async || {
+		let instance = self::create_instance().context("Unable to create instance")?;
+		let adapter = self::create_adapter(&instance)
+			.await
+			.context("Unable to create adaptor")?;
+		let (device, queue) = self::create_device(&adapter).await.context("Unable to create device")?;
 
-			let (empty_texture, empty_texture_view) = self::create_empty_image_texture(&device);
+		let (empty_texture, empty_texture_view) = self::create_empty_image_texture(&device);
 
-			Ok::<_, AppError>(WgpuShared {
-				instance,
-				adapter,
-				device,
-				queue,
-				empty_texture,
-				empty_texture_view,
-			})
+		Ok::<_, AppError>(Wgpu {
+			instance,
+			adapter,
+			device,
+			queue,
+			empty_texture,
+			empty_texture_view,
 		})
-		.await
+	})
+	.await
 }
 
 /// Creates the device
diff --git a/zsw-wgpu/src/renderer.rs b/zsw-wgpu/src/renderer.rs
index 4d43350..41a87fd 100644
--- a/zsw-wgpu/src/renderer.rs
+++ b/zsw-wgpu/src/renderer.rs
@@ -2,7 +2,7 @@
 
 // Imports
 use {
-	super::WgpuShared,
+	super::Wgpu,
 	app_error::Context,
 	std::sync::Arc,
 	winit::{dpi::PhysicalSize, window::Window},
@@ -34,15 +34,15 @@ pub struct WgpuRenderer {
 }
 
 impl WgpuRenderer {
-	pub fn new(window: Arc<Window>, shared: &WgpuShared) -> Result<Self, AppError> {
+	pub fn new(window: Arc<Window>, wgpu: &Wgpu) -> Result<Self, AppError> {
 		// Create the surface
 		// SAFETY: We keep an `Arc<Window>` that we only drop
 		//         *after* dropping the surface.
-		let surface = unsafe { self::create_surface(shared, &window) }?;
+		let surface = unsafe { self::create_surface(wgpu, &window) }?;
 
 		// Configure the surface and get the preferred texture format and surface size
 		let surface_size = window.inner_size();
-		let surface_config = self::configure_window_surface(shared, &surface, surface_size)
+		let surface_config = self::configure_window_surface(wgpu, &surface, surface_size)
 			.context("Unable to configure window surface")?;
 
 		Ok(Self {
@@ -69,7 +69,7 @@ impl WgpuRenderer {
 	///
 	/// Returns the encoder and surface view to render onto
 	// TODO: Ensure it's not called more than once?
-	pub fn start_render(&self, shared: &WgpuShared) -> Result<FrameRender, AppError> {
+	pub fn start_render(&self, wgpu: &Wgpu) -> Result<FrameRender, AppError> {
 		// And then get the surface texture
 		// Note: This can block, so we run it under tokio's block-in-place
 		// Note: If the application goes to sleep, this can fail spuriously due to a timeout,
@@ -96,7 +96,7 @@ impl WgpuRenderer {
 		let encoder_descriptor = wgpu::CommandEncoderDescriptor {
 			label: Some("[zsw] Frame render command encoder"),
 		};
-		let encoder = shared.device.create_command_encoder(&encoder_descriptor);
+		let encoder = wgpu.device.create_command_encoder(&encoder_descriptor);
 
 		Ok(FrameRender {
 			encoder,
@@ -107,7 +107,7 @@ impl WgpuRenderer {
 	}
 
 	/// Re-configures the surface
-	pub fn reconfigure(&mut self, shared: &WgpuShared) -> Result<(), AppError> {
+	pub fn reconfigure(&mut self, wgpu: &Wgpu) -> Result<(), AppError> {
 		tracing::info!(
 			"Reconfiguring wgpu surface to {}x{}",
 			self.surface_size.width,
@@ -115,14 +115,14 @@ impl WgpuRenderer {
 		);
 
 		// Update our surface
-		self.surface_config = self::configure_window_surface(shared, &self.surface, self.surface_size)
+		self.surface_config = self::configure_window_surface(wgpu, &self.surface, self.surface_size)
 			.context("Unable to configure window surface")?;
 
 		Ok(())
 	}
 
 	/// Performs a resize
-	pub fn resize(&mut self, shared: &WgpuShared, size: PhysicalSize<u32>) -> Result<(), AppError> {
+	pub fn resize(&mut self, wgpu: &Wgpu, size: PhysicalSize<u32>) -> Result<(), AppError> {
 		tracing::info!(
 			"Resizing wgpu surface to {}x{}",
 			self.surface_size.width,
@@ -132,7 +132,7 @@ impl WgpuRenderer {
 		// TODO: Don't ignore resizes to the same size?
 		if size.width > 0 && size.height > 0 && size != self.surface_size {
 			// Update our surface
-			self.surface_config = self::configure_window_surface(shared, &self.surface, size)
+			self.surface_config = self::configure_window_surface(wgpu, &self.surface, size)
 				.context("Unable to configure window surface")?;
 			self.surface_size = size;
 		}
@@ -162,11 +162,11 @@ impl FrameRender {
 	///
 	/// Returns if a reconfigure is needed
 	#[must_use]
-	pub fn finish(self, shared: &WgpuShared) -> bool {
+	pub fn finish(self, wgpu: &Wgpu) -> bool {
 		// Submit everything to the queue and present the surface's texture
 		// Note: Although not supposed to, `submit` calls can block, so we wrap it
 		//       in a tokio block-in-place
-		let _ = tokio::task::block_in_place(|| shared.queue.submit([self.encoder.finish()]));
+		let _ = tokio::task::block_in_place(|| wgpu.queue.submit([self.encoder.finish()]));
 		let reconfigure = self.surface_texture.suboptimal;
 		self.surface_texture.present();
 
@@ -176,13 +176,13 @@ impl FrameRender {
 
 /// Configures the window surface and returns the configuration
 fn configure_window_surface(
-	shared: &WgpuShared,
+	wgpu: &Wgpu,
 	surface: &wgpu::Surface<'static>,
 	size: PhysicalSize<u32>,
 ) -> Result<wgpu::SurfaceConfiguration, AppError> {
 	// Get the format
 	let mut config = surface
-		.get_default_config(&shared.adapter, size.width, size.height)
+		.get_default_config(&wgpu.adapter, size.width, size.height)
 		.context("Unable to get surface default config")?;
 	tracing::debug!(?config, "Found surface configuration");
 
@@ -192,7 +192,7 @@ fn configure_window_surface(
 	tracing::debug!(?config, "Updated surface configuration");
 
 	// Then configure it
-	surface.configure(&shared.device, &config);
+	surface.configure(&wgpu.device, &config);
 
 	Ok(config)
 }
@@ -201,13 +201,13 @@ fn configure_window_surface(
 ///
 /// # Safety
 /// The returned surface *must* be dropped before the window.
-unsafe fn create_surface(shared: &WgpuShared, window: &Window) -> Result<wgpu::Surface<'static>, AppError> {
+unsafe fn create_surface(wgpu: &Wgpu, window: &Window) -> Result<wgpu::Surface<'static>, AppError> {
 	// Create the surface
 	tracing::debug!(?window, "Requesting wgpu surface");
 	// SAFETY: User ensures that the surface is dropped before the window.
 	let target = unsafe { wgpu::SurfaceTargetUnsafe::from_window(window) }.context("Unable to get window target")?;
 	// SAFETY: User ensures that the surface is dropped before the window.
-	let surface = unsafe { shared.instance.create_surface_unsafe(target) }.context("Unable to request surface")?;
+	let surface = unsafe { wgpu.instance.create_surface_unsafe(target) }.context("Unable to request surface")?;
 	tracing::debug!(?surface, "Created wgpu surface");
 
 	Ok(surface)
diff --git a/zsw/src/main.rs b/zsw/src/main.rs
index 7b0b4c9..c3fca4e 100644
--- a/zsw/src/main.rs
+++ b/zsw/src/main.rs
@@ -168,10 +168,8 @@ impl WinitApp {
 		config_dirs: Arc<ConfigDirs>,
 		event_loop_proxy: winit::event_loop::EventLoopProxy<AppEvent>,
 	) -> Result<Self, AppError> {
-		let wgpu_shared = zsw_wgpu::get_or_create_shared()
-			.await
-			.context("Unable to initialize wgpu")?;
-		let panels_renderer_layouts = PanelsRendererLayouts::new(wgpu_shared);
+		let wgpu = zsw_wgpu::get_or_create().await.context("Unable to initialize wgpu")?;
+		let panels_renderer_layouts = PanelsRendererLayouts::new(wgpu);
 
 		let playlists = Playlists::new(config_dirs.playlists().to_path_buf());
 		let panels = Panels::new(config_dirs.panels().to_path_buf());
@@ -182,7 +180,7 @@ impl WinitApp {
 			last_resize: AtomicCell::new(None),
 			// TODO: Not have a default of (0,0)?
 			cursor_pos: AtomicCell::new(PhysicalPosition::new(0.0, 0.0)),
-			wgpu: wgpu_shared,
+			wgpu,
 			panels_renderer_layouts,
 			panels,
 			playlists: Arc::new(playlists),
diff --git a/zsw/src/panel/images.rs b/zsw/src/panel/images.rs
index ad17353..18c1db7 100644
--- a/zsw/src/panel/images.rs
+++ b/zsw/src/panel/images.rs
@@ -14,7 +14,7 @@ use {
 	std::{self, mem, path::Path, sync::Arc},
 	tracing::Instrument,
 	zsw_util::{AppError, Loadable, loadable::Loader},
-	zsw_wgpu::WgpuShared,
+	zsw_wgpu::Wgpu,
 	zutil_cloned::cloned,
 };
 
@@ -76,13 +76,13 @@ impl PanelFadeImages {
 	/// If successful, starts loading any missing images
 	///
 	/// Returns `Err(())` if this would erase the current image.
-	pub fn step_prev(&mut self, playlist_player: &mut PlaylistPlayer, wgpu_shared: &WgpuShared) -> Result<(), ()> {
+	pub fn step_prev(&mut self, playlist_player: &mut PlaylistPlayer, wgpu: &Wgpu) -> Result<(), ()> {
 		playlist_player.step_prev()?;
 		mem::swap(&mut self.cur, &mut self.next);
 		mem::swap(&mut self.prev, &mut self.cur);
 		self.prev = PanelFadeImage::empty();
 		self.image_bind_group = None;
-		self.load_missing(playlist_player, wgpu_shared);
+		self.load_missing(playlist_player, wgpu);
 
 		Ok(())
 	}
@@ -92,7 +92,7 @@ impl PanelFadeImages {
 	/// If successful, starts loading any missing images
 	///
 	/// Returns `Err(())` if this would erase the current image.
-	pub fn step_next(&mut self, playlist_player: &mut PlaylistPlayer, wgpu_shared: &WgpuShared) -> Result<(), ()> {
+	pub fn step_next(&mut self, playlist_player: &mut PlaylistPlayer, wgpu: &Wgpu) -> Result<(), ()> {
 		if !self.next.is_loaded() {
 			return Err(());
 		}
@@ -102,7 +102,7 @@ impl PanelFadeImages {
 		mem::swap(&mut self.cur, &mut self.next);
 		self.next = PanelFadeImage::empty();
 		self.image_bind_group = None;
-		self.load_missing(playlist_player, wgpu_shared);
+		self.load_missing(playlist_player, wgpu);
 
 		Ok(())
 	}
@@ -110,9 +110,9 @@ impl PanelFadeImages {
 	/// Loads any missing images, prioritizing the current, then next, then previous.
 	///
 	/// Requests images if missing any.
-	pub fn load_missing(&mut self, playlist_player: &mut PlaylistPlayer, wgpu_shared: &WgpuShared) {
+	pub fn load_missing(&mut self, playlist_player: &mut PlaylistPlayer, wgpu: &Wgpu) {
 		// Get the next image, if we can
-		let Some(res) = self.next_image(playlist_player, wgpu_shared) else {
+		let Some(res) = self.next_image(playlist_player, wgpu) else {
 			return;
 		};
 
@@ -130,7 +130,7 @@ impl PanelFadeImages {
 				);
 				playlist_player.remove(&res.path);
 
-				_ = self.schedule_load_image(playlist_player, wgpu_shared);
+				_ = self.schedule_load_image(playlist_player, wgpu);
 				return;
 			},
 		};
@@ -154,9 +154,9 @@ impl PanelFadeImages {
 
 		if let Some(slot) = slot {
 			match slot {
-				Slot::Prev => self.prev = PanelFadeImage::new(wgpu_shared, res.path, image),
-				Slot::Cur => self.cur = PanelFadeImage::new(wgpu_shared, res.path, image),
-				Slot::Next => self.next = PanelFadeImage::new(wgpu_shared, res.path, image),
+				Slot::Prev => self.prev = PanelFadeImage::new(wgpu, res.path, image),
+				Slot::Cur => self.cur = PanelFadeImage::new(wgpu, res.path, image),
+				Slot::Next => self.next = PanelFadeImage::new(wgpu, res.path, image),
 			}
 			self.image_bind_group = None;
 		}
@@ -166,20 +166,16 @@ impl PanelFadeImages {
 	///
 	/// If an image is not scheduled, schedules it, even after
 	/// successfully returning an image
-	fn next_image(&mut self, playlist_player: &mut PlaylistPlayer, wgpu_shared: &WgpuShared) -> Option<ImageLoadRes> {
+	fn next_image(&mut self, playlist_player: &mut PlaylistPlayer, wgpu: &Wgpu) -> Option<ImageLoadRes> {
 		// Schedule it and try to take any existing image result
-		_ = self.schedule_load_image(playlist_player, wgpu_shared);
+		_ = self.schedule_load_image(playlist_player, wgpu);
 		self.next_image.take()
 	}
 
 	/// Schedules a new image.
 	///
 	/// If the image is loaded, returns it
-	fn schedule_load_image(
-		&mut self,
-		playlist_player: &mut PlaylistPlayer,
-		wgpu_shared: &WgpuShared,
-	) -> Option<&mut ImageLoadRes> {
+	fn schedule_load_image(&mut self, playlist_player: &mut PlaylistPlayer, wgpu: &Wgpu) -> Option<&mut ImageLoadRes> {
 		// If we're loaded, just return it
 		// Note: We can't use if-let due to a borrow-checker limitation
 		if self.next_image.get().is_some() {
@@ -194,7 +190,7 @@ impl PanelFadeImages {
 			() => return None,
 		};
 
-		let max_image_size = wgpu_shared.device.limits().max_texture_dimension_2d;
+		let max_image_size = wgpu.device.limits().max_texture_dimension_2d;
 
 		self.next_image.try_load((NextImageArgs {
 			playlist_pos,
diff --git a/zsw/src/panel/images/image.rs b/zsw/src/panel/images/image.rs
index 08791f7..51e485f 100644
--- a/zsw/src/panel/images/image.rs
+++ b/zsw/src/panel/images/image.rs
@@ -6,7 +6,7 @@ use {
 	image::DynamicImage,
 	std::{path::Path, sync::Arc},
 	wgpu::util::DeviceExt,
-	zsw_wgpu::WgpuShared,
+	zsw_wgpu::Wgpu,
 };
 
 /// Panel's fade image
@@ -45,9 +45,9 @@ impl PanelFadeImage {
 
 	/// Creates a new panel image from an image
 	#[must_use]
-	pub fn new(wgpu_shared: &WgpuShared, image_path: Arc<Path>, image: DynamicImage) -> Self {
+	pub fn new(wgpu: &Wgpu, image_path: Arc<Path>, image: DynamicImage) -> Self {
 		let size = Vector2::new(image.width(), image.height());
-		let (texture, texture_view) = self::create_image_texture(wgpu_shared, &image_path, image);
+		let (texture, texture_view) = self::create_image_texture(wgpu, &image_path, image);
 
 		Self::Loaded {
 			_texture: texture,
@@ -59,9 +59,9 @@ impl PanelFadeImage {
 	}
 
 	/// Returns the texture view for this image.
-	pub fn texture_view<'a>(&'a self, wgpu_shared: &'a WgpuShared) -> &'a wgpu::TextureView {
+	pub fn texture_view<'a>(&'a self, wgpu: &'a Wgpu) -> &'a wgpu::TextureView {
 		match self {
-			Self::Empty => &wgpu_shared.empty_texture_view,
+			Self::Empty => &wgpu.empty_texture_view,
 			Self::Loaded { texture_view, .. } => texture_view,
 		}
 	}
@@ -73,11 +73,7 @@ impl PanelFadeImage {
 }
 
 /// Creates the image texture and view
-fn create_image_texture(
-	wgpu_shared: &WgpuShared,
-	image_path: &Path,
-	image: DynamicImage,
-) -> (wgpu::Texture, wgpu::TextureView) {
+fn create_image_texture(wgpu: &Wgpu, image_path: &Path, image: DynamicImage) -> (wgpu::Texture, wgpu::TextureView) {
 	// Get the image's format, converting if necessary.
 	let (image, format) = match image {
 		// With `rgba8` we can simply use the image
@@ -93,7 +89,7 @@ fn create_image_texture(
 	};
 
 	// Note: The image loader should ensure the image is the right size.
-	let limits = wgpu_shared.device.limits();
+	let limits = wgpu.device.limits();
 	let max_image_size = limits.max_texture_dimension_2d;
 	let image_width = image.width();
 	let image_height = image.height();
@@ -117,8 +113,8 @@ fn create_image_texture(
 		// TODO: Pass some view formats?
 		view_formats: &[],
 	};
-	let texture = wgpu_shared.device.create_texture_with_data(
-		&wgpu_shared.queue,
+	let texture = wgpu.device.create_texture_with_data(
+		&wgpu.queue,
 		&texture_descriptor,
 		wgpu::util::TextureDataOrder::LayerMajor,
 		image.as_bytes(),
diff --git a/zsw/src/panel/renderer.rs b/zsw/src/panel/renderer.rs
index c4132e0..a588f72 100644
--- a/zsw/src/panel/renderer.rs
+++ b/zsw/src/panel/renderer.rs
@@ -21,7 +21,7 @@ use {
 	wgpu::util::DeviceExt,
 	winit::{dpi::PhysicalSize, window::Window},
 	zsw_util::{AppError, Rect},
-	zsw_wgpu::{FrameRender, WgpuRenderer, WgpuShared},
+	zsw_wgpu::{FrameRender, WgpuRenderer, Wgpu},
 };
 
 /// Panels renderer layouts
@@ -37,9 +37,9 @@ pub struct PanelsRendererLayouts {
 
 impl PanelsRendererLayouts {
 	/// Creates new layouts for the panels renderer
-	pub fn new(wgpu_shared: &WgpuShared) -> Self {
-		let uniforms_bind_group_layout = self::create_uniforms_bind_group_layout(wgpu_shared);
-		let fade_image_bind_group_layout = self::create_fade_image_bind_group_layout(wgpu_shared);
+	pub fn new(wgpu: &Wgpu) -> Self {
+		let uniforms_bind_group_layout = self::create_uniforms_bind_group_layout(wgpu);
+		let fade_image_bind_group_layout = self::create_fade_image_bind_group_layout(wgpu);
 
 		Self {
 			uniforms_bind_group_layout,
@@ -81,14 +81,14 @@ pub struct PanelsRenderer {
 
 impl PanelsRenderer {
 	/// Creates a new renderer for the panels
-	pub fn new(wgpu_renderer: &WgpuRenderer, wgpu_shared: &WgpuShared, msaa_samples: u32) -> Result<Self, AppError> {
+	pub fn new(wgpu_renderer: &WgpuRenderer, wgpu: &Wgpu, msaa_samples: u32) -> Result<Self, AppError> {
 		// Create the index / vertex buffer
-		let indices = self::create_indices(wgpu_shared);
-		let vertices = self::create_vertices(wgpu_shared);
+		let indices = self::create_indices(wgpu);
+		let vertices = self::create_vertices(wgpu);
 
 		// Create the framebuffer
 		let msaa_framebuffer =
-			self::create_msaa_framebuffer(wgpu_renderer, wgpu_shared, wgpu_renderer.surface_size(), msaa_samples);
+			self::create_msaa_framebuffer(wgpu_renderer, wgpu, wgpu_renderer.surface_size(), msaa_samples);
 
 		Ok(Self {
 			render_pipelines: HashMap::new(),
@@ -100,9 +100,9 @@ impl PanelsRenderer {
 	}
 
 	/// Resizes the buffer
-	pub fn resize(&mut self, wgpu_renderer: &WgpuRenderer, wgpu_shared: &WgpuShared, size: PhysicalSize<u32>) {
+	pub fn resize(&mut self, wgpu_renderer: &WgpuRenderer, wgpu: &Wgpu, size: PhysicalSize<u32>) {
 		tracing::debug!("Resizing msaa framebuffer to {}x{}", size.width, size.height);
-		self.msaa_framebuffer = self::create_msaa_framebuffer(wgpu_renderer, wgpu_shared, size, self.msaa_samples);
+		self.msaa_framebuffer = self::create_msaa_framebuffer(wgpu_renderer, wgpu, size, self.msaa_samples);
 	}
 
 	/// Renders a panel
@@ -111,7 +111,7 @@ impl PanelsRenderer {
 		&mut self,
 		frame: &mut FrameRender,
 		wgpu_renderer: &WgpuRenderer,
-		wgpu_shared: &WgpuShared,
+		wgpu: &Wgpu,
 		layouts: &PanelsRendererLayouts,
 		window_geometry: Rect<i32, u32>,
 		window: &Window,
@@ -168,7 +168,7 @@ impl PanelsRenderer {
 			// Update the panel before drawing it
 			match &mut panel.state {
 				PanelState::None(_) => (),
-				PanelState::Fade(state) => state.update(wgpu_shared),
+				PanelState::Fade(state) => state.update(wgpu),
 			}
 
 			// If the panel images are empty, there's no sense in rendering it either
@@ -193,7 +193,7 @@ impl PanelsRenderer {
 
 					let render_pipeline = self::create_render_pipeline(
 						wgpu_renderer,
-						wgpu_shared,
+						wgpu,
 						bind_group_layouts,
 						panel.state.shader(),
 						self.msaa_samples,
@@ -214,14 +214,14 @@ impl PanelsRenderer {
 					let panel_images = panel_state.images_mut();
 					let image_sampler = panel_images
 						.image_sampler
-						.get_or_insert_with(|| self::create_image_sampler(wgpu_shared));
+						.get_or_insert_with(|| self::create_image_sampler(wgpu));
 					let image_bind_group = panel_images.image_bind_group.get_or_insert_with(|| {
 						self::create_image_bind_group(
-							wgpu_shared,
+							wgpu,
 							&layouts.fade_image_bind_group_layout,
-							panel_images.prev.texture_view(wgpu_shared),
-							panel_images.cur.texture_view(wgpu_shared),
-							panel_images.next.texture_view(wgpu_shared),
+							panel_images.prev.texture_view(wgpu),
+							panel_images.cur.texture_view(wgpu),
+							panel_images.next.texture_view(wgpu),
 							image_sampler,
 						)
 					});
@@ -237,7 +237,7 @@ impl PanelsRenderer {
 
 				// Write and bind the uniforms
 				Self::write_bind_uniforms(
-					wgpu_shared,
+					wgpu,
 					layouts,
 					frame.surface_size,
 					&panel.state,
@@ -257,7 +257,7 @@ impl PanelsRenderer {
 
 	/// Writes and binds the uniforms
 	pub fn write_bind_uniforms(
-		wgpu_shared: &WgpuShared,
+		wgpu: &Wgpu,
 		layouts: &PanelsRendererLayouts,
 		surface_size: PhysicalSize<u32>,
 		panel_state: &PanelState,
@@ -274,9 +274,9 @@ impl PanelsRenderer {
 		let geometry_uniforms = geometry
 			.uniforms
 			.entry(window.id())
-			.or_insert_with(|| self::create_panel_geometry_uniforms(wgpu_shared, layouts));
+			.or_insert_with(|| self::create_panel_geometry_uniforms(wgpu, layouts));
 		let write_uniforms = |uniforms_bytes| {
-			wgpu_shared
+			wgpu
 				.queue
 				.write_buffer(&geometry_uniforms.buffer, 0, uniforms_bytes);
 		};
@@ -355,7 +355,7 @@ impl PanelsRenderer {
 }
 
 /// Creates the panel geometry uniforms
-fn create_panel_geometry_uniforms(wgpu_shared: &WgpuShared, layouts: &PanelsRendererLayouts) -> PanelGeometryUniforms {
+fn create_panel_geometry_uniforms(wgpu: &Wgpu, layouts: &PanelsRendererLayouts) -> PanelGeometryUniforms {
 	// Create the uniforms
 	let buffer_descriptor = wgpu::BufferDescriptor {
 		label:              Some("[zsw::panel] Geometry uniforms buffer"),
@@ -363,7 +363,7 @@ fn create_panel_geometry_uniforms(wgpu_shared: &WgpuShared, layouts: &PanelsRend
 		size:               u64::try_from(MAX_UNIFORM_SIZE).expect("Maximum uniform size didn't fit into a `u64`"),
 		mapped_at_creation: false,
 	};
-	let buffer = wgpu_shared.device.create_buffer(&buffer_descriptor);
+	let buffer = wgpu.device.create_buffer(&buffer_descriptor);
 
 	// Create the uniform bind group
 	let bind_group_descriptor = wgpu::BindGroupDescriptor {
@@ -374,24 +374,24 @@ fn create_panel_geometry_uniforms(wgpu_shared: &WgpuShared, layouts: &PanelsRend
 		}],
 		label:   Some("[zsw::panel] Geometry uniforms bind group"),
 	};
-	let bind_group = wgpu_shared.device.create_bind_group(&bind_group_descriptor);
+	let bind_group = wgpu.device.create_bind_group(&bind_group_descriptor);
 
 	PanelGeometryUniforms { buffer, bind_group }
 }
 
 /// Creates the vertices
-fn create_vertices(wgpu_shared: &WgpuShared) -> wgpu::Buffer {
+fn create_vertices(wgpu: &Wgpu) -> wgpu::Buffer {
 	let descriptor = wgpu::util::BufferInitDescriptor {
 		label:    Some("[zsw::panel] Vertex buffer"),
 		contents: bytemuck::cast_slice(&PanelVertex::QUAD),
 		usage:    wgpu::BufferUsages::VERTEX,
 	};
 
-	wgpu_shared.device.create_buffer_init(&descriptor)
+	wgpu.device.create_buffer_init(&descriptor)
 }
 
 /// Creates the indices
-fn create_indices(wgpu_shared: &WgpuShared) -> wgpu::Buffer {
+fn create_indices(wgpu: &Wgpu) -> wgpu::Buffer {
 	const INDICES: [u32; 6] = [0, 1, 3, 0, 3, 2];
 	let descriptor = wgpu::util::BufferInitDescriptor {
 		label:    Some("[zsw::panel] Index buffer"),
@@ -399,13 +399,13 @@ fn create_indices(wgpu_shared: &WgpuShared) -> wgpu::Buffer {
 		usage:    wgpu::BufferUsages::INDEX,
 	};
 
-	wgpu_shared.device.create_buffer_init(&descriptor)
+	wgpu.device.create_buffer_init(&descriptor)
 }
 
 /// Creates the render pipeline
 fn create_render_pipeline(
 	wgpu_renderer: &WgpuRenderer,
-	wgpu_shared: &WgpuShared,
+	wgpu: &Wgpu,
 	bind_group_layouts: &[&wgpu::BindGroupLayout],
 	shader: PanelShader,
 	msaa_samples: u32,
@@ -422,7 +422,7 @@ fn create_render_pipeline(
 		label:  Some(&format!("[zsw::panel] Shader {shader_name:?}")),
 		source: wgpu::ShaderSource::Naga(Cow::Owned(shader_module)),
 	};
-	let shader = wgpu_shared.device.create_shader_module(shader_descriptor);
+	let shader = wgpu.device.create_shader_module(shader_descriptor);
 
 	// Create the pipeline layout
 	let render_pipeline_layout_descriptor = wgpu::PipelineLayoutDescriptor {
@@ -430,7 +430,7 @@ fn create_render_pipeline(
 		bind_group_layouts,
 		push_constant_ranges: &[],
 	};
-	let render_pipeline_layout = wgpu_shared
+	let render_pipeline_layout = wgpu
 		.device
 		.create_pipeline_layout(&render_pipeline_layout_descriptor);
 
@@ -474,13 +474,13 @@ fn create_render_pipeline(
 		cache:         None,
 	};
 
-	Ok(wgpu_shared.device.create_render_pipeline(&render_pipeline_descriptor))
+	Ok(wgpu.device.create_render_pipeline(&render_pipeline_descriptor))
 }
 
 /// Creates the msaa framebuffer
 fn create_msaa_framebuffer(
 	wgpu_renderer: &WgpuRenderer,
-	wgpu_shared: &WgpuShared,
+	wgpu: &Wgpu,
 	size: PhysicalSize<u32>,
 	msaa_samples: u32,
 ) -> wgpu::TextureView {
@@ -502,14 +502,14 @@ fn create_msaa_framebuffer(
 		view_formats:    &surface_config.view_formats,
 	};
 
-	wgpu_shared
+	wgpu
 		.device
 		.create_texture(&msaa_frame_descriptor)
 		.create_view(&wgpu::TextureViewDescriptor::default())
 }
 
 /// Creates the uniforms bind group layout
-fn create_uniforms_bind_group_layout(wgpu_shared: &WgpuShared) -> wgpu::BindGroupLayout {
+fn create_uniforms_bind_group_layout(wgpu: &Wgpu) -> wgpu::BindGroupLayout {
 	let descriptor = wgpu::BindGroupLayoutDescriptor {
 		label:   Some("[zsw::panel] Geometry uniforms bind group layout"),
 		entries: &[wgpu::BindGroupLayoutEntry {
@@ -524,11 +524,11 @@ fn create_uniforms_bind_group_layout(wgpu_shared: &WgpuShared) -> wgpu::BindGrou
 		}],
 	};
 
-	wgpu_shared.device.create_bind_group_layout(&descriptor)
+	wgpu.device.create_bind_group_layout(&descriptor)
 }
 
 /// Creates the fade image bind group layout
-fn create_fade_image_bind_group_layout(wgpu_shared: &WgpuShared) -> wgpu::BindGroupLayout {
+fn create_fade_image_bind_group_layout(wgpu: &Wgpu) -> wgpu::BindGroupLayout {
 	let descriptor = wgpu::BindGroupLayoutDescriptor {
 		label:   Some("[zsw::panel] Fade image bind group layout"),
 		entries: &[
@@ -571,12 +571,12 @@ fn create_fade_image_bind_group_layout(wgpu_shared: &WgpuShared) -> wgpu::BindGr
 		],
 	};
 
-	wgpu_shared.device.create_bind_group_layout(&descriptor)
+	wgpu.device.create_bind_group_layout(&descriptor)
 }
 
 /// Creates the texture bind group
 fn create_image_bind_group(
-	wgpu_shared: &WgpuShared,
+	wgpu: &Wgpu,
 	bind_group_layout: &wgpu::BindGroupLayout,
 	view_prev: &wgpu::TextureView,
 	view_cur: &wgpu::TextureView,
@@ -605,11 +605,11 @@ fn create_image_bind_group(
 		],
 		label:   Some("[zsw::panel] Image bind group"),
 	};
-	wgpu_shared.device.create_bind_group(&descriptor)
+	wgpu.device.create_bind_group(&descriptor)
 }
 
 /// Creates the image sampler
-fn create_image_sampler(wgpu_shared: &WgpuShared) -> wgpu::Sampler {
+fn create_image_sampler(wgpu: &Wgpu) -> wgpu::Sampler {
 	let descriptor = wgpu::SamplerDescriptor {
 		label: Some("[zsw::panel] Image sampler"),
 		address_mode_u: wgpu::AddressMode::ClampToEdge,
@@ -620,7 +620,7 @@ fn create_image_sampler(wgpu_shared: &WgpuShared) -> wgpu::Sampler {
 		mipmap_filter: wgpu::FilterMode::Linear,
 		..wgpu::SamplerDescriptor::default()
 	};
-	wgpu_shared.device.create_sampler(&descriptor)
+	wgpu.device.create_sampler(&descriptor)
 }
 
 /// Shader
diff --git a/zsw/src/panel/state.rs b/zsw/src/panel/state.rs
index 5599ee1..a8fff64 100644
--- a/zsw/src/panel/state.rs
+++ b/zsw/src/panel/state.rs
@@ -9,7 +9,7 @@ use {
 	core::time::Duration,
 	std::{sync::Arc, time::Instant},
 	zsw_util::{AppError, Loadable, loadable::Loader},
-	zsw_wgpu::WgpuShared,
+	zsw_wgpu::Wgpu,
 	zutil_cloned::cloned,
 };
 
@@ -250,12 +250,12 @@ impl PanelFadeState {
 	/// Skips to the next image.
 	///
 	/// If the playlist player isn't loaded, does nothing
-	pub fn skip(&mut self, wgpu_shared: &WgpuShared) {
+	pub fn skip(&mut self, wgpu: &Wgpu) {
 		let Some(Ok(playlist_player)) = self.playlist_player.try_load(()) else {
 			return;
 		};
 
-		self.progress = match self.images.step_next(playlist_player, wgpu_shared) {
+		self.progress = match self.images.step_next(playlist_player, wgpu) {
 			Ok(()) => self.fade_duration,
 			Err(()) => self.max_progress(),
 		}
@@ -264,7 +264,7 @@ impl PanelFadeState {
 	/// Steps this panel's state by a certain number of frames (potentially negative).
 	///
 	/// If the playlist player isn't loaded, does nothing
-	pub fn step(&mut self, wgpu_shared: &WgpuShared, delta: TimeDelta) {
+	pub fn step(&mut self, wgpu: &Wgpu, delta: TimeDelta) {
 		let Some(Ok(playlist_player)) = self.playlist_player.try_load(()) else {
 			return;
 		};
@@ -281,7 +281,7 @@ impl PanelFadeState {
 			Some(next_progress) => match next_progress.checked_sub(self.duration) {
 				// If we did, `next_progress` is our progress at the next image, so try
 				// to step to it.
-				Some(next_progress) => match self.images.step_next(playlist_player, wgpu_shared) {
+				Some(next_progress) => match self.images.step_next(playlist_player, wgpu) {
 					// If we successfully stepped to the next image, start at the next progress
 					// Note: If delta was big enough to overflow 2 durations, then cap it at the
 					//       max duration of the next image.
@@ -297,7 +297,7 @@ impl PanelFadeState {
 			},
 
 			// Otherwise, we underflowed, so try to step back
-			None => match self.images.step_prev(playlist_player, wgpu_shared) {
+			None => match self.images.step_prev(playlist_player, wgpu) {
 				// If we successfully stepped backwards, start at where we're supposed to:
 				Ok(()) => {
 					// Note: This branch is only taken when `delta` is negative, so we can always
@@ -321,14 +321,14 @@ impl PanelFadeState {
 	/// Updates this panel's state using the current time as a delta
 	///
 	/// If the playlist player isn't loaded, does nothing
-	pub fn update(&mut self, wgpu_shared: &WgpuShared) {
+	pub fn update(&mut self, wgpu: &Wgpu) {
 		let Some(Ok(playlist_player)) = self.playlist_player.try_load(()) else {
 			return;
 		};
 
 		// Note: We always load images, even if we're paused, since the user might be
 		//       moving around manually.
-		self.images.load_missing(playlist_player, wgpu_shared);
+		self.images.load_missing(playlist_player, wgpu);
 
 		// If we're paused, don't update anything
 		if self.paused {
@@ -342,7 +342,7 @@ impl PanelFadeState {
 		//       the other has updated.
 		let delta = self.update_delta();
 		let delta = TimeDelta::from_std(delta).expect("Last update duration didn't fit into a delta");
-		self.step(wgpu_shared, delta);
+		self.step(wgpu, delta);
 	}
 }
 
diff --git a/zsw/src/settings_menu.rs b/zsw/src/settings_menu.rs
index d0dcf1c..2802bc5 100644
--- a/zsw/src/settings_menu.rs
+++ b/zsw/src/settings_menu.rs
@@ -15,7 +15,7 @@ use {
 	std::{path::Path, sync::Arc},
 	winit::{dpi::LogicalPosition, event_loop::EventLoopProxy},
 	zsw_util::{AppError, Rect, TokioTaskBlockOn},
-	zsw_wgpu::WgpuShared,
+	zsw_wgpu::Wgpu,
 };
 
 /// Settings menu
@@ -41,7 +41,7 @@ impl SettingsMenu {
 	pub fn draw(
 		&mut self,
 		ctx: &egui::Context,
-		wgpu_shared: &WgpuShared,
+		wgpu: &Wgpu,
 		panels: &Panels,
 		playlists: &Arc<Playlists>,
 		event_loop_proxy: &EventLoopProxy<AppEvent>,
@@ -68,7 +68,7 @@ impl SettingsMenu {
 			ui.separator();
 
 			match self.cur_tab {
-				Tab::Panels => self::draw_panels_tab(ui, wgpu_shared, panels, playlists, window_geometry),
+				Tab::Panels => self::draw_panels_tab(ui, wgpu, panels, playlists, window_geometry),
 				Tab::Settings => self::draw_settings(ui, event_loop_proxy),
 			}
 		});
@@ -77,12 +77,12 @@ impl SettingsMenu {
 /// Draws the panels tab
 fn draw_panels_tab(
 	ui: &mut egui::Ui,
-	wgpu_shared: &WgpuShared,
+	wgpu: &Wgpu,
 	panels: &Panels,
 	playlists: &Arc<Playlists>,
 	window_geometry: Rect<i32, u32>,
 ) {
-	self::draw_panels_editor(ui, wgpu_shared, panels, playlists, window_geometry);
+	self::draw_panels_editor(ui, wgpu, panels, playlists, window_geometry);
 	ui.separator();
 }
 
@@ -90,7 +90,7 @@ fn draw_panels_tab(
 // TODO: Not edit the values as-is, as that breaks some invariants of panels (such as duration versus image states)
 fn draw_panels_editor(
 	ui: &mut egui::Ui,
-	wgpu_shared: &WgpuShared,
+	wgpu: &Wgpu,
 	panels: &Panels,
 	playlists: &Arc<Playlists>,
 	window_geometry: Rect<i32, u32>,
@@ -119,7 +119,7 @@ fn draw_panels_editor(
 			match &mut panel.state {
 				PanelState::None(_) => (),
 				PanelState::Fade(state) =>
-					self::draw_fade_panel_editor(ui, wgpu_shared, window_geometry, state, &mut panel.geometries),
+					self::draw_fade_panel_editor(ui, wgpu, window_geometry, state, &mut panel.geometries),
 			}
 
 			ui.collapsing("Shader", |ui| {
@@ -132,7 +132,7 @@ fn draw_panels_editor(
 /// Draws the fade panel editor
 fn draw_fade_panel_editor(
 	ui: &mut egui::Ui,
-	wgpu_shared: &WgpuShared,
+	wgpu: &Wgpu,
 	window_geometry: Rect<i32, u32>,
 	panel_state: &mut PanelFadeState,
 	geometries: &mut [PanelGeometry],
@@ -190,7 +190,7 @@ fn draw_fade_panel_editor(
 	ui.horizontal(|ui| {
 		ui.label("Skip");
 		if ui.button("🔄").clicked() {
-			panel_state.skip(wgpu_shared);
+			panel_state.skip(wgpu);
 		}
 	});
 
diff --git a/zsw/src/shared.rs b/zsw/src/shared.rs
index d6ca54d..4af47ba 100644
--- a/zsw/src/shared.rs
+++ b/zsw/src/shared.rs
@@ -11,7 +11,7 @@ use {
 	crossbeam::atomic::AtomicCell,
 	std::sync::Arc,
 	winit::dpi::PhysicalPosition,
-	zsw_wgpu::WgpuShared,
+	zsw_wgpu::Wgpu,
 };
 
 /// Shared data
@@ -22,7 +22,7 @@ pub struct Shared {
 	pub last_resize: AtomicCell<Option<Resize>>,
 	pub cursor_pos:  AtomicCell<PhysicalPosition<f64>>,
 
-	pub wgpu:                    &'static WgpuShared,
+	pub wgpu:                    &'static Wgpu,
 	pub panels_renderer_layouts: PanelsRendererLayouts,
 
 	pub panels:    Panels,