diff --git a/src/shell/element/stack.rs b/src/shell/element/stack.rs
index 3b1aab87..92d29b75 100644
--- a/src/shell/element/stack.rs
+++ b/src/shell/element/stack.rs
@@ -4,14 +4,8 @@ use super::{
 };
 use crate::{
     backend::render::{
-        IndicatorShader, Key, Usage,
-        cursor::CursorState,
-        element::AsGlowRenderer,
-        shadow::ShadowShader,
-        wayland::{
-            SurfaceRenderElement,
-            blur_effect::{BlurElement, BlurState},
-        },
+        IndicatorShader, Key, Usage, cursor::CursorState, element::AsGlowRenderer,
+        shadow::ShadowShader, wayland::SurfaceRenderElement,
     },
     hooks::{Decorations, HOOKS},
     shell::{
@@ -22,7 +16,7 @@ use crate::{
     },
     state::State,
     utils::{
-        iced::{IcedElement, Program},
+        iced::{IcedElement, IcedRenderElement, Program},
         prelude::*,
     },
 };
@@ -47,10 +41,7 @@ use smithay::{
         input::KeyState,
         renderer::{
             ImportAll, ImportMem, Renderer,
-            element::{
-                Element, Id as RendererId, Kind, RenderElement, UnderlyingStorage,
-                memory::MemoryRenderBufferRenderElement,
-            },
+            element::{Element, Id as RendererId, Kind, RenderElement, UnderlyingStorage},
             gles::element::PixelShaderElement,
             glow::GlowRenderer,
             utils::{CommitCounter, DamageSet, OpaqueRegions},
@@ -129,7 +120,6 @@ pub struct CosmicStackInternal {
     tiled: AtomicBool,
     theme: Mutex<cosmic::Theme>,
     appearance_conf: Mutex<AppearanceConfig>,
-    blur_state: Mutex<BlurState>,
 }
 
 impl CosmicStackInternal {
@@ -156,9 +146,10 @@ impl CosmicStack {
     pub fn new<I: Into<CosmicSurface>>(
         windows: impl Iterator<Item = I>,
         handle: LoopHandle<'static, crate::state::State>,
-        theme: cosmic::Theme,
+        mut theme: cosmic::Theme,
         appearance: AppearanceConfig,
     ) -> CosmicStack {
+        theme.transparent = theme.cosmic().frosted_windows;
         let windows = windows.map(Into::into).collect::<Vec<_>>();
         assert!(!windows.is_empty());
 
@@ -188,7 +179,6 @@ impl CosmicStack {
                 tiled: AtomicBool::new(false),
                 theme: Mutex::new(theme.clone()),
                 appearance_conf: Mutex::new(appearance),
-                blur_state: Default::default(),
             },
             (width, TAB_HEIGHT),
             handle,
@@ -811,11 +801,6 @@ impl CosmicStack {
             })
         });
 
-        self.0
-            .push_render_elements(renderer, stack_loc, scale, alpha, &mut |elem| {
-                push_above(elem.into())
-            });
-
         self.0.with_program(|p| {
             let windows = p.windows.lock().unwrap();
             let active = p.active.load(Ordering::SeqCst);
@@ -862,31 +847,19 @@ impl CosmicStack {
             );
         });
 
-        if frosted > 0 {
-            let geometry = Rectangle::new(
-                stack_loc.to_f64().to_logical(scale),
-                Size::new(
-                    geometry.size.to_f64().to_logical(scale).w,
-                    TAB_HEIGHT as f64,
-                ),
-            );
-            if let Ok(Some(elem)) = self.0.with_program(|p| {
-                let mut state = p.blur_state.lock().unwrap();
-                BlurElement::from_state(
-                    renderer,
-                    &mut state,
-                    geometry,
-                    scale.x,
-                    radii.map(|[_, b, _, d]| [0, b, 0, d]).unwrap_or([0; 4]),
-                    frosted,
-                )
-            }) {
-                push_below(elem.into());
-            }
-        }
+        self.0.push_render_elements(
+            renderer,
+            stack_loc,
+            scale,
+            alpha,
+            radii.map(|[_, b, _, d]| [0, b, 0, d]).unwrap_or([0; 4]),
+            &mut |elem| push_above(elem.into()),
+            Some(&mut |elem| push_below(elem.into())),
+        );
     }
 
-    pub(crate) fn set_theme(&self, theme: cosmic::Theme) {
+    pub(crate) fn set_theme(&self, mut theme: cosmic::Theme) {
+        theme.transparent = theme.cosmic().frosted_windows;
         self.0.with_program(|p| {
             *p.theme.lock().unwrap() = theme.clone();
         });
@@ -1929,27 +1902,20 @@ impl TouchTarget<State> for CosmicStack {
 }
 
 pub enum CosmicStackRenderElement<R: Renderer + ImportAll + ImportMem> {
-    Header(MemoryRenderBufferRenderElement<R>),
-    HeaderBlur(BlurElement),
+    Header(IcedRenderElement<R>),
     Shadow(PixelShaderElement),
     Border(PixelShaderElement),
     Window(SurfaceRenderElement<R>),
 }
 
-impl<R: Renderer + ImportAll + ImportMem> From<MemoryRenderBufferRenderElement<R>>
+impl<R: Renderer + ImportAll + ImportMem> From<IcedRenderElement<R>>
     for CosmicStackRenderElement<R>
 {
-    fn from(value: MemoryRenderBufferRenderElement<R>) -> Self {
+    fn from(value: IcedRenderElement<R>) -> Self {
         Self::Header(value)
     }
 }
 
-impl<R: Renderer + AsGlowRenderer> From<BlurElement> for CosmicStackRenderElement<R> {
-    fn from(value: BlurElement) -> Self {
-        Self::HeaderBlur(value)
-    }
-}
-
 impl<R: Renderer + ImportAll + ImportMem> From<SurfaceRenderElement<R>>
     for CosmicStackRenderElement<R>
 {
@@ -1966,7 +1932,6 @@ where
     fn id(&self) -> &RendererId {
         match self {
             CosmicStackRenderElement::Header(elem) => elem.id(),
-            CosmicStackRenderElement::HeaderBlur(elem) => elem.id(),
             CosmicStackRenderElement::Shadow(elem) => elem.id(),
             CosmicStackRenderElement::Border(elem) => elem.id(),
             CosmicStackRenderElement::Window(elem) => elem.id(),
@@ -1976,7 +1941,6 @@ where
     fn current_commit(&self) -> CommitCounter {
         match self {
             CosmicStackRenderElement::Header(elem) => elem.current_commit(),
-            CosmicStackRenderElement::HeaderBlur(elem) => elem.current_commit(),
             CosmicStackRenderElement::Shadow(elem) => elem.current_commit(),
             CosmicStackRenderElement::Border(elem) => elem.current_commit(),
             CosmicStackRenderElement::Window(elem) => elem.current_commit(),
@@ -1986,7 +1950,6 @@ where
     fn src(&self) -> Rectangle<f64, Buffer> {
         match self {
             CosmicStackRenderElement::Header(elem) => elem.src(),
-            CosmicStackRenderElement::HeaderBlur(elem) => elem.src(),
             CosmicStackRenderElement::Shadow(elem) => elem.src(),
             CosmicStackRenderElement::Border(elem) => elem.src(),
             CosmicStackRenderElement::Window(elem) => elem.src(),
@@ -1996,7 +1959,6 @@ where
     fn geometry(&self, scale: Scale<f64>) -> Rectangle<i32, Physical> {
         match self {
             CosmicStackRenderElement::Header(elem) => elem.geometry(scale),
-            CosmicStackRenderElement::HeaderBlur(elem) => elem.geometry(scale),
             CosmicStackRenderElement::Shadow(elem) => elem.geometry(scale),
             CosmicStackRenderElement::Border(elem) => elem.geometry(scale),
             CosmicStackRenderElement::Window(elem) => elem.geometry(scale),
@@ -2006,7 +1968,6 @@ where
     fn location(&self, scale: Scale<f64>) -> Point<i32, Physical> {
         match self {
             CosmicStackRenderElement::Header(elem) => elem.location(scale),
-            CosmicStackRenderElement::HeaderBlur(elem) => elem.location(scale),
             CosmicStackRenderElement::Shadow(elem) => elem.location(scale),
             CosmicStackRenderElement::Border(elem) => elem.location(scale),
             CosmicStackRenderElement::Window(elem) => elem.location(scale),
@@ -2016,7 +1977,6 @@ where
     fn transform(&self) -> Transform {
         match self {
             CosmicStackRenderElement::Header(elem) => elem.transform(),
-            CosmicStackRenderElement::HeaderBlur(elem) => elem.transform(),
             CosmicStackRenderElement::Shadow(elem) => elem.transform(),
             CosmicStackRenderElement::Border(elem) => elem.transform(),
             CosmicStackRenderElement::Window(elem) => elem.transform(),
@@ -2030,7 +1990,6 @@ where
     ) -> DamageSet<i32, Physical> {
         match self {
             CosmicStackRenderElement::Header(elem) => elem.damage_since(scale, commit),
-            CosmicStackRenderElement::HeaderBlur(elem) => elem.damage_since(scale, commit),
             CosmicStackRenderElement::Shadow(elem) => elem.damage_since(scale, commit),
             CosmicStackRenderElement::Border(elem) => elem.damage_since(scale, commit),
             CosmicStackRenderElement::Window(elem) => elem.damage_since(scale, commit),
@@ -2040,7 +1999,6 @@ where
     fn opaque_regions(&self, scale: Scale<f64>) -> OpaqueRegions<i32, Physical> {
         match self {
             CosmicStackRenderElement::Header(elem) => elem.opaque_regions(scale),
-            CosmicStackRenderElement::HeaderBlur(elem) => elem.opaque_regions(scale),
             CosmicStackRenderElement::Shadow(elem) => elem.opaque_regions(scale),
             CosmicStackRenderElement::Border(elem) => elem.opaque_regions(scale),
             CosmicStackRenderElement::Window(elem) => elem.opaque_regions(scale),
@@ -2050,7 +2008,6 @@ where
     fn alpha(&self) -> f32 {
         match self {
             CosmicStackRenderElement::Header(elem) => elem.alpha(),
-            CosmicStackRenderElement::HeaderBlur(elem) => elem.alpha(),
             CosmicStackRenderElement::Shadow(elem) => elem.alpha(),
             CosmicStackRenderElement::Border(elem) => elem.alpha(),
             CosmicStackRenderElement::Window(elem) => elem.alpha(),
@@ -2060,7 +2017,6 @@ where
     fn kind(&self) -> Kind {
         match self {
             CosmicStackRenderElement::Header(elem) => elem.kind(),
-            CosmicStackRenderElement::HeaderBlur(elem) => elem.kind(),
             CosmicStackRenderElement::Shadow(elem) => elem.kind(),
             CosmicStackRenderElement::Border(elem) => elem.kind(),
             CosmicStackRenderElement::Window(elem) => elem.kind(),
@@ -2070,7 +2026,6 @@ where
     fn is_framebuffer_effect(&self) -> bool {
         match self {
             CosmicStackRenderElement::Header(elem) => elem.is_framebuffer_effect(),
-            CosmicStackRenderElement::HeaderBlur(elem) => elem.is_framebuffer_effect(),
             CosmicStackRenderElement::Shadow(elem) => elem.is_framebuffer_effect(),
             CosmicStackRenderElement::Border(elem) => elem.is_framebuffer_effect(),
             CosmicStackRenderElement::Window(elem) => elem.is_framebuffer_effect(),
@@ -2096,9 +2051,6 @@ where
             CosmicStackRenderElement::Header(elem) => {
                 elem.draw(frame, src, dst, damage, opaque_regions, cache)
             }
-            CosmicStackRenderElement::HeaderBlur(elem) => {
-                RenderElement::<R>::draw(elem, frame, src, dst, damage, opaque_regions, cache)
-            }
             CosmicStackRenderElement::Shadow(elem) | CosmicStackRenderElement::Border(elem) => {
                 RenderElement::<GlowRenderer>::draw(
                     elem,
@@ -2120,7 +2072,6 @@ where
     fn underlying_storage(&self, renderer: &mut R) -> Option<UnderlyingStorage<'_>> {
         match self {
             CosmicStackRenderElement::Header(elem) => elem.underlying_storage(renderer),
-            CosmicStackRenderElement::HeaderBlur(elem) => elem.underlying_storage(renderer),
             CosmicStackRenderElement::Shadow(elem) | CosmicStackRenderElement::Border(elem) => {
                 elem.underlying_storage(renderer.glow_renderer_mut())
             }
@@ -2139,9 +2090,6 @@ where
             CosmicStackRenderElement::Header(elem) => {
                 elem.capture_framebuffer(frame, src, dst, cache)
             }
-            CosmicStackRenderElement::HeaderBlur(elem) => {
-                RenderElement::<R>::capture_framebuffer(elem, frame, src, dst, cache)
-            }
             CosmicStackRenderElement::Shadow(elem) | CosmicStackRenderElement::Border(elem) => {
                 RenderElement::<GlowRenderer>::capture_framebuffer(
                     elem,
diff --git a/src/shell/element/window.rs b/src/shell/element/window.rs
index b978cfd3..09c59f90 100644
--- a/src/shell/element/window.rs
+++ b/src/shell/element/window.rs
@@ -1,13 +1,7 @@
 use crate::{
     backend::render::{
-        IndicatorShader, Key, Usage,
-        cursor::CursorState,
-        element::AsGlowRenderer,
-        shadow::ShadowShader,
-        wayland::{
-            SurfaceRenderElement,
-            blur_effect::{BlurElement, BlurState},
-        },
+        IndicatorShader, Key, Usage, cursor::CursorState, element::AsGlowRenderer,
+        shadow::ShadowShader, wayland::SurfaceRenderElement,
     },
     hooks::{Decorations, HOOKS},
     shell::{
@@ -17,7 +11,7 @@ use crate::{
     },
     state::State,
     utils::{
-        iced::{IcedElement, Program},
+        iced::{IcedElement, IcedRenderElement, Program},
         prelude::*,
     },
 };
@@ -30,10 +24,7 @@ use smithay::{
         input::KeyState,
         renderer::{
             ImportAll, ImportMem, Renderer,
-            element::{
-                Element, Id as RendererId, Kind, RenderElement, UnderlyingStorage,
-                memory::MemoryRenderBufferRenderElement,
-            },
+            element::{Element, Id as RendererId, Kind, RenderElement, UnderlyingStorage},
             gles::element::PixelShaderElement,
             glow::GlowRenderer,
             utils::{CommitCounter, DamageSet, OpaqueRegions},
@@ -99,7 +90,6 @@ pub struct CosmicWindowInternal {
     tiled: AtomicBool,
     theme: Mutex<cosmic::Theme>,
     appearance_conf: Mutex<AppearanceConfig>,
-    blur_state: Mutex<BlurState>,
 }
 
 #[repr(u8)]
@@ -200,12 +190,13 @@ impl CosmicWindow {
     pub fn new(
         window: impl Into<CosmicSurface>,
         handle: LoopHandle<'static, crate::state::State>,
-        theme: cosmic::Theme,
+        mut theme: cosmic::Theme,
         appearance: AppearanceConfig,
     ) -> CosmicWindow {
         let window = window.into();
         let width = window.geometry().size.w;
         let last_title = window.title();
+        theme.transparent = theme.cosmic().frosted_windows;
 
         if appearance.clip_floating_windows {
             window.set_tiled(true);
@@ -220,7 +211,6 @@ impl CosmicWindow {
                 tiled: AtomicBool::new(false),
                 theme: Mutex::new(theme.clone()),
                 appearance_conf: Mutex::new(appearance),
-                blur_state: Mutex::default(),
             },
             (width, SSD_HEIGHT),
             handle,
@@ -558,7 +548,7 @@ impl CosmicWindow {
             push_above(elem);
         }
 
-        let frosted = self.0.with_program(|p| {
+        self.0.with_program(|p| {
             if has_ssd {
                 radii[1] = 0;
                 radii[3] = 0;
@@ -582,8 +572,6 @@ impl CosmicWindow {
                 &mut |elem| push_above(elem.into()),
                 Some(&mut |elem| push_below(elem.into())),
             );
-
-            frosted
         });
 
         if has_ssd {
@@ -591,26 +579,20 @@ impl CosmicWindow {
                 + self
                     .0
                     .with_program(|p| p.window.geometry().loc.to_physical_precise_round(scale));
-            if frosted > 0 {
-                let geometry = Rectangle::new(
-                    ssd_loc.to_f64().to_logical(scale),
-                    Size::new(geo.size.w, SSD_HEIGHT as f64),
-                );
-                if let Ok(Some(elem)) = self.0.with_program(|p| {
-                    let mut state = p.blur_state.lock().unwrap();
-                    BlurElement::from_state(renderer, &mut state, geometry, scale.x, radii, frosted)
-                }) {
-                    push_below(elem.into());
-                }
-            }
-            self.0
-                .push_render_elements(renderer, ssd_loc, scale, alpha, &mut |elem| {
-                    push_above(elem.into())
-                });
+            self.0.push_render_elements(
+                renderer,
+                ssd_loc,
+                scale,
+                alpha,
+                radii,
+                &mut |elem| push_above(elem.into()),
+                Some(&mut |elem| push_below(elem.into())),
+            );
         }
     }
 
-    pub(crate) fn set_theme(&self, theme: cosmic::Theme) {
+    pub(crate) fn set_theme(&self, mut theme: cosmic::Theme) {
+        theme.transparent = theme.cosmic().frosted_windows;
         self.0.with_program(|p| {
             *p.theme.lock().unwrap() = theme.clone();
         });
@@ -1267,29 +1249,22 @@ impl WaylandFocus for CosmicWindow {
     }
 }
 
-pub enum CosmicWindowRenderElement<R: Renderer + ImportAll + ImportMem> {
-    Header(MemoryRenderBufferRenderElement<R>),
-    HeaderBlur(BlurElement),
+pub enum CosmicWindowRenderElement<R: AsGlowRenderer + ImportAll + ImportMem> {
+    Header(IcedRenderElement<R>),
     Shadow(PixelShaderElement),
     Border(PixelShaderElement),
     Window(SurfaceRenderElement<R>),
 }
 
-impl<R: Renderer + ImportAll + ImportMem> From<MemoryRenderBufferRenderElement<R>>
+impl<R: AsGlowRenderer + ImportAll + ImportMem> From<IcedRenderElement<R>>
     for CosmicWindowRenderElement<R>
 {
-    fn from(value: MemoryRenderBufferRenderElement<R>) -> Self {
+    fn from(value: IcedRenderElement<R>) -> Self {
         Self::Header(value)
     }
 }
 
-impl<R: Renderer + AsGlowRenderer> From<BlurElement> for CosmicWindowRenderElement<R> {
-    fn from(value: BlurElement) -> Self {
-        Self::HeaderBlur(value)
-    }
-}
-
-impl<R: Renderer + ImportAll + ImportMem> From<SurfaceRenderElement<R>>
+impl<R: AsGlowRenderer + ImportAll + ImportMem> From<SurfaceRenderElement<R>>
     for CosmicWindowRenderElement<R>
 {
     fn from(value: SurfaceRenderElement<R>) -> Self {
@@ -1305,7 +1280,6 @@ where
     fn id(&self) -> &RendererId {
         match self {
             CosmicWindowRenderElement::Header(elem) => elem.id(),
-            CosmicWindowRenderElement::HeaderBlur(elem) => elem.id(),
             CosmicWindowRenderElement::Shadow(elem) => elem.id(),
             CosmicWindowRenderElement::Border(elem) => elem.id(),
             CosmicWindowRenderElement::Window(elem) => elem.id(),
@@ -1315,7 +1289,6 @@ where
     fn current_commit(&self) -> CommitCounter {
         match self {
             CosmicWindowRenderElement::Header(elem) => elem.current_commit(),
-            CosmicWindowRenderElement::HeaderBlur(elem) => elem.current_commit(),
             CosmicWindowRenderElement::Shadow(elem) => elem.current_commit(),
             CosmicWindowRenderElement::Border(elem) => elem.current_commit(),
             CosmicWindowRenderElement::Window(elem) => elem.current_commit(),
@@ -1325,7 +1298,6 @@ where
     fn src(&self) -> Rectangle<f64, Buffer> {
         match self {
             CosmicWindowRenderElement::Header(elem) => elem.src(),
-            CosmicWindowRenderElement::HeaderBlur(elem) => elem.src(),
             CosmicWindowRenderElement::Shadow(elem) => elem.src(),
             CosmicWindowRenderElement::Border(elem) => elem.src(),
             CosmicWindowRenderElement::Window(elem) => elem.src(),
@@ -1335,7 +1307,6 @@ where
     fn geometry(&self, scale: Scale<f64>) -> Rectangle<i32, Physical> {
         match self {
             CosmicWindowRenderElement::Header(elem) => elem.geometry(scale),
-            CosmicWindowRenderElement::HeaderBlur(elem) => elem.geometry(scale),
             CosmicWindowRenderElement::Shadow(elem) => elem.geometry(scale),
             CosmicWindowRenderElement::Border(elem) => elem.geometry(scale),
             CosmicWindowRenderElement::Window(elem) => elem.geometry(scale),
@@ -1345,7 +1316,6 @@ where
     fn location(&self, scale: Scale<f64>) -> Point<i32, Physical> {
         match self {
             CosmicWindowRenderElement::Header(elem) => elem.location(scale),
-            CosmicWindowRenderElement::HeaderBlur(elem) => elem.location(scale),
             CosmicWindowRenderElement::Shadow(elem) => elem.location(scale),
             CosmicWindowRenderElement::Border(elem) => elem.location(scale),
             CosmicWindowRenderElement::Window(elem) => elem.location(scale),
@@ -1355,7 +1325,6 @@ where
     fn transform(&self) -> Transform {
         match self {
             CosmicWindowRenderElement::Header(elem) => elem.transform(),
-            CosmicWindowRenderElement::HeaderBlur(elem) => elem.transform(),
             CosmicWindowRenderElement::Shadow(elem) => elem.transform(),
             CosmicWindowRenderElement::Border(elem) => elem.transform(),
             CosmicWindowRenderElement::Window(elem) => elem.transform(),
@@ -1369,7 +1338,6 @@ where
     ) -> DamageSet<i32, Physical> {
         match self {
             CosmicWindowRenderElement::Header(elem) => elem.damage_since(scale, commit),
-            CosmicWindowRenderElement::HeaderBlur(elem) => elem.damage_since(scale, commit),
             CosmicWindowRenderElement::Shadow(elem) => elem.damage_since(scale, commit),
             CosmicWindowRenderElement::Border(elem) => elem.damage_since(scale, commit),
             CosmicWindowRenderElement::Window(elem) => elem.damage_since(scale, commit),
@@ -1379,7 +1347,6 @@ where
     fn opaque_regions(&self, scale: Scale<f64>) -> OpaqueRegions<i32, Physical> {
         match self {
             CosmicWindowRenderElement::Header(elem) => elem.opaque_regions(scale),
-            CosmicWindowRenderElement::HeaderBlur(elem) => elem.opaque_regions(scale),
             CosmicWindowRenderElement::Shadow(elem) => elem.opaque_regions(scale),
             CosmicWindowRenderElement::Border(elem) => elem.opaque_regions(scale),
             CosmicWindowRenderElement::Window(elem) => elem.opaque_regions(scale),
@@ -1389,7 +1356,6 @@ where
     fn alpha(&self) -> f32 {
         match self {
             CosmicWindowRenderElement::Header(elem) => elem.alpha(),
-            CosmicWindowRenderElement::HeaderBlur(elem) => elem.alpha(),
             CosmicWindowRenderElement::Shadow(elem) => elem.alpha(),
             CosmicWindowRenderElement::Border(elem) => elem.alpha(),
             CosmicWindowRenderElement::Window(elem) => elem.alpha(),
@@ -1399,7 +1365,6 @@ where
     fn kind(&self) -> Kind {
         match self {
             CosmicWindowRenderElement::Header(elem) => elem.kind(),
-            CosmicWindowRenderElement::HeaderBlur(elem) => elem.kind(),
             CosmicWindowRenderElement::Shadow(elem) => elem.kind(),
             CosmicWindowRenderElement::Border(elem) => elem.kind(),
             CosmicWindowRenderElement::Window(elem) => elem.kind(),
@@ -1409,7 +1374,6 @@ where
     fn is_framebuffer_effect(&self) -> bool {
         match self {
             CosmicWindowRenderElement::Header(elem) => elem.is_framebuffer_effect(),
-            CosmicWindowRenderElement::HeaderBlur(elem) => elem.is_framebuffer_effect(),
             CosmicWindowRenderElement::Shadow(elem) => elem.is_framebuffer_effect(),
             CosmicWindowRenderElement::Border(elem) => elem.is_framebuffer_effect(),
             CosmicWindowRenderElement::Window(elem) => elem.is_framebuffer_effect(),
@@ -1435,9 +1399,6 @@ where
             CosmicWindowRenderElement::Header(elem) => {
                 elem.draw(frame, src, dst, damage, opaque_regions, cache)
             }
-            CosmicWindowRenderElement::HeaderBlur(elem) => {
-                RenderElement::<R>::draw(elem, frame, src, dst, damage, opaque_regions, cache)
-            }
             CosmicWindowRenderElement::Shadow(elem) | CosmicWindowRenderElement::Border(elem) => {
                 RenderElement::<GlowRenderer>::draw(
                     elem,
@@ -1459,7 +1420,6 @@ where
     fn underlying_storage(&self, renderer: &mut R) -> Option<UnderlyingStorage<'_>> {
         match self {
             CosmicWindowRenderElement::Header(elem) => elem.underlying_storage(renderer),
-            CosmicWindowRenderElement::HeaderBlur(elem) => elem.underlying_storage(renderer),
             CosmicWindowRenderElement::Shadow(elem) | CosmicWindowRenderElement::Border(elem) => {
                 elem.underlying_storage(renderer.glow_renderer_mut())
             }
@@ -1478,9 +1438,6 @@ where
             CosmicWindowRenderElement::Header(elem) => {
                 elem.capture_framebuffer(frame, src, dst, cache)
             }
-            CosmicWindowRenderElement::HeaderBlur(elem) => {
-                RenderElement::<R>::capture_framebuffer(elem, frame, src, dst, cache)
-            }
             CosmicWindowRenderElement::Shadow(elem) | CosmicWindowRenderElement::Border(elem) => {
                 RenderElement::<GlowRenderer>::capture_framebuffer(
                     elem,