diff --git a/Cargo.lock b/Cargo.lock
index 99a2064e..32b39461 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -757,9 +757,9 @@ checksum = "9ea835d29036a4087793836fa931b08837ad5e957da9e23886b29586fb9b6650"
 
 [[package]]
 name = "drm"
-version = "0.8.0"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "98d190a8cb219483212f462d9e34abebe24a13cdb7f0c9a64c5b59175ccd62d2"
+checksum = "edf9159ef4bcecd0c5e4cbeb573b8d0037493403d542780dba5d840bbf9df56f"
 dependencies = [
  "bitflags",
  "bytemuck",
@@ -770,9 +770,9 @@ dependencies = [
 
 [[package]]
 name = "drm-ffi"
-version = "0.4.0"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "48310b65d262ac1140f63e2bbc605c73a417c7e46452ea8c20a3cad698af96d0"
+checksum = "1352481b7b90e27a8a1bf8ef6b33cf18b98dba7c410e75c24bb3eef2f0d8d525"
 dependencies = [
  "drm-sys",
  "nix 0.26.2",
@@ -786,9 +786,9 @@ checksum = "0aafbcdb8afc29c1a7ee5fbe53b5d62f4565b35a042a662ca9fecd0b54dae6f4"
 
 [[package]]
 name = "drm-sys"
-version = "0.3.0"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "52ecd1ca96a64fd7444a58a2ce3aa8be79cea3c1c7f7f69a4b89624018b46377"
+checksum = "1369f1679d6b706d234c4c1e0613c415c2c74b598a09ad28080ba2474b72e42d"
 dependencies = [
  "libc",
 ]
@@ -1265,9 +1265,9 @@ dependencies = [
 
 [[package]]
 name = "gbm"
-version = "0.11.0"
+version = "0.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fffcdb4a9a42ceeb8170a916a84d44ec1fbfbbd753070180a98db92b71bfd431"
+checksum = "f2ec389cda876966cf824111bf6e533fb934c711d473498279964a990853b3c6"
 dependencies = [
  "bitflags",
  "drm",
@@ -3306,7 +3306,7 @@ checksum = "a507befe795404456341dfab10cef66ead4c041f62b8b11bbb92bffe5d0953e0"
 [[package]]
 name = "smithay"
 version = "0.3.0"
-source = "git+https://github.com/pop-os/smithay?rev=4e287a585a#4e287a585ae257393a0377694b2d284da243f4b2"
+source = "git+https://github.com/smithay//smithay?rev=a5a3c2bd4e#a5a3c2bd4e129e6895e1884b075a9994c9affe66"
 dependencies = [
  "appendlist",
  "ash",
diff --git a/Cargo.toml b/Cargo.toml
index db68d7e1..7fde36f9 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -70,4 +70,4 @@ debug = true
 lto = "fat"
 
 [patch."https://github.com/Smithay/smithay.git"]
-smithay = { git = "https://github.com/pop-os/smithay", rev = "4e287a585a" }
+smithay = { git = "https://github.com/smithay//smithay", rev = "a5a3c2bd4e" }
diff --git a/src/backend/kms/mod.rs b/src/backend/kms/mod.rs
index fc456383..63fb6472 100644
--- a/src/backend/kms/mod.rs
+++ b/src/backend/kms/mod.rs
@@ -33,7 +33,7 @@ use smithay::{
         libinput::{LibinputInputBackend, LibinputSessionInterface},
         renderer::{
             buffer_dimensions,
-            damage::{DamageTrackedRendererError as RenderError, OutputNoMode},
+            damage::{Error as RenderError, OutputNoMode},
             gles2::Gles2Renderbuffer,
             glow::GlowRenderer,
             multigpu::{gbm::GbmGlesBackend, Error as MultiError, GpuManager},
@@ -1013,8 +1013,8 @@ impl Surface {
                             &session,
                             params,
                             self.output.current_transform(),
-                            |_node, buffer, renderer, dtr, age| {
-                                let res = dtr.damage_output(age, &elements)?;
+                            |_node, buffer, renderer, dt, age| {
+                                let res = dt.damage_output(age, &elements)?;
 
                                 if let (Some(ref damage), _) = &res {
                                     if let Ok(dmabuf) = get_dmabuf(buffer) {
diff --git a/src/backend/render/mod.rs b/src/backend/render/mod.rs
index 73b4b93b..4798ccca 100644
--- a/src/backend/render/mod.rs
+++ b/src/backend/render/mod.rs
@@ -35,9 +35,7 @@ use smithay::{
         drm::DrmNode,
         renderer::{
             buffer_dimensions,
-            damage::{
-                DamageTrackedRenderer, DamageTrackedRendererError as RenderError, OutputNoMode,
-            },
+            damage::{Error as RenderError, OutputDamageTracker, OutputNoMode},
             element::{Element, RenderElement, RenderElementStates},
             gles2::{
                 element::PixelShaderElement, Gles2Error, Gles2PixelProgram, Gles2Renderer, Uniform,
@@ -316,7 +314,7 @@ pub fn render_output<'frame, R, Target, OffTarget, Source>(
     gpu: Option<&DrmNode>,
     renderer: &mut R,
     target: Target,
-    damage_tracker: &mut DamageTrackedRenderer,
+    damage_tracker: &mut OutputDamageTracker,
     age: usize,
     state: &mut Common,
     output: &Output,
@@ -364,7 +362,7 @@ pub fn render_workspace<'frame, R, Target, OffTarget, Source>(
     gpu: Option<&DrmNode>,
     renderer: &mut R,
     target: Target,
-    damage_tracker: &mut DamageTrackedRenderer,
+    damage_tracker: &mut OutputDamageTracker,
     age: usize,
     state: &mut Common,
     output: &Output,
@@ -450,8 +448,8 @@ where
                     &session,
                     params,
                     output.current_transform(),
-                    |_node, buffer, renderer, dtr, age| {
-                        let res = dtr.damage_output(age, &elements)?;
+                    |_node, buffer, renderer, dt, age| {
+                        let res = dt.damage_output(age, &elements)?;
 
                         if let (Some(ref damage), _) = &res {
                             if let Ok(dmabuf) = get_dmabuf(buffer) {
diff --git a/src/backend/winit.rs b/src/backend/winit.rs
index 49244ac2..fde048b6 100644
--- a/src/backend/winit.rs
+++ b/src/backend/winit.rs
@@ -13,7 +13,7 @@ use smithay::{
     backend::{
         egl::EGLDevice,
         renderer::{
-            damage::DamageTrackedRenderer, gles2::Gles2Renderbuffer, glow::GlowRenderer, ImportDma,
+            damage::OutputDamageTracker, gles2::Gles2Renderbuffer, glow::GlowRenderer, ImportDma,
             ImportEgl,
         },
         winit::{self, WinitEvent, WinitGraphicsBackend, WinitVirtualDevice},
@@ -40,7 +40,7 @@ pub struct WinitState {
     // The winit backend currently has no notion of multiple windows
     pub backend: WinitGraphicsBackend<GlowRenderer>,
     output: Output,
-    damage_tracker: DamageTrackedRenderer,
+    damage_tracker: OutputDamageTracker,
     screencopy: Vec<(ScreencopySession, BufferParams)>,
     #[cfg(feature = "debug")]
     fps: Fps,
@@ -240,7 +240,7 @@ pub fn init_backend(
     state.backend = BackendData::Winit(WinitState {
         backend,
         output: output.clone(),
-        damage_tracker: DamageTrackedRenderer::from_output(&output),
+        damage_tracker: OutputDamageTracker::from_output(&output),
         screencopy: Vec::new(),
         #[cfg(feature = "debug")]
         fps,
diff --git a/src/backend/x11.rs b/src/backend/x11.rs
index 73b3c72e..1f7f0a26 100644
--- a/src/backend/x11.rs
+++ b/src/backend/x11.rs
@@ -20,7 +20,7 @@ use smithay::{
         egl::{EGLContext, EGLDevice, EGLDisplay},
         input::{Event, InputEvent},
         renderer::{
-            damage::DamageTrackedRenderer, gles2::Gles2Renderbuffer, glow::GlowRenderer, Bind,
+            damage::OutputDamageTracker, gles2::Gles2Renderbuffer, glow::GlowRenderer, Bind,
             ImportDma, ImportEgl,
         },
         vulkan::{version::Version, Instance, PhysicalDevice},
@@ -141,7 +141,7 @@ impl X11State {
         self.surfaces.push(Surface {
             window,
             surface,
-            damage_tracker: DamageTrackedRenderer::from_output(&output),
+            damage_tracker: OutputDamageTracker::from_output(&output),
             output: output.clone(),
             render: ping.clone(),
             dirty: false,
@@ -204,7 +204,7 @@ impl X11State {
 
 pub struct Surface {
     window: Window,
-    damage_tracker: DamageTrackedRenderer,
+    damage_tracker: OutputDamageTracker,
     screencopy: Vec<(ScreencopySession, BufferParams)>,
     surface: X11Surface,
     output: Output,
diff --git a/src/wayland/handlers/screencopy.rs b/src/wayland/handlers/screencopy.rs
index 033b18b8..b0042911 100644
--- a/src/wayland/handlers/screencopy.rs
+++ b/src/wayland/handlers/screencopy.rs
@@ -16,7 +16,7 @@ use smithay::{
         egl::EGLDevice,
         renderer::{
             buffer_dimensions, buffer_type,
-            damage::{DamageTrackedRenderer, DamageTrackedRendererError},
+            damage::{Error as DTError, OutputDamageTracker},
             element::{
                 surface::WaylandSurfaceRenderElement, AsRenderElements, RenderElement,
                 RenderElementStates,
@@ -92,7 +92,7 @@ impl PartialEq<Session> for DropableSession {
     }
 }
 
-pub type SessionDTR = RefCell<DamageTrackedRenderer>;
+pub type SessionDT = RefCell<OutputDamageTracker>;
 
 impl ScreencopyHandler for State {
     fn capture_output(&mut self, output: Output, session: Session) -> Vec<BufferInfo> {
@@ -117,7 +117,7 @@ impl ScreencopyHandler for State {
 
         session
             .user_data()
-            .insert_if_missing(|| SessionDTR::new(DamageTrackedRenderer::from_output(&output)));
+            .insert_if_missing(|| SessionDT::new(OutputDamageTracker::from_output(&output)));
         output
             .user_data()
             .insert_if_missing(ScreencopySessions::default);
@@ -156,7 +156,7 @@ impl ScreencopyHandler for State {
 
         session
             .user_data()
-            .insert_if_missing(|| SessionDTR::new(DamageTrackedRenderer::from_output(&output)));
+            .insert_if_missing(|| SessionDT::new(OutputDamageTracker::from_output(&output)));
 
         workspace
             .screencopy_sessions
@@ -226,7 +226,7 @@ impl ScreencopyHandler for State {
 
         let size = toplevel.geometry().size.to_physical(1);
         session.user_data().insert_if_missing(|| {
-            SessionDTR::new(DamageTrackedRenderer::new(size, 1.0, Transform::Normal))
+            SessionDT::new(OutputDamageTracker::new(size, 1.0, Transform::Normal))
         });
         toplevel
             .user_data()
@@ -547,40 +547,34 @@ pub fn render_session<F, R>(
     params: &BufferParams,
     transform: Transform,
     render_fn: F,
-) -> Result<bool, DamageTrackedRendererError<R>>
+) -> Result<bool, DTError<R>>
 where
     R: ExportMem,
     F: FnOnce(
         Option<&DrmNode>,
         &WlBuffer,
         &mut R,
-        &mut DamageTrackedRenderer,
+        &mut OutputDamageTracker,
         usize,
-    ) -> Result<
-        (Option<Vec<Rectangle<i32, Physical>>>, RenderElementStates),
-        DamageTrackedRendererError<R>,
-    >,
+    )
+        -> Result<(Option<Vec<Rectangle<i32, Physical>>>, RenderElementStates), DTError<R>>,
 {
     #[cfg(feature = "debug")]
     puffin::profile_function!();
 
-    let mut dtr = session
-        .user_data()
-        .get::<SessionDTR>()
-        .unwrap()
-        .borrow_mut();
+    let mut dt = session.user_data().get::<SessionDT>().unwrap().borrow_mut();
 
     let res = render_fn(
         node.as_ref(),
         &params.buffer,
         renderer,
-        &mut *dtr,
+        &mut *dt,
         params.age as usize,
     )?;
 
     if let (Some(damage), _) = res {
         submit_buffer(session, &params.buffer, renderer, transform, damage)
-            .map_err(DamageTrackedRendererError::Rendering)?;
+            .map_err(DTError::Rendering)?;
         Ok(true)
     } else {
         Ok(false)
@@ -605,15 +599,12 @@ pub fn render_output_to_buffer(
         node: Option<&DrmNode>,
         buffer: &WlBuffer,
         renderer: &mut R,
-        dtr: &mut DamageTrackedRenderer,
+        dt: &mut OutputDamageTracker,
         age: usize,
         common: &mut Common,
         session: &Session,
         output: &Output,
-    ) -> Result<
-        (Option<Vec<Rectangle<i32, Physical>>>, RenderElementStates),
-        DamageTrackedRendererError<R>,
-    >
+    ) -> Result<(Option<Vec<Rectangle<i32, Physical>>>, RenderElementStates), DTError<R>>
     where
         R: Renderer
             + ImportAll
@@ -639,7 +630,7 @@ pub fn render_output_to_buffer(
                 node,
                 renderer,
                 dmabuf,
-                dtr,
+                dt,
                 age,
                 common,
                 &output,
@@ -650,12 +641,12 @@ pub fn render_output_to_buffer(
         } else {
             let size = buffer_dimensions(buffer).unwrap();
             let render_buffer = Offscreen::<Gles2Renderbuffer>::create_buffer(renderer, size)
-                .map_err(DamageTrackedRendererError::Rendering)?;
+                .map_err(DTError::Rendering)?;
             render_output::<_, _, Gles2Renderbuffer, Dmabuf>(
                 node,
                 renderer,
                 render_buffer,
-                dtr,
+                dt,
                 age,
                 common,
                 &output,
@@ -680,13 +671,13 @@ pub fn render_output_to_buffer(
                 session,
                 &params,
                 output.current_transform(),
-                |node, buffer, renderer, dtr, age| {
-                    render_fn(node, buffer, renderer, dtr, age, common, session, output)
+                |node, buffer, renderer, dt, age| {
+                    render_fn(node, buffer, renderer, dt, age, common, session, output)
                 },
             )
             .map_err(|err| match err {
-                DamageTrackedRendererError::OutputNoMode(x) => (FailureReason::Unspec, x.into()),
-                DamageTrackedRendererError::Rendering(x) => (FailureReason::Unspec, x.into()),
+                DTError::OutputNoMode(x) => (FailureReason::Unspec, x.into()),
+                DTError::Rendering(x) => (FailureReason::Unspec, x.into()),
             })
         }
         BackendData::Winit(winit) => render_session::<_, _>(
@@ -695,8 +686,8 @@ pub fn render_output_to_buffer(
             session,
             &params,
             output.current_transform(),
-            |node, buffer, renderer, dtr, age| {
-                render_fn(node, buffer, renderer, dtr, age, common, session, output)
+            |node, buffer, renderer, dt, age| {
+                render_fn(node, buffer, renderer, dt, age, common, session, output)
             },
         )
         .map_err(|err| (FailureReason::Unspec, err.into())),
@@ -706,8 +697,8 @@ pub fn render_output_to_buffer(
             session,
             &params,
             output.current_transform(),
-            |node, buffer, renderer, dtr, age| {
-                render_fn(node, buffer, renderer, dtr, age, common, session, output)
+            |node, buffer, renderer, dt, age| {
+                render_fn(node, buffer, renderer, dt, age, common, session, output)
             },
         )
         .map_err(|err| (FailureReason::Unspec, err.into())),
@@ -734,16 +725,13 @@ pub fn render_workspace_to_buffer(
         node: Option<&DrmNode>,
         buffer: &WlBuffer,
         renderer: &mut R,
-        dtr: &mut DamageTrackedRenderer,
+        dt: &mut OutputDamageTracker,
         age: usize,
         common: &mut Common,
         session: &Session,
         output: &Output,
         handle: &WorkspaceHandle,
-    ) -> Result<
-        (Option<Vec<Rectangle<i32, Physical>>>, RenderElementStates),
-        DamageTrackedRendererError<R>,
-    >
+    ) -> Result<(Option<Vec<Rectangle<i32, Physical>>>, RenderElementStates), DTError<R>>
     where
         R: Renderer
             + ImportAll
@@ -768,7 +756,7 @@ pub fn render_workspace_to_buffer(
                 node,
                 renderer,
                 dmabuf,
-                dtr,
+                dt,
                 age,
                 common,
                 &output,
@@ -781,12 +769,12 @@ pub fn render_workspace_to_buffer(
         } else {
             let size = buffer_dimensions(buffer).unwrap();
             let render_buffer = Offscreen::<Gles2Renderbuffer>::create_buffer(renderer, size)
-                .map_err(DamageTrackedRendererError::Rendering)?;
+                .map_err(DTError::Rendering)?;
             render_workspace::<_, _, Gles2Renderbuffer, Dmabuf>(
                 node,
                 renderer,
                 render_buffer,
-                dtr,
+                dt,
                 age,
                 common,
                 &output,
@@ -813,15 +801,15 @@ pub fn render_workspace_to_buffer(
                 session,
                 &params,
                 output.current_transform(),
-                |node, buffer, renderer, dtr, age| {
+                |node, buffer, renderer, dt, age| {
                     render_fn(
-                        node, buffer, renderer, dtr, age, common, session, output, handle,
+                        node, buffer, renderer, dt, age, common, session, output, handle,
                     )
                 },
             )
             .map_err(|err| match err {
-                DamageTrackedRendererError::OutputNoMode(x) => (FailureReason::Unspec, x.into()),
-                DamageTrackedRendererError::Rendering(x) => (FailureReason::Unspec, x.into()),
+                DTError::OutputNoMode(x) => (FailureReason::Unspec, x.into()),
+                DTError::Rendering(x) => (FailureReason::Unspec, x.into()),
             })
         }
         BackendData::Winit(winit) => render_session::<_, _>(
@@ -830,9 +818,9 @@ pub fn render_workspace_to_buffer(
             session,
             &params,
             output.current_transform(),
-            |node, buffer, renderer, dtr, age| {
+            |node, buffer, renderer, dt, age| {
                 render_fn(
-                    node, buffer, renderer, dtr, age, common, session, output, handle,
+                    node, buffer, renderer, dt, age, common, session, output, handle,
                 )
             },
         )
@@ -843,9 +831,9 @@ pub fn render_workspace_to_buffer(
             session,
             &params,
             output.current_transform(),
-            |node, buffer, renderer, dtr, age| {
+            |node, buffer, renderer, dt, age| {
                 render_fn(
-                    node, buffer, renderer, dtr, age, common, session, output, handle,
+                    node, buffer, renderer, dt, age, common, session, output, handle,
                 )
             },
         )
@@ -878,16 +866,13 @@ pub fn render_window_to_buffer(
     fn render_fn<R>(
         buffer: &WlBuffer,
         renderer: &mut R,
-        dtr: &mut DamageTrackedRenderer,
+        dt: &mut OutputDamageTracker,
         age: usize,
         session: &Session,
         common: &mut Common,
         window: &CosmicSurface,
         geometry: Rectangle<i32, Logical>,
-    ) -> Result<
-        (Option<Vec<Rectangle<i32, Physical>>>, RenderElementStates),
-        DamageTrackedRendererError<R>,
-    >
+    ) -> Result<(Option<Vec<Rectangle<i32, Physical>>>, RenderElementStates), DTError<R>>
     where
         R: Renderer
             + ImportAll
@@ -952,19 +937,15 @@ pub fn render_window_to_buffer(
         }
 
         if let Ok(dmabuf) = get_dmabuf(buffer) {
-            renderer
-                .bind(dmabuf)
-                .map_err(DamageTrackedRendererError::Rendering)?;
+            renderer.bind(dmabuf).map_err(DTError::Rendering)?;
         } else {
             let size = buffer_dimensions(buffer).unwrap();
             let render_buffer = Offscreen::<Gles2Renderbuffer>::create_buffer(renderer, size)
-                .map_err(DamageTrackedRendererError::Rendering)?;
-            renderer
-                .bind(render_buffer)
-                .map_err(DamageTrackedRendererError::Rendering)?;
+                .map_err(DTError::Rendering)?;
+            renderer.bind(render_buffer).map_err(DTError::Rendering)?;
         }
 
-        dtr.render_output(renderer, age, &elements, CLEAR_COLOR)
+        dt.render_output(renderer, age, &elements, CLEAR_COLOR)
     }
 
     let node = node_from_params(&params, &mut state.backend, None);
@@ -981,15 +962,13 @@ pub fn render_window_to_buffer(
                 session,
                 &params,
                 Transform::Normal,
-                |_node, buffer, renderer, dtr, age| {
-                    render_fn(
-                        buffer, renderer, dtr, age, session, common, window, geometry,
-                    )
+                |_node, buffer, renderer, dt, age| {
+                    render_fn(buffer, renderer, dt, age, session, common, window, geometry)
                 },
             )
             .map_err(|err| match err {
-                DamageTrackedRendererError::OutputNoMode(x) => (FailureReason::Unspec, x.into()),
-                DamageTrackedRendererError::Rendering(x) => (FailureReason::Unspec, x.into()),
+                DTError::OutputNoMode(x) => (FailureReason::Unspec, x.into()),
+                DTError::Rendering(x) => (FailureReason::Unspec, x.into()),
             })
         }
         BackendData::Winit(winit) => render_session::<_, _>(
@@ -998,10 +977,8 @@ pub fn render_window_to_buffer(
             session,
             &params,
             Transform::Normal,
-            |_node, buffer, renderer, dtr, age| {
-                render_fn(
-                    buffer, renderer, dtr, age, session, common, window, geometry,
-                )
+            |_node, buffer, renderer, dt, age| {
+                render_fn(buffer, renderer, dt, age, session, common, window, geometry)
             },
         )
         .map_err(|err| (FailureReason::Unspec, err.into())),
@@ -1011,10 +988,8 @@ pub fn render_window_to_buffer(
             session,
             &params,
             Transform::Normal,
-            |_node, buffer, renderer, dtr, age| {
-                render_fn(
-                    buffer, renderer, dtr, age, session, common, window, geometry,
-                )
+            |_node, buffer, renderer, dt, age| {
+                render_fn(buffer, renderer, dt, age, session, common, window, geometry)
             },
         )
         .map_err(|err| (FailureReason::Unspec, err.into())),