diff --git a/Cargo.lock b/Cargo.lock
index b4761bd8..cd3ef420 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4581,7 +4581,7 @@ checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"
 [[package]]
 name = "smithay"
 version = "0.3.0"
-source = "git+https://github.com/smithay//smithay?rev=24e36e9#24e36e97a1844d575a1586d3cddcc94d96c2044d"
+source = "git+https://github.com/smithay//smithay?rev=b4f8120#b4f8120be0fb9b7f038d041efa7f6549e26cd2bc"
 dependencies = [
  "appendlist",
  "ash",
diff --git a/Cargo.toml b/Cargo.toml
index 0c953367..e7feb2d3 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -118,4 +118,4 @@ inherits = "release"
 lto = "fat"
 
 [patch."https://github.com/Smithay/smithay.git"]
-smithay = {git = "https://github.com/smithay//smithay", rev = "24e36e9"}
+smithay = {git = "https://github.com/smithay//smithay", rev = "b4f8120"}
diff --git a/src/backend/render/element.rs b/src/backend/render/element.rs
index 5093f332..dcff9585 100644
--- a/src/backend/render/element.rs
+++ b/src/backend/render/element.rs
@@ -189,21 +189,22 @@ impl RenderElement<GlowRenderer> for CosmicElement<GlowRenderer> {
         src: Rectangle<f64, BufferCoords>,
         dst: Rectangle<i32, Physical>,
         damage: &[Rectangle<i32, Physical>],
+        opaque_regions: &[Rectangle<i32, Physical>],
     ) -> Result<(), <GlowRenderer as Renderer>::Error> {
         match self {
-            CosmicElement::Workspace(elem) => elem.draw(frame, src, dst, damage),
-            CosmicElement::Cursor(elem) => elem.draw(frame, src, dst, damage),
-            CosmicElement::Dnd(elem) => elem.draw(frame, src, dst, damage),
-            CosmicElement::MoveGrab(elem) => elem.draw(frame, src, dst, damage),
+            CosmicElement::Workspace(elem) => elem.draw(frame, src, dst, damage, opaque_regions),
+            CosmicElement::Cursor(elem) => elem.draw(frame, src, dst, damage, opaque_regions),
+            CosmicElement::Dnd(elem) => elem.draw(frame, src, dst, damage, opaque_regions),
+            CosmicElement::MoveGrab(elem) => elem.draw(frame, src, dst, damage, opaque_regions),
             CosmicElement::AdditionalDamage(elem) => {
-                RenderElement::<GlowRenderer>::draw(elem, frame, src, dst, damage)
+                RenderElement::<GlowRenderer>::draw(elem, frame, src, dst, damage, opaque_regions)
             }
             CosmicElement::Mirror(elem) => {
-                RenderElement::<GlowRenderer>::draw(elem, frame, src, dst, damage)
+                RenderElement::<GlowRenderer>::draw(elem, frame, src, dst, damage, opaque_regions)
             }
             #[cfg(feature = "debug")]
             CosmicElement::Egui(elem) => {
-                RenderElement::<GlowRenderer>::draw(elem, frame, src, dst, damage)
+                RenderElement::<GlowRenderer>::draw(elem, frame, src, dst, damage, opaque_regions)
             }
         }
     }
@@ -229,20 +230,33 @@ impl<'a> RenderElement<GlMultiRenderer<'a>> for CosmicElement<GlMultiRenderer<'a
         src: Rectangle<f64, BufferCoords>,
         dst: Rectangle<i32, Physical>,
         damage: &[Rectangle<i32, Physical>],
+        opaque_regions: &[Rectangle<i32, Physical>],
     ) -> Result<(), GlMultiError> {
         match self {
-            CosmicElement::Workspace(elem) => elem.draw(frame, src, dst, damage),
-            CosmicElement::Cursor(elem) => elem.draw(frame, src, dst, damage),
-            CosmicElement::Dnd(elem) => elem.draw(frame, src, dst, damage),
-            CosmicElement::MoveGrab(elem) => elem.draw(frame, src, dst, damage),
-            CosmicElement::AdditionalDamage(elem) => {
-                RenderElement::<GlMultiRenderer<'a>>::draw(elem, frame, src, dst, damage)
-            }
+            CosmicElement::Workspace(elem) => elem.draw(frame, src, dst, damage, opaque_regions),
+            CosmicElement::Cursor(elem) => elem.draw(frame, src, dst, damage, opaque_regions),
+            CosmicElement::Dnd(elem) => elem.draw(frame, src, dst, damage, opaque_regions),
+            CosmicElement::MoveGrab(elem) => elem.draw(frame, src, dst, damage, opaque_regions),
+            CosmicElement::AdditionalDamage(elem) => RenderElement::<GlMultiRenderer<'a>>::draw(
+                elem,
+                frame,
+                src,
+                dst,
+                damage,
+                opaque_regions,
+            ),
             CosmicElement::Mirror(elem) => {
                 let elem = {
                     let glow_frame = frame.glow_frame_mut();
-                    RenderElement::<GlowRenderer>::draw(elem, glow_frame, src, dst, damage)
-                        .map_err(|err| GlMultiError::Render(err))
+                    RenderElement::<GlowRenderer>::draw(
+                        elem,
+                        glow_frame,
+                        src,
+                        dst,
+                        damage,
+                        opaque_regions,
+                    )
+                    .map_err(|err| GlMultiError::Render(err))
                 };
                 elem
             }
@@ -250,8 +264,15 @@ impl<'a> RenderElement<GlMultiRenderer<'a>> for CosmicElement<GlMultiRenderer<'a
             CosmicElement::Egui(elem) => {
                 let elem = {
                     let glow_frame = frame.glow_frame_mut();
-                    RenderElement::<GlowRenderer>::draw(elem, glow_frame, src, dst, damage)
-                        .map_err(|err| GlMultiError::Render(err))
+                    RenderElement::<GlowRenderer>::draw(
+                        elem,
+                        glow_frame,
+                        src,
+                        dst,
+                        damage,
+                        opaque_regions,
+                    )
+                    .map_err(|err| GlMultiError::Render(err))
                 };
                 elem
             }
@@ -439,6 +460,7 @@ impl<R: Renderer> RenderElement<R> for DamageElement {
         _src: Rectangle<f64, BufferCoords>,
         _dst: Rectangle<i32, Physical>,
         _damage: &[Rectangle<i32, Physical>],
+        _opaque_regions: &[Rectangle<i32, Physical>],
     ) -> Result<(), <R as Renderer>::Error> {
         Ok(())
     }
diff --git a/src/input/mod.rs b/src/input/mod.rs
index 39ba1bea..f5b61335 100644
--- a/src/input/mod.rs
+++ b/src/input/mod.rs
@@ -528,7 +528,7 @@ impl State {
                             Some(constraint) if constraint.is_active() => {
                                 // Constraint does not apply if not within region
                                 if !constraint.region().map_or(true, |x| {
-                                    x.contains(ptr.current_location().to_i32_round() - *surface_loc)
+                                    x.contains((ptr.current_location() - *surface_loc).to_i32_round())
                                 }) {
                                     return;
                                 }
@@ -621,7 +621,7 @@ impl State {
                             }
                             if let Some(region) = confine_region {
                                 if !region
-                                    .contains(position.as_logical().to_i32_round() - *surface_loc)
+                                    .contains((position.as_logical() - *surface_loc).to_i32_round())
                                 {
                                     ptr.frame(self);
                                     return;
@@ -653,7 +653,7 @@ impl State {
                                     PointerConstraint::Confined(confined) => confined.region(),
                                 };
                                 let point =
-                                    ptr.current_location().to_i32_round() - surface_location;
+                                    (ptr.current_location() - surface_location).to_i32_round();
                                 if region.map_or(true, |region| region.contains(point)) {
                                     constraint.activate();
                                 }
@@ -2501,7 +2501,7 @@ impl State {
         global_pos: Point<f64, Global>,
         output: &Output,
         shell: &mut Shell,
-    ) -> Option<(PointerFocusTarget, Point<i32, Global>)> {
+    ) -> Option<(PointerFocusTarget, Point<f64, Global>)> {
         let session_lock = shell.session_lock.as_ref();
         let relative_pos = global_pos.to_local(output);
         let output_geo = output.geometry();
@@ -2513,7 +2513,7 @@ impl State {
                         surface: surface.wl_surface().clone(),
                         toplevel: None,
                     },
-                    output_geo.loc,
+                    output_geo.loc.to_f64(),
                 )
             });
         }
@@ -2531,7 +2531,7 @@ impl State {
                             surface: wl_surface,
                             toplevel: None,
                         },
-                        output_geo.loc + layer_loc.as_global() + surface_loc.as_global(),
+                        (output_geo.loc + layer_loc.as_global() + surface_loc.as_global()).to_f64(),
                     ));
                 }
             }
@@ -2545,7 +2545,7 @@ impl State {
                 })
                 .and_then(|or| {
                     or.wl_surface()
-                        .map(|surface| (surface, X11Surface::geometry(or).loc.as_global()))
+                        .map(|surface| (surface, X11Surface::geometry(or).loc.as_global().to_f64()))
                 })
             {
                 return Some((
@@ -2557,7 +2557,7 @@ impl State {
                 ));
             }
             PointerFocusTarget::under_surface(window, relative_pos.as_logical())
-                .map(|(target, surface_loc)| (target, output_geo.loc + surface_loc.as_global()))
+                .map(|(target, surface_loc)| (target, (output_geo.loc + surface_loc.as_global()).to_f64()))
         } else {
             {
                 let layers = layer_map_for_output(output);
@@ -2575,7 +2575,8 @@ impl State {
                                 surface: wl_surface,
                                 toplevel: None,
                             },
-                            output_geo.loc + layer_loc.as_global() + surface_loc.as_global(),
+                            (output_geo.loc + layer_loc.as_global() + surface_loc.as_global())
+                                .to_f64(),
                         ));
                     }
                 }
@@ -2590,7 +2591,7 @@ impl State {
                 })
                 .and_then(|or| {
                     or.wl_surface()
-                        .map(|surface| (surface, X11Surface::geometry(or).loc.as_global()))
+                        .map(|surface| (surface, X11Surface::geometry(or).loc.as_global().to_f64()))
                 })
             {
                 return Some((
@@ -2620,7 +2621,8 @@ impl State {
                                 surface: wl_surface,
                                 toplevel: None,
                             },
-                            output_geo.loc + layer_loc.as_global() + surface_loc.as_global(),
+                            (output_geo.loc + layer_loc.as_global() + surface_loc.as_global())
+                                .to_f64(),
                         ));
                     }
                 }
diff --git a/src/shell/element/mod.rs b/src/shell/element/mod.rs
index 0bf5542e..83914a2d 100644
--- a/src/shell/element/mod.rs
+++ b/src/shell/element/mod.rs
@@ -260,7 +260,7 @@ impl CosmicMapped {
     pub fn focus_under(
         &self,
         relative_pos: Point<f64, Logical>,
-    ) -> Option<(PointerFocusTarget, Point<i32, Logical>)> {
+    ) -> Option<(PointerFocusTarget, Point<f64, Logical>)> {
         match &self.element {
             CosmicMappedInternal::Stack(stack) => stack.focus_under(relative_pos),
             CosmicMappedInternal::Window(window) => window.focus_under(relative_pos),
@@ -1219,31 +1219,48 @@ impl RenderElement<GlowRenderer> for CosmicMappedRenderElement<GlowRenderer> {
         src: Rectangle<f64, BufferCoords>,
         dst: Rectangle<i32, Physical>,
         damage: &[Rectangle<i32, Physical>],
+        opaque_regions: &[Rectangle<i32, Physical>],
     ) -> Result<(), <GlowRenderer as Renderer>::Error> {
         match self {
-            CosmicMappedRenderElement::Stack(elem) => elem.draw(frame, src, dst, damage),
-            CosmicMappedRenderElement::Window(elem) => elem.draw(frame, src, dst, damage),
-            CosmicMappedRenderElement::TiledStack(elem) => elem.draw(frame, src, dst, damage),
-            CosmicMappedRenderElement::TiledWindow(elem) => elem.draw(frame, src, dst, damage),
-            CosmicMappedRenderElement::TiledOverlay(elem) => {
-                RenderElement::<GlowRenderer>::draw(elem, frame, src, dst, damage)
+            CosmicMappedRenderElement::Stack(elem) => {
+                elem.draw(frame, src, dst, damage, opaque_regions)
+            }
+            CosmicMappedRenderElement::Window(elem) => {
+                elem.draw(frame, src, dst, damage, opaque_regions)
+            }
+            CosmicMappedRenderElement::TiledStack(elem) => {
+                elem.draw(frame, src, dst, damage, opaque_regions)
+            }
+            CosmicMappedRenderElement::TiledWindow(elem) => {
+                elem.draw(frame, src, dst, damage, opaque_regions)
+            }
+            CosmicMappedRenderElement::TiledOverlay(elem) => {
+                RenderElement::<GlowRenderer>::draw(elem, frame, src, dst, damage, opaque_regions)
+            }
+            CosmicMappedRenderElement::MovingStack(elem) => {
+                elem.draw(frame, src, dst, damage, opaque_regions)
+            }
+            CosmicMappedRenderElement::MovingWindow(elem) => {
+                elem.draw(frame, src, dst, damage, opaque_regions)
+            }
+            CosmicMappedRenderElement::GrabbedStack(elem) => {
+                elem.draw(frame, src, dst, damage, opaque_regions)
+            }
+            CosmicMappedRenderElement::GrabbedWindow(elem) => {
+                elem.draw(frame, src, dst, damage, opaque_regions)
             }
-            CosmicMappedRenderElement::MovingStack(elem) => elem.draw(frame, src, dst, damage),
-            CosmicMappedRenderElement::MovingWindow(elem) => elem.draw(frame, src, dst, damage),
-            CosmicMappedRenderElement::GrabbedStack(elem) => elem.draw(frame, src, dst, damage),
-            CosmicMappedRenderElement::GrabbedWindow(elem) => elem.draw(frame, src, dst, damage),
             CosmicMappedRenderElement::FocusIndicator(elem) => {
-                RenderElement::<GlowRenderer>::draw(elem, frame, src, dst, damage)
+                RenderElement::<GlowRenderer>::draw(elem, frame, src, dst, damage, opaque_regions)
             }
             CosmicMappedRenderElement::Overlay(elem) => {
-                RenderElement::<GlowRenderer>::draw(elem, frame, src, dst, damage)
+                RenderElement::<GlowRenderer>::draw(elem, frame, src, dst, damage, opaque_regions)
             }
             CosmicMappedRenderElement::StackHoverIndicator(elem) => {
-                RenderElement::<GlowRenderer>::draw(elem, frame, src, dst, damage)
+                RenderElement::<GlowRenderer>::draw(elem, frame, src, dst, damage, opaque_regions)
             }
             #[cfg(feature = "debug")]
             CosmicMappedRenderElement::Egui(elem) => {
-                RenderElement::<GlowRenderer>::draw(elem, frame, src, dst, damage)
+                RenderElement::<GlowRenderer>::draw(elem, frame, src, dst, damage, opaque_regions)
             }
         }
     }
@@ -1277,36 +1294,75 @@ impl<'a> RenderElement<GlMultiRenderer<'a>> for CosmicMappedRenderElement<GlMult
         src: Rectangle<f64, BufferCoords>,
         dst: Rectangle<i32, Physical>,
         damage: &[Rectangle<i32, Physical>],
+        opaque_regions: &[Rectangle<i32, Physical>],
     ) -> Result<(), GlMultiError> {
         match self {
-            CosmicMappedRenderElement::Stack(elem) => elem.draw(frame, src, dst, damage),
-            CosmicMappedRenderElement::Window(elem) => elem.draw(frame, src, dst, damage),
-            CosmicMappedRenderElement::TiledStack(elem) => elem.draw(frame, src, dst, damage),
-            CosmicMappedRenderElement::TiledWindow(elem) => elem.draw(frame, src, dst, damage),
-            CosmicMappedRenderElement::TiledOverlay(elem) => {
-                RenderElement::<GlowRenderer>::draw(elem, frame.glow_frame_mut(), src, dst, damage)
-                    .map_err(|err| GlMultiError::Render(err))
+            CosmicMappedRenderElement::Stack(elem) => {
+                elem.draw(frame, src, dst, damage, opaque_regions)
             }
-            CosmicMappedRenderElement::MovingStack(elem) => elem.draw(frame, src, dst, damage),
-            CosmicMappedRenderElement::MovingWindow(elem) => elem.draw(frame, src, dst, damage),
-            CosmicMappedRenderElement::GrabbedStack(elem) => elem.draw(frame, src, dst, damage),
-            CosmicMappedRenderElement::GrabbedWindow(elem) => elem.draw(frame, src, dst, damage),
-            CosmicMappedRenderElement::FocusIndicator(elem) => {
-                RenderElement::<GlowRenderer>::draw(elem, frame.glow_frame_mut(), src, dst, damage)
-                    .map_err(|err| GlMultiError::Render(err))
+            CosmicMappedRenderElement::Window(elem) => {
+                elem.draw(frame, src, dst, damage, opaque_regions)
             }
-            CosmicMappedRenderElement::Overlay(elem) => {
-                RenderElement::<GlowRenderer>::draw(elem, frame.glow_frame_mut(), src, dst, damage)
-                    .map_err(|err| GlMultiError::Render(err))
+            CosmicMappedRenderElement::TiledStack(elem) => {
+                elem.draw(frame, src, dst, damage, opaque_regions)
             }
+            CosmicMappedRenderElement::TiledWindow(elem) => {
+                elem.draw(frame, src, dst, damage, opaque_regions)
+            }
+            CosmicMappedRenderElement::TiledOverlay(elem) => RenderElement::<GlowRenderer>::draw(
+                elem,
+                frame.glow_frame_mut(),
+                src,
+                dst,
+                damage,
+                opaque_regions,
+            )
+            .map_err(|err| GlMultiError::Render(err)),
+            CosmicMappedRenderElement::MovingStack(elem) => {
+                elem.draw(frame, src, dst, damage, opaque_regions)
+            }
+            CosmicMappedRenderElement::MovingWindow(elem) => {
+                elem.draw(frame, src, dst, damage, opaque_regions)
+            }
+            CosmicMappedRenderElement::GrabbedStack(elem) => {
+                elem.draw(frame, src, dst, damage, opaque_regions)
+            }
+            CosmicMappedRenderElement::GrabbedWindow(elem) => {
+                elem.draw(frame, src, dst, damage, opaque_regions)
+            }
+            CosmicMappedRenderElement::FocusIndicator(elem) => RenderElement::<GlowRenderer>::draw(
+                elem,
+                frame.glow_frame_mut(),
+                src,
+                dst,
+                damage,
+                opaque_regions,
+            )
+            .map_err(|err| GlMultiError::Render(err)),
+            CosmicMappedRenderElement::Overlay(elem) => RenderElement::<GlowRenderer>::draw(
+                elem,
+                frame.glow_frame_mut(),
+                src,
+                dst,
+                damage,
+                opaque_regions,
+            )
+            .map_err(|err| GlMultiError::Render(err)),
             CosmicMappedRenderElement::StackHoverIndicator(elem) => {
-                elem.draw(frame, src, dst, damage)
+                elem.draw(frame, src, dst, damage, opaque_regions)
             }
             #[cfg(feature = "debug")]
             CosmicMappedRenderElement::Egui(elem) => {
                 let glow_frame = frame.glow_frame_mut();
-                RenderElement::<GlowRenderer>::draw(elem, glow_frame, src, dst, damage)
-                    .map_err(|err| GlMultiError::Render(err))
+                RenderElement::<GlowRenderer>::draw(
+                    elem,
+                    glow_frame,
+                    src,
+                    dst,
+                    damage,
+                    opaque_regions,
+                )
+                .map_err(|err| GlMultiError::Render(err))
             }
         }
     }
diff --git a/src/shell/element/stack.rs b/src/shell/element/stack.rs
index 3ff15436..ba749acc 100644
--- a/src/shell/element/stack.rs
+++ b/src/shell/element/stack.rs
@@ -420,7 +420,7 @@ impl CosmicStack {
     pub fn focus_under(
         &self,
         mut relative_pos: Point<f64, Logical>,
-    ) -> Option<(PointerFocusTarget, Point<i32, Logical>)> {
+    ) -> Option<(PointerFocusTarget, Point<f64, Logical>)> {
         self.0.with_program(|p| {
             let mut stack_ui = None;
             let geo = p.windows.lock().unwrap()[p.active.load(Ordering::SeqCst)].geometry();
@@ -435,14 +435,14 @@ impl CosmicStack {
             {
                 stack_ui = Some((
                     PointerFocusTarget::StackUI(self.clone()),
-                    Point::from((0, 0)),
+                    Point::from((0., 0.)),
                 ));
             }
 
             if point_i32.y - geo.loc.y < TAB_HEIGHT {
                 stack_ui = Some((
                     PointerFocusTarget::StackUI(self.clone()),
-                    Point::from((0, 0)),
+                    Point::from((0., 0.)),
                 ));
             }
 
@@ -458,7 +458,7 @@ impl CosmicStack {
                             surface,
                             toplevel: Some(active_window.clone().into()),
                         },
-                        surface_offset + Point::from((0, TAB_HEIGHT)),
+                        surface_offset.to_f64() + Point::from((0., TAB_HEIGHT as f64)),
                     )
                 })
                 .or(stack_ui)
diff --git a/src/shell/element/window.rs b/src/shell/element/window.rs
index 527219cd..b28b3fdd 100644
--- a/src/shell/element/window.rs
+++ b/src/shell/element/window.rs
@@ -247,9 +247,9 @@ impl CosmicWindow {
     pub fn focus_under(
         &self,
         mut relative_pos: Point<f64, Logical>,
-    ) -> Option<(PointerFocusTarget, Point<i32, Logical>)> {
+    ) -> Option<(PointerFocusTarget, Point<f64, Logical>)> {
         self.0.with_program(|p| {
-            let mut offset = Point::from((0, 0));
+            let mut offset = Point::from((0., 0.));
             let mut window_ui = None;
             if p.has_ssd(false) {
                 let geo = p.window.geometry();
@@ -264,19 +264,19 @@ impl CosmicWindow {
                 {
                     window_ui = Some((
                         PointerFocusTarget::WindowUI(self.clone()),
-                        Point::from((0, 0)),
+                        Point::from((0., 0.)),
                     ));
                 }
 
                 if point_i32.y - geo.loc.y < SSD_HEIGHT {
                     window_ui = Some((
                         PointerFocusTarget::WindowUI(self.clone()),
-                        Point::from((0, 0)),
+                        Point::from((0., 0.)),
                     ));
                 }
 
                 relative_pos.y -= SSD_HEIGHT as f64;
-                offset.y += SSD_HEIGHT;
+                offset.y += SSD_HEIGHT as f64;
             }
 
             p.window
@@ -288,7 +288,7 @@ impl CosmicWindow {
                             surface,
                             toplevel: Some(p.window.clone().into()),
                         },
-                        offset + surface_offset,
+                        (offset + surface_offset.to_f64()),
                     )
                 })
                 .or(window_ui)
diff --git a/src/shell/grabs/menu/mod.rs b/src/shell/grabs/menu/mod.rs
index ec9080df..104d181a 100644
--- a/src/shell/grabs/menu/mod.rs
+++ b/src/shell/grabs/menu/mod.rs
@@ -473,7 +473,7 @@ impl PointerGrab<State> for MenuGrab {
         &mut self,
         state: &mut State,
         handle: &mut PointerInnerHandle<'_, State>,
-        _focus: Option<(PointerFocusTarget, Point<i32, Logical>)>,
+        _focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
         event: &MotionEvent,
     ) {
         {
@@ -520,7 +520,7 @@ impl PointerGrab<State> for MenuGrab {
         &mut self,
         state: &mut State,
         handle: &mut PointerInnerHandle<'_, State>,
-        _focus: Option<(PointerFocusTarget, Point<i32, Logical>)>,
+        _focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
         event: &RelativeMotionEvent,
     ) {
         // While the grab is active, no client has pointer focus
diff --git a/src/shell/grabs/mod.rs b/src/shell/grabs/mod.rs
index 18744cda..7a4b3b9c 100644
--- a/src/shell/grabs/mod.rs
+++ b/src/shell/grabs/mod.rs
@@ -31,14 +31,14 @@ pub enum GrabStartData {
 }
 
 impl GrabStartData {
-    pub fn focus(&self) -> Option<&(PointerFocusTarget, Point<i32, Logical>)> {
+    pub fn focus(&self) -> Option<&(PointerFocusTarget, Point<f64, Logical>)> {
         match self {
             Self::Touch(touch) => touch.focus.as_ref(),
             Self::Pointer(pointer) => pointer.focus.as_ref(),
         }
     }
 
-    pub fn set_focus(&mut self, focus: Option<(PointerFocusTarget, Point<i32, Logical>)>) {
+    pub fn set_focus(&mut self, focus: Option<(PointerFocusTarget, Point<f64, Logical>)>) {
         match self {
             Self::Touch(touch) => touch.focus = focus,
             Self::Pointer(pointer) => pointer.focus = focus,
@@ -167,7 +167,7 @@ impl PointerGrab<State> for ResizeGrab {
         &mut self,
         data: &mut State,
         handle: &mut PointerInnerHandle<'_, State>,
-        focus: Option<(PointerFocusTarget, Point<i32, Logical>)>,
+        focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
         event: &MotionEvent,
     ) {
         match self {
@@ -180,7 +180,7 @@ impl PointerGrab<State> for ResizeGrab {
         &mut self,
         data: &mut State,
         handle: &mut PointerInnerHandle<'_, State>,
-        focus: Option<(PointerFocusTarget, Point<i32, Logical>)>,
+        focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
         event: &RelativeMotionEvent,
     ) {
         match self {
@@ -336,7 +336,7 @@ impl TouchGrab<State> for ResizeGrab {
         &mut self,
         data: &mut State,
         handle: &mut TouchInnerHandle<'_, State>,
-        focus: Option<(PointerFocusTarget, Point<i32, Logical>)>,
+        focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
         event: &DownEvent,
         seq: Serial,
     ) {
@@ -363,7 +363,7 @@ impl TouchGrab<State> for ResizeGrab {
         &mut self,
         data: &mut State,
         handle: &mut TouchInnerHandle<'_, State>,
-        focus: Option<(PointerFocusTarget, Point<i32, Logical>)>,
+        focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
         event: &TouchMotionEvent,
         seq: Serial,
     ) {
diff --git a/src/shell/grabs/moving.rs b/src/shell/grabs/moving.rs
index 45695cc7..28f20e36 100644
--- a/src/shell/grabs/moving.rs
+++ b/src/shell/grabs/moving.rs
@@ -445,7 +445,7 @@ impl PointerGrab<State> for MoveGrab {
         &mut self,
         state: &mut State,
         handle: &mut PointerInnerHandle<'_, State>,
-        _focus: Option<(PointerFocusTarget, Point<i32, Logical>)>,
+        _focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
         event: &MotionEvent,
     ) {
         self.update_location(state, event.location);
@@ -461,7 +461,7 @@ impl PointerGrab<State> for MoveGrab {
         &mut self,
         state: &mut State,
         handle: &mut PointerInnerHandle<'_, State>,
-        _focus: Option<(PointerFocusTarget, Point<i32, Logical>)>,
+        _focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
         event: &RelativeMotionEvent,
     ) {
         // While the grab is active, no client has pointer focus
@@ -589,7 +589,7 @@ impl TouchGrab<State> for MoveGrab {
         &mut self,
         data: &mut State,
         handle: &mut TouchInnerHandle<'_, State>,
-        _focus: Option<(PointerFocusTarget, Point<i32, Logical>)>,
+        _focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
         event: &touch::DownEvent,
         seq: Serial,
     ) {
@@ -614,7 +614,7 @@ impl TouchGrab<State> for MoveGrab {
         &mut self,
         data: &mut State,
         handle: &mut TouchInnerHandle<'_, State>,
-        _focus: Option<(PointerFocusTarget, Point<i32, Logical>)>,
+        _focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
         event: &touch::MotionEvent,
         seq: Serial,
     ) {
@@ -858,7 +858,7 @@ impl Drop for MoveGrab {
                             state,
                             Some((
                                 target,
-                                position.as_logical() - window.geometry().loc + offset,
+                                position.as_logical().to_f64() - window.geometry().loc.to_f64() + offset,
                             )),
                             &MotionEvent {
                                 location: pointer.current_location(),
diff --git a/src/shell/layout/floating/grabs/resize.rs b/src/shell/layout/floating/grabs/resize.rs
index d5a40c6a..e0ee2911 100644
--- a/src/shell/layout/floating/grabs/resize.rs
+++ b/src/shell/layout/floating/grabs/resize.rs
@@ -137,7 +137,7 @@ impl PointerGrab<State> for ResizeSurfaceGrab {
         &mut self,
         data: &mut State,
         handle: &mut PointerInnerHandle<'_, State>,
-        _focus: Option<(PointerFocusTarget, Point<i32, Logical>)>,
+        _focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
         event: &MotionEvent,
     ) {
         // While the grab is active, no client has pointer focus
@@ -152,7 +152,7 @@ impl PointerGrab<State> for ResizeSurfaceGrab {
         &mut self,
         state: &mut State,
         handle: &mut PointerInnerHandle<'_, State>,
-        _focus: Option<(PointerFocusTarget, Point<i32, Logical>)>,
+        _focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
         event: &RelativeMotionEvent,
     ) {
         // While the grab is active, no client has pointer focus
@@ -282,7 +282,7 @@ impl TouchGrab<State> for ResizeSurfaceGrab {
         &mut self,
         data: &mut State,
         handle: &mut TouchInnerHandle<'_, State>,
-        _focus: Option<(PointerFocusTarget, Point<i32, Logical>)>,
+        _focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
         event: &DownEvent,
         seq: Serial,
     ) {
@@ -307,7 +307,7 @@ impl TouchGrab<State> for ResizeSurfaceGrab {
         &mut self,
         data: &mut State,
         handle: &mut TouchInnerHandle<'_, State>,
-        _focus: Option<(PointerFocusTarget, Point<i32, Logical>)>,
+        _focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
         event: &TouchMotionEvent,
         seq: Serial,
     ) {
diff --git a/src/shell/layout/floating/mod.rs b/src/shell/layout/floating/mod.rs
index 7476ddd7..92cca3cf 100644
--- a/src/shell/layout/floating/mod.rs
+++ b/src/shell/layout/floating/mod.rs
@@ -730,7 +730,7 @@ impl FloatingLayout {
     pub fn surface_under(
         &mut self,
         location: Point<f64, Local>,
-    ) -> Option<(PointerFocusTarget, Point<i32, Local>)> {
+    ) -> Option<(PointerFocusTarget, Point<f64, Local>)> {
         let res = self
             .space
             .element_under(location.as_logical())
@@ -753,7 +753,7 @@ impl FloatingLayout {
             element
                 .focus_under(point.as_logical())
                 .map(|(surface, surface_offset)| {
-                    (surface, space_offset + surface_offset.as_local())
+                    (surface, space_offset.to_f64() + surface_offset.as_local())
                 })
         })
     }
diff --git a/src/shell/layout/tiling/grabs/resize.rs b/src/shell/layout/tiling/grabs/resize.rs
index 428f8682..562b2d44 100644
--- a/src/shell/layout/tiling/grabs/resize.rs
+++ b/src/shell/layout/tiling/grabs/resize.rs
@@ -336,7 +336,7 @@ impl PointerGrab<State> for ResizeForkGrab {
         &mut self,
         data: &mut State,
         handle: &mut PointerInnerHandle<'_, State>,
-        _focus: Option<(PointerFocusTarget, Point<i32, Logical>)>,
+        _focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
         event: &MotionEvent,
     ) {
         // While the grab is active, no client has pointer focus
@@ -351,7 +351,7 @@ impl PointerGrab<State> for ResizeForkGrab {
         &mut self,
         state: &mut State,
         handle: &mut PointerInnerHandle<'_, State>,
-        _focus: Option<(PointerFocusTarget, Point<i32, Logical>)>,
+        _focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
         event: &RelativeMotionEvent,
     ) {
         // While the grab is active, no client has pointer focus
@@ -479,7 +479,7 @@ impl TouchGrab<State> for ResizeForkGrab {
         &mut self,
         data: &mut State,
         handle: &mut TouchInnerHandle<'_, State>,
-        _focus: Option<(PointerFocusTarget, Point<i32, Logical>)>,
+        _focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
         event: &DownEvent,
         seq: Serial,
     ) {
@@ -504,7 +504,7 @@ impl TouchGrab<State> for ResizeForkGrab {
         &mut self,
         data: &mut State,
         handle: &mut TouchInnerHandle<'_, State>,
-        _focus: Option<(PointerFocusTarget, Point<i32, Logical>)>,
+        _focus: Option<(PointerFocusTarget, Point<f64, Logical>)>,
         event: &TouchMotionEvent,
         seq: Serial,
     ) {
diff --git a/src/shell/layout/tiling/mod.rs b/src/shell/layout/tiling/mod.rs
index d1ad81df..ea693db9 100644
--- a/src/shell/layout/tiling/mod.rs
+++ b/src/shell/layout/tiling/mod.rs
@@ -3101,7 +3101,7 @@ impl TilingLayout {
         &mut self,
         location_f64: Point<f64, Local>,
         overview: OverviewMode,
-    ) -> Option<(PointerFocusTarget, Point<i32, Local>)> {
+    ) -> Option<(PointerFocusTarget, Point<f64, Local>)> {
         let gaps = self.gaps();
         let last_overview_hover = &mut self.last_overview_hover;
         let placeholder_id = &self.placeholder_id;
@@ -3132,7 +3132,8 @@ impl TilingLayout {
                 ) {
                     return Some((
                         target,
-                        geo.loc - mapped.geometry().loc.as_local() + surface_offset.as_local(),
+                        geo.loc.to_f64() - mapped.geometry().loc.as_local().to_f64()
+                            + surface_offset.as_local(),
                     ));
                 }
             }
@@ -3179,7 +3180,8 @@ impl TilingLayout {
                         .map(|(surface, surface_offset)| {
                             (
                                 surface,
-                                last_geometry.loc - mapped.geometry().loc.as_local()
+                                last_geometry.loc.to_f64()
+                                    - mapped.geometry().loc.as_local().to_f64()
                                     + surface_offset.as_local(),
                             )
                         })
@@ -3211,7 +3213,7 @@ impl TilingLayout {
                             orientation,
                         }
                         .into(),
-                        last_geometry.loc
+                        (last_geometry.loc
                             + tree
                                 .children(&id)
                                 .unwrap()
@@ -3221,7 +3223,8 @@ impl TilingLayout {
                                     let geo = node.data().geometry();
                                     geo.loc + geo.size
                                 })
-                                .unwrap(),
+                                .unwrap())
+                        .to_f64(),
                     ))
                 }
                 _ => None,
diff --git a/src/shell/mod.rs b/src/shell/mod.rs
index ab123667..060c02dc 100644
--- a/src/shell/mod.rs
+++ b/src/shell/mod.rs
@@ -2001,7 +2001,7 @@ impl Shell {
         &mut self,
         location: Point<f64, Global>,
         output: &Output,
-    ) -> Option<(PointerFocusTarget, Point<i32, Global>)> {
+    ) -> Option<(PointerFocusTarget, Point<f64, Global>)> {
         let overview = self.overview_mode.clone();
         self.workspaces.sets.get_mut(output).and_then(|set| {
             set.sticky_layer
@@ -2659,7 +2659,7 @@ impl Shell {
         edge: ResizeEdge,
     ) -> Option<(
         (
-            Option<(PointerFocusTarget, Point<i32, Logical>)>,
+            Option<(PointerFocusTarget, Point<f64, Logical>)>,
             Point<i32, Global>,
         ),
         (ResizeGrab, Focus),
@@ -2715,7 +2715,7 @@ impl Shell {
         let element_offset = (new_loc - geometry.loc).as_logical();
         let focus = mapped
             .focus_under(element_offset.to_f64())
-            .map(|(target, surface_offset)| (target, (surface_offset + element_offset)));
+            .map(|(target, surface_offset)| (target, (surface_offset + element_offset.to_f64())));
         start_data.set_location(new_loc.as_logical().to_f64());
         start_data.set_focus(focus.clone());
 
@@ -3185,7 +3185,7 @@ pub fn check_grab_preconditions(
         } else {
             GrabStartData::Pointer(pointer.grab_start_data().unwrap_or_else(|| {
                 PointerGrabStartData {
-                    focus: pointer.current_focus().map(|f| (f, Point::from((0, 0)))),
+                    focus: pointer.current_focus().map(|f| (f, Point::from((0., 0.)))),
                     button: 0x110,
                     location: pointer.current_location(),
                 }
diff --git a/src/shell/workspace.rs b/src/shell/workspace.rs
index ac6dcb57..a36304d8 100644
--- a/src/shell/workspace.rs
+++ b/src/shell/workspace.rs
@@ -475,7 +475,7 @@ impl Workspace {
         &mut self,
         location: Point<f64, Global>,
         overview: OverviewMode,
-    ) -> Option<(PointerFocusTarget, Point<i32, Global>)> {
+    ) -> Option<(PointerFocusTarget, Point<f64, Global>)> {
         let location = location.to_local(&self.output);
         self.floating_layer
             .surface_under(location)
@@ -1360,14 +1360,23 @@ impl RenderElement<GlowRenderer> for WorkspaceRenderElement<GlowRenderer> {
         src: Rectangle<f64, BufferCoords>,
         dst: Rectangle<i32, Physical>,
         damage: &[Rectangle<i32, smithay::utils::Physical>],
+        opaque_regions: &[Rectangle<i32, Physical>],
     ) -> Result<(), GlesError> {
         match self {
-            WorkspaceRenderElement::OverrideRedirect(elem) => elem.draw(frame, src, dst, damage),
-            WorkspaceRenderElement::Fullscreen(elem) => elem.draw(frame, src, dst, damage),
-            WorkspaceRenderElement::FullscreenPopup(elem) => elem.draw(frame, src, dst, damage),
-            WorkspaceRenderElement::Window(elem) => elem.draw(frame, src, dst, damage),
+            WorkspaceRenderElement::OverrideRedirect(elem) => {
+                elem.draw(frame, src, dst, damage, opaque_regions)
+            }
+            WorkspaceRenderElement::Fullscreen(elem) => {
+                elem.draw(frame, src, dst, damage, opaque_regions)
+            }
+            WorkspaceRenderElement::FullscreenPopup(elem) => {
+                elem.draw(frame, src, dst, damage, opaque_regions)
+            }
+            WorkspaceRenderElement::Window(elem) => {
+                elem.draw(frame, src, dst, damage, opaque_regions)
+            }
             WorkspaceRenderElement::Backdrop(elem) => {
-                RenderElement::<GlowRenderer>::draw(elem, frame, src, dst, damage)
+                RenderElement::<GlowRenderer>::draw(elem, frame, src, dst, damage, opaque_regions)
             }
         }
     }
@@ -1393,16 +1402,30 @@ impl<'a> RenderElement<GlMultiRenderer<'a>> for WorkspaceRenderElement<GlMultiRe
         src: Rectangle<f64, BufferCoords>,
         dst: Rectangle<i32, Physical>,
         damage: &[Rectangle<i32, smithay::utils::Physical>],
+        opaque_regions: &[Rectangle<i32, Physical>],
     ) -> Result<(), GlMultiError> {
         match self {
-            WorkspaceRenderElement::OverrideRedirect(elem) => elem.draw(frame, src, dst, damage),
-            WorkspaceRenderElement::Fullscreen(elem) => elem.draw(frame, src, dst, damage),
-            WorkspaceRenderElement::FullscreenPopup(elem) => elem.draw(frame, src, dst, damage),
-            WorkspaceRenderElement::Window(elem) => elem.draw(frame, src, dst, damage),
-            WorkspaceRenderElement::Backdrop(elem) => {
-                RenderElement::<GlowRenderer>::draw(elem, frame.glow_frame_mut(), src, dst, damage)
-                    .map_err(GlMultiError::Render)
+            WorkspaceRenderElement::OverrideRedirect(elem) => {
+                elem.draw(frame, src, dst, damage, opaque_regions)
             }
+            WorkspaceRenderElement::Fullscreen(elem) => {
+                elem.draw(frame, src, dst, damage, opaque_regions)
+            }
+            WorkspaceRenderElement::FullscreenPopup(elem) => {
+                elem.draw(frame, src, dst, damage, opaque_regions)
+            }
+            WorkspaceRenderElement::Window(elem) => {
+                elem.draw(frame, src, dst, damage, opaque_regions)
+            }
+            WorkspaceRenderElement::Backdrop(elem) => RenderElement::<GlowRenderer>::draw(
+                elem,
+                frame.glow_frame_mut(),
+                src,
+                dst,
+                damage,
+                opaque_regions,
+            )
+            .map_err(GlMultiError::Render),
         }
     }
 
diff --git a/src/wayland/handlers/compositor.rs b/src/wayland/handlers/compositor.rs
index 39d039df..8ece0e71 100644
--- a/src/wayland/handlers/compositor.rs
+++ b/src/wayland/handlers/compositor.rs
@@ -22,7 +22,7 @@ use smithay::{
             },
         },
     },
-    xwayland::{X11Wm, XWaylandClientData},
+    xwayland::XWaylandClientData,
 };
 use std::sync::Mutex;
 
@@ -134,7 +134,6 @@ impl CompositorHandler for State {
     }
 
     fn commit(&mut self, surface: &WlSurface) {
-        X11Wm::commit_hook::<State>(self, surface);
         // first load the buffer for various smithay helper functions (which also initializes the RendererSurfaceState)
         on_commit_buffer_handler::<Self>(surface);