diff --git a/Cargo.toml b/Cargo.toml
index 51416ec..90f9d3b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -2,48 +2,28 @@
 name = "cosmic-time"
 version = "0.4.0"
 edition = "2021"
-description = "An animation Crate for Iced and Cosmic DE"
+description = "An animation Crate for libcosmic and Cosmic DE"
 authors = ["Brock Szuszczewicz <brock@szu.email>"]
 license = "MIT"
 repository = "https://github.com/pop-os/cosmic-time"
 documentation = "https://docs.rs/cosmic-time"
-keywords = ["gui", "animation", "interface", "widgets", "iced"]
+keywords = ["gui", "animation", "interface", "widgets", "libcosmic"]
 categories = ["gui"]
 
 [features]
-default = ["iced"]
-iced = [
-    "dep:iced",
-    "dep:iced_runtime",
-    "dep:iced_widget",
-    "dep:iced_futures",
-    "dep:iced_core",
-    "dep:iced_style",
-]
 once_cell = ["dep:once_cell"]
-wayland-libcosmic = ["libcosmic", "libcosmic/wayland"]
-winit-libcosmic = ["libcosmic", "libcosmic/winit"]
-libcosmic = ["dep:libcosmic"]
 
 [workspace]
-members = ["examples/*"]
+members = []
 
 [dependencies]
-iced = { git = "https://github.com/iced-rs/iced", rev = "5540ac0", features = [
+libcosmic = { path = "../fork/libcosmic", default-features = false, features = [
     "tokio",
-], optional = true }
-iced_runtime = { git = "https://github.com/iced-rs/iced", rev = "5540ac0", optional = true }
-iced_widget = { git = "https://github.com/iced-rs/iced", rev = "5540ac0", optional = true }
-iced_futures = { git = "https://github.com/iced-rs/iced", rev = "5540ac0", optional = true }
-iced_core = { git = "https://github.com/iced-rs/iced", rev = "5540ac0", optional = true }
-iced_style = { git = "https://github.com/iced-rs/iced", rev = "5540ac0", optional = true }
-libcosmic = { git = "https://github.com/pop-os/libcosmic/", default-features = false, features = [
-    "tokio",
-], optional = true }
+] }
 once_cell = { version = "1.18.0", optional = true }
 float-cmp = "0.9"
 
 # [patch.'https://github.com/pop-os/libcosmic']
-# libcosmic = { path = "../libcosmic" }
-# cosmic-config = { path = "../libcosmic/cosmic-config" }
-# cosmic-theme = { path = "../libcosmic/cosmic-theme" }
+# libcosmic = { path = "../fork/libcosmic" }
+# cosmic-config = { path = "../fork/libcosmic/cosmic-config" }
+# cosmic-theme = { path = "../fork/libcosmic/cosmic-theme" }
diff --git a/examples/pong/src/layer.rs b/examples/pong/src/layer.rs
index fc92b62..6aef802 100644
--- a/examples/pong/src/layer.rs
+++ b/examples/pong/src/layer.rs
@@ -143,7 +143,7 @@ where
         state: &mut Tree,
         layout: Layout<'_>,
         renderer: &Renderer,
-        operation: &mut dyn widget::Operation<Message>,
+        operation: &mut dyn widget::Operation<()>,
     ) {
         self.base
             .as_widget()
@@ -236,7 +236,7 @@ where
         &mut self,
         layout: Layout<'_>,
         renderer: &Renderer,
-        operation: &mut dyn widget::Operation<Message>,
+        operation: &mut dyn widget::Operation<()>,
     ) {
         self.content.as_widget().operate(
             self.tree,
diff --git a/src/keyframes.rs b/src/keyframes.rs
index 2dfec03..9758f4a 100644
--- a/src/keyframes.rs
+++ b/src/keyframes.rs
@@ -1,33 +1,14 @@
-mod button;
-#[cfg(feature = "libcosmic")]
 mod cards;
-mod column;
-mod container;
 mod helpers;
-mod row;
-mod space;
-mod style_button;
-mod style_container;
 mod toggler;
 
 use crate::reexports::iced_core::{widget, Length};
 
-pub use button::Button;
-#[cfg(feature = "libcosmic")]
 pub use cards::Cards;
-pub use column::Column;
-pub use container::Container;
-#[cfg(feature = "libcosmic")]
 pub use helpers::cards;
 pub use helpers::id;
 pub use helpers::lazy;
-pub use helpers::{
-    button, chain, column, container, row, space, style_button, style_container, toggler,
-};
-pub use row::Row;
-pub use space::Space;
-pub use style_button::StyleButton;
-pub use style_container::StyleContainer;
+pub use helpers::{chain, toggler};
 pub use toggler::Toggler;
 
 use crate::Timeline;
diff --git a/src/keyframes/button.rs b/src/keyframes/button.rs
deleted file mode 100644
index b2d9237..0000000
--- a/src/keyframes/button.rs
+++ /dev/null
@@ -1,212 +0,0 @@
-use self::iced_core::{widget::Id as IcedId, Element, Length, Padding, Renderer as IcedRenderer};
-use crate::reexports::{iced_core, iced_style, iced_widget};
-
-use crate::keyframes::{as_f32, get_length, Repeat};
-use crate::timeline::Frame;
-use crate::{Ease, Linear, MovementType};
-
-/// A Button's animation Id. Used for linking animation built in `update()` with widget output in `view()`
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Id(IcedId);
-
-impl Id {
-    /// Creates a custom [`Id`].
-    pub fn new(id: impl Into<std::borrow::Cow<'static, str>>) -> Self {
-        Self(IcedId::new(id))
-    }
-
-    /// Creates a unique [`Id`].
-    ///
-    /// This function produces a different [`Id`] every time it is called.
-    #[must_use]
-    pub fn unique() -> Self {
-        Self(IcedId::unique())
-    }
-
-    /// Used by [`crate::chain!`] macro
-    #[must_use]
-    pub fn into_chain(self) -> Chain {
-        Chain::new(self)
-    }
-
-    /// Used by [`crate::chain!`] macro
-    #[must_use]
-    pub fn into_chain_with_children(self, children: Vec<Button>) -> Chain {
-        Chain::with_children(self, children)
-    }
-
-    /// Used by [`crate::anim!`] macro
-    pub fn as_widget<'a, Message, Theme, Renderer>(
-        self,
-        timeline: &crate::Timeline,
-        content: impl Into<Element<'a, Message, Theme, Renderer>>,
-    ) -> iced_widget::Button<'a, Message, Theme, Renderer>
-    where
-        Renderer: IcedRenderer,
-        Theme: iced_style::button::StyleSheet,
-    {
-        Button::as_widget(self, timeline, content)
-    }
-}
-
-impl From<Id> for IcedId {
-    fn from(id: Id) -> Self {
-        id.0
-    }
-}
-
-#[derive(Debug)]
-pub struct Chain {
-    id: Id,
-    links: Vec<Button>,
-    repeat: Repeat,
-}
-
-impl Chain {
-    pub fn new(id: Id) -> Self {
-        Chain {
-            id,
-            links: Vec::new(),
-            repeat: Repeat::Never,
-        }
-    }
-
-    pub fn with_children(id: Id, children: Vec<Button>) -> Self {
-        Chain {
-            id,
-            links: children,
-            repeat: Repeat::Never,
-        }
-    }
-
-    pub fn link(mut self, button: Button) -> Self {
-        self.links.push(button);
-        self
-    }
-
-    pub fn loop_forever(mut self) -> Self {
-        self.repeat = Repeat::Forever;
-        self
-    }
-
-    pub fn loop_once(mut self) -> Self {
-        self.repeat = Repeat::Never;
-        self
-    }
-}
-
-impl From<Chain> for crate::timeline::Chain {
-    fn from(chain: Chain) -> Self {
-        crate::timeline::Chain::new(
-            chain.id.into(),
-            chain.repeat,
-            chain
-                .links
-                .into_iter()
-                .map(std::convert::Into::into)
-                .collect::<Vec<_>>(),
-        )
-    }
-}
-
-#[must_use = "Keyframes are intended to be used in an animation chain."]
-#[derive(Debug, Clone, Copy)]
-pub struct Button {
-    at: MovementType,
-    ease: Ease,
-    width: Option<Length>,
-    height: Option<Length>,
-    padding: Option<Padding>,
-    is_eager: bool,
-}
-
-impl Button {
-    pub fn new(at: impl Into<MovementType>) -> Button {
-        let at = at.into();
-        Button {
-            at,
-            ease: Linear::InOut.into(),
-            width: None,
-            height: None,
-            padding: None,
-            is_eager: true,
-        }
-    }
-
-    pub fn lazy(at: impl Into<MovementType>) -> Button {
-        let at = at.into();
-        Button {
-            at,
-            ease: Linear::InOut.into(),
-            width: None,
-            height: None,
-            padding: None,
-            is_eager: false,
-        }
-    }
-
-    pub fn as_widget<'a, Message, Theme, Renderer>(
-        id: Id,
-        timeline: &crate::Timeline,
-        content: impl Into<Element<'a, Message, Theme, Renderer>>,
-    ) -> iced_widget::Button<'a, Message, Theme, Renderer>
-    where
-        Renderer: IcedRenderer,
-        Theme: iced_style::button::StyleSheet,
-    {
-        let id: IcedId = id.into();
-
-        iced_widget::Button::new(content)
-            .width(get_length(&id, timeline, 0, Length::Shrink))
-            .height(get_length(&id, timeline, 1, Length::Shrink))
-            .padding([
-                timeline.get(&id, 2).map_or(5.0, |m| m.value),
-                timeline.get(&id, 3).map_or(5.0, |m| m.value),
-                timeline.get(&id, 4).map_or(5.0, |m| m.value),
-                timeline.get(&id, 5).map_or(5.0, |m| m.value),
-            ])
-    }
-
-    pub fn width(mut self, width: Length) -> Self {
-        self.width = Some(width);
-        self
-    }
-
-    pub fn height(mut self, height: Length) -> Self {
-        self.height = Some(height);
-        self
-    }
-
-    pub fn padding<P: Into<Padding>>(mut self, padding: P) -> Self {
-        self.padding = Some(padding.into());
-        self
-    }
-
-    pub fn ease<E: Into<Ease>>(mut self, ease: E) -> Self {
-        self.ease = ease.into();
-        self
-    }
-}
-
-#[rustfmt::skip]
-impl From<Button> for Vec<Option<Frame>> {
-    fn from(button: Button) -> Vec<Option<Frame>> {
-      if button.is_eager {
-        vec![as_f32(button.width).map(|w| Frame::eager(button.at, w, button.ease)),  // 0 = width
-             as_f32(button.height).map(|h| Frame::eager(button.at, h, button.ease)), // 1 = height
-             button.padding.map(|p| Frame::eager(button.at, p.top, button.ease)),    // 2 = padding[0] (top)
-             button.padding.map(|p| Frame::eager(button.at, p.right, button.ease)),  // 3 = padding[1] (right)
-             button.padding.map(|p| Frame::eager(button.at, p.bottom, button.ease)), // 4 = padding[2] (bottom)
-             button.padding.map(|p| Frame::eager(button.at, p.left, button.ease)),   // 5 = padding[3] (left)
-        ]
-      } else {
-        vec![Some(Frame::lazy(button.at, 0., button.ease)), // 0 = width
-             Some(Frame::lazy(button.at, 0., button.ease)), // 1 = height
-             Some(Frame::lazy(button.at, 5., button.ease)), // 2 = padding[0] (top)
-             Some(Frame::lazy(button.at, 5., button.ease)), // 3 = padding[1] (right)
-             Some(Frame::lazy(button.at, 5., button.ease)), // 4 = padding[2] (bottom)
-             Some(Frame::lazy(button.at, 5., button.ease)), // 5 = padding[3] (left)
-        ]
-      }
-    }
-}
diff --git a/src/keyframes/column.rs b/src/keyframes/column.rs
deleted file mode 100644
index 9de019e..0000000
--- a/src/keyframes/column.rs
+++ /dev/null
@@ -1,215 +0,0 @@
-use crate::reexports::iced_core::{
-    widget::Id as IcedId, Length, Padding, Pixels, Renderer as IcedRenderer,
-};
-use crate::reexports::iced_widget;
-
-use crate::keyframes::{as_f32, get_length, Repeat};
-use crate::timeline::Frame;
-use crate::{Ease, Linear, MovementType};
-
-/// A Column's animation Id. Used for linking animation built in `update()` with widget output in `view()`
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Id(IcedId);
-
-impl Id {
-    /// Creates a custom [`Id`].
-    pub fn new(id: impl Into<std::borrow::Cow<'static, str>>) -> Self {
-        Self(IcedId::new(id))
-    }
-
-    /// Creates a unique [`Id`].
-    ///
-    /// This function produces a different [`Id`] every time it is called.
-    #[must_use]
-    pub fn unique() -> Self {
-        Self(IcedId::unique())
-    }
-
-    /// Used by [`crate::chain!`] macro
-    #[must_use]
-    pub fn into_chain(self) -> Chain {
-        Chain::new(self)
-    }
-
-    /// Used by [`crate::chain!`] macro
-    #[must_use]
-    pub fn into_chain_with_children(self, children: Vec<Column>) -> Chain {
-        Chain::with_children(self, children)
-    }
-
-    /// Used by [`crate::anim!`] macro
-    #[must_use]
-    pub fn as_widget<'a, Message, Theme, Renderer>(
-        self,
-        timeline: &crate::Timeline,
-    ) -> iced_widget::Column<'a, Message, Theme, Renderer>
-    where
-        Renderer: IcedRenderer,
-    {
-        Column::as_widget(self, timeline)
-    }
-}
-
-impl From<Id> for IcedId {
-    fn from(id: Id) -> Self {
-        id.0
-    }
-}
-
-#[derive(Debug)]
-pub struct Chain {
-    id: Id,
-    links: Vec<Column>,
-    repeat: Repeat,
-}
-
-impl Chain {
-    pub fn new(id: Id) -> Self {
-        Chain {
-            id,
-            links: Vec::new(),
-            repeat: Repeat::Never,
-        }
-    }
-
-    pub fn with_children(id: Id, children: Vec<Column>) -> Self {
-        Chain {
-            id,
-            links: children,
-            repeat: Repeat::Never,
-        }
-    }
-
-    pub fn link(mut self, container: Column) -> Self {
-        self.links.push(container);
-        self
-    }
-
-    pub fn loop_forever(mut self) -> Self {
-        self.repeat = Repeat::Forever;
-        self
-    }
-
-    pub fn loop_once(mut self) -> Self {
-        self.repeat = Repeat::Never;
-        self
-    }
-}
-
-impl From<Chain> for crate::timeline::Chain {
-    fn from(chain: Chain) -> Self {
-        crate::timeline::Chain::new(
-            chain.id.into(),
-            chain.repeat,
-            chain
-                .links
-                .into_iter()
-                .map(std::convert::Into::into)
-                .collect::<Vec<_>>(),
-        )
-    }
-}
-
-#[must_use = "Keyframes are intended to be used in an animation chain."]
-#[derive(Debug, Clone, Copy)]
-pub struct Column {
-    at: MovementType,
-    ease: Ease,
-    spacing: Option<f32>,
-    padding: Option<Padding>,
-    width: Option<Length>,
-    height: Option<Length>,
-    is_eager: bool,
-}
-
-impl Column {
-    pub fn new(at: impl Into<MovementType>) -> Column {
-        let at = at.into();
-        Column {
-            at,
-            ease: Linear::InOut.into(),
-            spacing: None,
-            width: None,
-            height: None,
-            padding: None,
-            is_eager: true,
-        }
-    }
-
-    pub fn lazy(at: impl Into<MovementType>) -> Column {
-        let at = at.into();
-        Column {
-            at,
-            ease: Linear::InOut.into(),
-            spacing: None,
-            width: None,
-            height: None,
-            padding: None,
-            is_eager: false,
-        }
-    }
-
-    pub fn as_widget<'a, Message, Theme, Renderer>(
-        id: Id,
-        timeline: &crate::Timeline,
-    ) -> iced_widget::Column<'a, Message, Theme, Renderer>
-    where
-        Renderer: IcedRenderer,
-    {
-        let id: IcedId = id.into();
-
-        iced_widget::Column::new()
-            .spacing(timeline.get(&id, 0).map_or(0., |m| m.value))
-            .padding([
-                timeline.get(&id, 1).map_or(0., |m| m.value),
-                timeline.get(&id, 2).map_or(0., |m| m.value),
-                timeline.get(&id, 3).map_or(0., |m| m.value),
-                timeline.get(&id, 4).map_or(0., |m| m.value),
-            ])
-            .width(get_length(&id, timeline, 5, Length::Shrink))
-            .height(get_length(&id, timeline, 6, Length::Shrink))
-    }
-
-    pub fn spacing(mut self, spacing: impl Into<Pixels>) -> Self {
-        self.spacing = Some(spacing.into().0);
-        self
-    }
-
-    pub fn width(mut self, width: impl Into<Length>) -> Self {
-        self.width = Some(width.into());
-        self
-    }
-
-    pub fn height(mut self, height: impl Into<Length>) -> Self {
-        self.height = Some(height.into());
-        self
-    }
-
-    pub fn padding<P: Into<Padding>>(mut self, padding: P) -> Self {
-        self.padding = Some(padding.into());
-        self
-    }
-
-    pub fn ease<E: Into<Ease>>(mut self, ease: E) -> Self {
-        self.ease = ease.into();
-        self
-    }
-}
-
-#[rustfmt::skip]
-impl From<Column> for Vec<Option<Frame>> {
-    fn from(column: Column) -> Vec<Option<Frame>> {
-      if column.is_eager {
-        vec![column.spacing.map(|s| Frame::eager(column.at, s, column.ease)),        // 0 = spacing
-             column.padding.map(|p| Frame::eager(column.at, p.top, column.ease)),    // 1 = padding[0] (top)
-             column.padding.map(|p| Frame::eager(column.at, p.right, column.ease)),  // 2 = padding[1] (right)
-             column.padding.map(|p| Frame::eager(column.at, p.bottom, column.ease)), // 3 = padding[2] (bottom)
-             column.padding.map(|p| Frame::eager(column.at, p.left, column.ease)),   // 4 = padding[3] (left)
-             as_f32(column.width).map(|w| Frame::eager(column.at, w, column.ease)),  // 5 = width
-             as_f32(column.height).map(|h| Frame::eager(column.at, h, column.ease)), // 6 = height
-        ]
-      } else {
-        vec![Some(Frame::lazy(column.at, 0., column.ease)); 7] // lazy evaluates for all values
-      }
-    }
-}
diff --git a/src/keyframes/container.rs b/src/keyframes/container.rs
deleted file mode 100644
index 270be0b..0000000
--- a/src/keyframes/container.rs
+++ /dev/null
@@ -1,224 +0,0 @@
-use crate::reexports::iced_core::{
-    widget::Id as IcedId, Element, Length, Padding, Pixels, Renderer as IcedRenderer,
-};
-use crate::reexports::{iced_style, iced_widget};
-
-use crate::keyframes::{as_f32, get_length, Repeat};
-use crate::timeline::Frame;
-use crate::{Ease, Linear, MovementType};
-
-/// A Container's animation Id. Used for linking animation built in `update()` with widget output in `view()`
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Id(IcedId);
-
-impl Id {
-    /// Creates a custom [`Id`].
-    pub fn new(id: impl Into<std::borrow::Cow<'static, str>>) -> Self {
-        Self(IcedId::new(id))
-    }
-
-    /// Creates a unique [`Id`].
-    ///
-    /// This function produces a different [`Id`] every time it is called.
-    #[must_use]
-    pub fn unique() -> Self {
-        Self(IcedId::unique())
-    }
-
-    /// Used by [`crate::chain!`] macro
-    #[must_use]
-    pub fn into_chain(self) -> Chain {
-        Chain::new(self)
-    }
-
-    /// Used by [`crate::chain!`] macro
-    #[must_use]
-    pub fn into_chain_with_children(self, children: Vec<Container>) -> Chain {
-        Chain::with_children(self, children)
-    }
-
-    /// Used by [`crate::anim!`] macro
-    pub fn as_widget<'a, Message, Theme, Renderer>(
-        self,
-        timeline: &crate::Timeline,
-        content: impl Into<Element<'a, Message, Theme, Renderer>>,
-    ) -> iced_widget::Container<'a, Message, Theme, Renderer>
-    where
-        Renderer: IcedRenderer,
-        Theme: iced_style::container::StyleSheet,
-    {
-        Container::as_widget(self, timeline, content)
-    }
-}
-
-impl From<Id> for IcedId {
-    fn from(id: Id) -> Self {
-        id.0
-    }
-}
-
-#[derive(Debug)]
-pub struct Chain {
-    id: Id,
-    links: Vec<Container>,
-    repeat: Repeat,
-}
-
-impl Chain {
-    pub fn new(id: Id) -> Self {
-        Chain {
-            id,
-            links: Vec::new(),
-            repeat: Repeat::Never,
-        }
-    }
-
-    pub fn with_children(id: Id, children: Vec<Container>) -> Self {
-        Chain {
-            id,
-            links: children,
-            repeat: Repeat::Never,
-        }
-    }
-
-    pub fn link(mut self, container: Container) -> Self {
-        self.links.push(container);
-        self
-    }
-
-    pub fn loop_forever(mut self) -> Self {
-        self.repeat = Repeat::Forever;
-        self
-    }
-
-    pub fn loop_once(mut self) -> Self {
-        self.repeat = Repeat::Never;
-        self
-    }
-}
-
-impl From<Chain> for crate::timeline::Chain {
-    fn from(chain: Chain) -> Self {
-        crate::timeline::Chain::new(
-            chain.id.into(),
-            chain.repeat,
-            chain.links.into_iter().map(Into::into).collect::<Vec<_>>(),
-        )
-    }
-}
-
-#[must_use = "Keyframes are intended to be used in an animation chain."]
-#[derive(Debug, Clone, Copy)]
-pub struct Container {
-    at: MovementType,
-    ease: Ease,
-    width: Option<Length>,
-    height: Option<Length>,
-    padding: Option<Padding>,
-    max_width: Option<f32>,
-    max_height: Option<f32>,
-    is_eager: bool,
-}
-
-impl Container {
-    pub fn new(at: impl Into<MovementType>) -> Container {
-        let at = at.into();
-        Container {
-            at,
-            ease: Linear::InOut.into(),
-            width: None,
-            height: None,
-            padding: None,
-            max_width: None,
-            max_height: None,
-            is_eager: true,
-        }
-    }
-
-    pub fn lazy(at: impl Into<MovementType>) -> Container {
-        let at = at.into();
-        Container {
-            at,
-            ease: Linear::InOut.into(),
-            width: None,
-            height: None,
-            padding: None,
-            max_width: None,
-            max_height: None,
-            is_eager: false,
-        }
-    }
-
-    pub fn as_widget<'a, Message, Theme, Renderer>(
-        id: Id,
-        timeline: &crate::Timeline,
-        content: impl Into<Element<'a, Message, Theme, Renderer>>,
-    ) -> iced_widget::Container<'a, Message, Theme, Renderer>
-    where
-        Renderer: IcedRenderer,
-        Theme: iced_style::container::StyleSheet,
-    {
-        let id: IcedId = id.into();
-
-        iced_widget::Container::new(content)
-            .width(get_length(&id, timeline, 0, Length::Shrink))
-            .height(get_length(&id, timeline, 1, Length::Shrink))
-            .padding([
-                timeline.get(&id, 2).map_or(0., |m| m.value),
-                timeline.get(&id, 3).map_or(0., |m| m.value),
-                timeline.get(&id, 4).map_or(0., |m| m.value),
-                timeline.get(&id, 5).map_or(0., |m| m.value),
-            ])
-            .max_width(timeline.get(&id, 6).map_or(f32::INFINITY, |m| m.value))
-            .max_height(timeline.get(&id, 7).map_or(f32::INFINITY, |m| m.value))
-    }
-
-    pub fn width(mut self, width: impl Into<Length>) -> Self {
-        self.width = Some(width.into());
-        self
-    }
-
-    pub fn max_width(mut self, max_width: impl Into<Pixels>) -> Self {
-        self.max_width = Some(max_width.into().0);
-        self
-    }
-
-    pub fn height(mut self, height: impl Into<Length>) -> Self {
-        self.height = Some(height.into());
-        self
-    }
-
-    pub fn max_height(mut self, max_height: impl Into<Pixels>) -> Self {
-        self.max_height = Some(max_height.into().0);
-        self
-    }
-
-    pub fn padding<P: Into<Padding>>(mut self, padding: P) -> Self {
-        self.padding = Some(padding.into());
-        self
-    }
-
-    pub fn ease<E: Into<Ease>>(mut self, ease: E) -> Self {
-        self.ease = ease.into();
-        self
-    }
-}
-
-#[rustfmt::skip]
-impl From<Container> for Vec<Option<Frame>> {
-    fn from(container: Container) -> Vec<Option<Frame>> {
-      if container.is_eager {
-        vec![as_f32(container.width).map(|w| Frame::eager(container.at, w, container.ease)),  // 0 = width
-             as_f32(container.height).map(|h| Frame::eager(container.at, h, container.ease)), // 1 = height
-             container.padding.map(|p| Frame::eager(container.at, p.top, container.ease)),    // 2 = padding[0] (top)
-             container.padding.map(|p| Frame::eager(container.at, p.right, container.ease)),  // 3 = padding[1] (right)
-             container.padding.map(|p| Frame::eager(container.at, p.bottom, container.ease)), // 4 = padding[2] (bottom)
-             container.padding.map(|p| Frame::eager(container.at, p.left, container.ease)),   // 5 = padding[3] (left)
-             container.max_width.map(|w| Frame::eager(container.at, w, container.ease)),      // 6 = max_width
-             container.max_height.map(|h| Frame::eager(container.at, h, container.ease)),     // 7 = max_height
-        ]
-      } else {
-        vec![Some(Frame::lazy(container.at, 0., container.ease)); 8] // lazy evaluates for all values
-      }
-    }
-}
diff --git a/src/keyframes/helpers.rs b/src/keyframes/helpers.rs
index 1aa0f9e..57bbff8 100644
--- a/src/keyframes/helpers.rs
+++ b/src/keyframes/helpers.rs
@@ -1,146 +1,48 @@
-#[cfg(feature = "libcosmic")]
 use crate::keyframes::Cards;
-use crate::keyframes::{
-    Button, Column, Container, Row, Space, StyleButton, StyleContainer, Toggler,
-};
+use crate::keyframes::Toggler;
 
 use crate::MovementType;
 
-/// Create a button keyframe.
-/// Needs to be added into a chain. See [`crate::chain!`] macro.
-pub fn button(at: impl Into<MovementType>) -> Button {
-    Button::new(at)
-}
-
-/// Create a column keyframe.
-/// Needs to be added into a chain. See [`crate::chain!`] macro.
-pub fn column(at: impl Into<MovementType>) -> Column {
-    Column::new(at)
-}
-
-/// Create a container keyframe.
-/// Needs to be added into a chain. See [`crate::chain!`] macro.
-pub fn container(at: impl Into<MovementType>) -> Container {
-    Container::new(at)
-}
-
-/// Create a row keyframe.
-/// Needs to be added into a chain. See [`crate::chain!`] macro.
-pub fn row(at: impl Into<MovementType>) -> Row {
-    Row::new(at)
-}
-
-/// Create a space keyframe.
-/// Needs to be added into a chain. See [`crate::chain!`] macro.
-pub fn space(at: impl Into<MovementType>) -> Space {
-    Space::new(at)
-}
-
 /// Create a toggler keyframe.
 /// Needs to be added into a chain. See [`crate::chain!`] macro.
 pub fn toggler(at: impl Into<MovementType>) -> Toggler {
     Toggler::new(at)
 }
 
-#[cfg(feature = "libcosmic")]
 /// Create a cards keyframe.
 /// Needs to be added into a chain. See [`crate::chain!`] macro.
 pub fn cards(at: impl Into<MovementType>) -> Cards {
     Cards::new(at)
 }
 
-/// Create a `style_button` keyframe.
-/// Needs to be added into a chain. See [`crate::chain!`] macro.
-pub fn style_button(at: impl Into<MovementType>) -> StyleButton {
-    StyleButton::new(at)
-}
-
-/// Create a `style_container` keyframe.
-/// Needs to be added into a chain. See [`crate::chain!`] macro.
-pub fn style_container(at: impl Into<MovementType>) -> StyleContainer {
-    StyleContainer::new(at)
-}
-
 /// A slightly different import to clean up makeing lazy keyframes.
 pub mod lazy {
-    #[cfg(feature = "libcosmic")]
     use crate::keyframes::Cards;
-    use crate::keyframes::{
-        Button, Column, Container, Row, Space, StyleButton, StyleContainer, Toggler,
-    };
+    use crate::keyframes::Toggler;
     use crate::MovementType;
 
-    /// Create a lazy button keyframe.
-    /// Needs to be added into a chain. See [`crate::chain!`] macro.
-    pub fn button(at: impl Into<MovementType>) -> Button {
-        Button::lazy(at)
-    }
-
-    /// Create a lazy column keyframe.
-    /// Needs to be added into a chain. See [`crate::chain!`] macro.
-    pub fn column(at: impl Into<MovementType>) -> Column {
-        Column::lazy(at)
-    }
-
-    /// Create a lazy container keyframe.
-    /// Needs to be added into a chain. See [`crate::chain!`] macro.
-    pub fn container(at: impl Into<MovementType>) -> Container {
-        Container::lazy(at)
-    }
-
-    /// Create a lazy row keyframe.
-    /// Needs to be added into a chain. See [`crate::chain!`] macro.
-    pub fn row(at: impl Into<MovementType>) -> Row {
-        Row::lazy(at)
-    }
-
-    /// Create a lazy space keyframe.
-    /// Needs to be added into a chain. See [`crate::chain!`] macro.
-    pub fn space(at: impl Into<MovementType>) -> Space {
-        Space::lazy(at)
-    }
-
     /// Create a lazy toggler keyframe.
     /// Needs to be added into a chain. See [`crate::chain!`] macro.
     pub fn toggler(at: impl Into<MovementType>) -> Toggler {
         Toggler::lazy(at)
     }
 
-    #[cfg(feature = "libcosmic")]
     /// Create a lazy toggler keyframe.
     /// Needs to be added into a chain. See [`crate::chain!`] macro.
     pub fn cards(at: impl Into<MovementType>) -> Cards {
         Cards::lazy(at)
     }
-
-    /// Create a lazy `style_button` keyframe.
-    /// Needs to be added into a chain. See [`crate::chain!`] macro.
-    pub fn style_button(at: impl Into<MovementType>) -> StyleButton {
-        StyleButton::lazy(at)
-    }
-
-    /// Create a lazy `style_container` keyframe.
-    /// Needs to be added into a chain. See [`crate::chain!`] macro.
-    pub fn style_container(at: impl Into<MovementType>) -> StyleContainer {
-        StyleContainer::lazy(at)
-    }
 }
 
 /// A slightly different import to clean up makeing animation Ids.
 pub mod id {
-    #[cfg(feature = "libcosmic")]
     pub use crate::keyframes::cards::Id as Cards;
-    pub use crate::keyframes::{
-        button::Id as Button, column::Id as Column, container::Id as Container, row::Id as Row,
-        space::Id as Space, style_button::Id as StyleButton, style_container::Id as StyleContainer,
-        toggler::Id as Toggler,
-    };
+    pub use crate::keyframes::toggler::Id as Toggler;
 }
 
 /// Direct access to `Chain`s for widget that may return an animation
 /// in a message.
 pub mod chain {
-    #[cfg(feature = "libcosmic")]
     pub use crate::keyframes::cards::Chain as Cards;
     pub use crate::keyframes::toggler::Chain as Toggler;
 }
diff --git a/src/keyframes/row.rs b/src/keyframes/row.rs
deleted file mode 100644
index 3fa9afd..0000000
--- a/src/keyframes/row.rs
+++ /dev/null
@@ -1,215 +0,0 @@
-use crate::reexports::iced_core::{
-    widget::Id as IcedId, Length, Padding, Pixels, Renderer as IcedRenderer,
-};
-use crate::reexports::iced_widget;
-
-use crate::keyframes::{as_f32, get_length, Repeat};
-use crate::timeline::Frame;
-use crate::{Ease, Linear, MovementType};
-
-/// A Row's animation Id. Used for linking animation built in `update()` with widget output in `view()`
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Id(IcedId);
-
-impl Id {
-    /// Creates a custom [`Id`].
-    pub fn new(id: impl Into<std::borrow::Cow<'static, str>>) -> Self {
-        Self(IcedId::new(id))
-    }
-
-    /// Creates a unique [`Id`].
-    ///
-    /// This function produces a different [`Id`] every time it is called.
-    #[must_use]
-    pub fn unique() -> Self {
-        Self(IcedId::unique())
-    }
-
-    /// Used by [`crate::chain!`] macro
-    #[must_use]
-    pub fn into_chain(self) -> Chain {
-        Chain::new(self)
-    }
-
-    /// Used by [`crate::chain!`] macro
-    #[must_use]
-    pub fn into_chain_with_children(self, children: Vec<Row>) -> Chain {
-        Chain::with_children(self, children)
-    }
-
-    /// Used by [`crate::anim!`] macro
-    #[must_use]
-    pub fn as_iced_widget<'a, Message, Theme, Renderer>(
-        self,
-        timeline: &crate::Timeline,
-    ) -> iced_widget::Row<'a, Message, Theme, Renderer>
-    where
-        Renderer: IcedRenderer,
-    {
-        Row::as_iced_widget(self, timeline)
-    }
-}
-
-impl From<Id> for IcedId {
-    fn from(id: Id) -> Self {
-        id.0
-    }
-}
-
-#[derive(Debug)]
-pub struct Chain {
-    id: Id,
-    links: Vec<Row>,
-    repeat: Repeat,
-}
-
-impl Chain {
-    pub fn new(id: Id) -> Self {
-        Chain {
-            id,
-            links: Vec::new(),
-            repeat: Repeat::Never,
-        }
-    }
-
-    pub fn with_children(id: Id, children: Vec<Row>) -> Self {
-        Chain {
-            id,
-            links: children,
-            repeat: Repeat::Never,
-        }
-    }
-
-    pub fn link(mut self, container: Row) -> Self {
-        self.links.push(container);
-        self
-    }
-
-    pub fn loop_forever(mut self) -> Self {
-        self.repeat = Repeat::Forever;
-        self
-    }
-
-    pub fn loop_once(mut self) -> Self {
-        self.repeat = Repeat::Never;
-        self
-    }
-}
-
-impl From<Chain> for crate::timeline::Chain {
-    fn from(chain: Chain) -> Self {
-        crate::timeline::Chain::new(
-            chain.id.into(),
-            chain.repeat,
-            chain
-                .links
-                .into_iter()
-                .map(std::convert::Into::into)
-                .collect::<Vec<_>>(),
-        )
-    }
-}
-
-#[must_use = "Keyframes are intended to be used in an animation chain."]
-#[derive(Debug, Clone, Copy)]
-pub struct Row {
-    at: MovementType,
-    ease: Ease,
-    spacing: Option<f32>,
-    padding: Option<Padding>,
-    width: Option<Length>,
-    height: Option<Length>,
-    is_eager: bool,
-}
-
-impl Row {
-    pub fn new(at: impl Into<MovementType>) -> Row {
-        let at = at.into();
-        Row {
-            at,
-            ease: Linear::InOut.into(),
-            spacing: None,
-            width: None,
-            height: None,
-            padding: None,
-            is_eager: true,
-        }
-    }
-
-    pub fn lazy(at: impl Into<MovementType>) -> Row {
-        let at = at.into();
-        Row {
-            at,
-            ease: Linear::InOut.into(),
-            spacing: None,
-            width: None,
-            height: None,
-            padding: None,
-            is_eager: false,
-        }
-    }
-
-    pub fn as_iced_widget<'a, Message, Theme, Renderer>(
-        id: Id,
-        timeline: &crate::Timeline,
-    ) -> iced_widget::Row<'a, Message, Theme, Renderer>
-    where
-        Renderer: IcedRenderer,
-    {
-        let id: IcedId = id.into();
-
-        iced_widget::Row::new()
-            .spacing(timeline.get(&id, 0).map_or(0., |m| m.value))
-            .padding([
-                timeline.get(&id, 1).map_or(0., |m| m.value),
-                timeline.get(&id, 2).map_or(0., |m| m.value),
-                timeline.get(&id, 3).map_or(0., |m| m.value),
-                timeline.get(&id, 4).map_or(0., |m| m.value),
-            ])
-            .width(get_length(&id, timeline, 5, Length::Shrink))
-            .height(get_length(&id, timeline, 6, Length::Shrink))
-    }
-
-    pub fn spacing(mut self, spacing: impl Into<Pixels>) -> Self {
-        self.spacing = Some(spacing.into().0);
-        self
-    }
-
-    pub fn width(mut self, width: impl Into<Length>) -> Self {
-        self.width = Some(width.into());
-        self
-    }
-
-    pub fn height(mut self, height: impl Into<Length>) -> Self {
-        self.height = Some(height.into());
-        self
-    }
-
-    pub fn padding<P: Into<Padding>>(mut self, padding: P) -> Self {
-        self.padding = Some(padding.into());
-        self
-    }
-
-    pub fn ease<E: Into<Ease>>(mut self, ease: E) -> Self {
-        self.ease = ease.into();
-        self
-    }
-}
-
-#[rustfmt::skip]
-impl From<Row> for Vec<Option<Frame>> {
-    fn from(row: Row) -> Vec<Option<Frame>> {
-      if row.is_eager {
-        vec![row.spacing.map(|s| Frame::eager(row.at, s, row.ease)),        // 0 = spacing
-             row.padding.map(|p| Frame::eager(row.at, p.top, row.ease)),    // 1 = padding[0] (top)
-             row.padding.map(|p| Frame::eager(row.at, p.right, row.ease)),  // 2 = padding[1] (right)
-             row.padding.map(|p| Frame::eager(row.at, p.bottom, row.ease)), // 3 = padding[2] (bottom)
-             row.padding.map(|p| Frame::eager(row.at, p.left, row.ease)),  // 4 = padding[3] (left)
-             as_f32(row.width).map(|w| Frame::eager(row.at, w, row.ease)),  // 5 = width
-             as_f32(row.height).map(|h| Frame::eager(row.at, h, row.ease)), // 6 = height
-        ]
-      } else {
-        vec![Some(Frame::lazy(row.at, 0., row.ease)); 7] // lazy evaluates for all values
-      }
-    }
-}
diff --git a/src/keyframes/space.rs b/src/keyframes/space.rs
deleted file mode 100644
index de26541..0000000
--- a/src/keyframes/space.rs
+++ /dev/null
@@ -1,176 +0,0 @@
-use crate::reexports::iced_core::{widget::Id as IcedId, Length};
-use crate::reexports::iced_widget;
-
-use crate::keyframes::{as_f32, get_length, Repeat};
-use crate::timeline::Frame;
-use crate::{Ease, Linear, MovementType};
-
-/// A Space's animation Id. Used for linking animation built in `update()` with widget output in `view()`
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Id(IcedId);
-
-impl Id {
-    /// Creates a custom [`Id`].
-    pub fn new(id: impl Into<std::borrow::Cow<'static, str>>) -> Self {
-        Self(IcedId::new(id))
-    }
-
-    /// Creates a unique [`Id`].
-    ///
-    /// This function produces a different [`Id`] every time it is called.
-    #[must_use]
-    pub fn unique() -> Self {
-        Self(IcedId::unique())
-    }
-
-    /// Used by [`crate::chain!`] macro
-    #[must_use]
-    pub fn into_chain(self) -> Chain {
-        Chain::new(self)
-    }
-
-    /// Used by [`crate::chain!`] macro
-    #[must_use]
-    pub fn into_chain_with_children(self, children: Vec<Space>) -> Chain {
-        Chain::with_children(self, children)
-    }
-
-    /// Used by [`crate::anim!`] macro
-    #[must_use]
-    pub fn as_widget(self, timeline: &crate::Timeline) -> iced_widget::Space {
-        Space::as_widget(self, timeline)
-    }
-}
-
-impl From<Id> for IcedId {
-    fn from(id: Id) -> Self {
-        id.0
-    }
-}
-
-#[derive(Debug)]
-pub struct Chain {
-    id: Id,
-    links: Vec<Space>,
-    repeat: Repeat,
-}
-
-impl Chain {
-    pub fn new(id: Id) -> Self {
-        Chain {
-            id,
-            links: Vec::new(),
-            repeat: Repeat::Never,
-        }
-    }
-
-    pub fn with_children(id: Id, children: Vec<Space>) -> Self {
-        Chain {
-            id,
-            links: children,
-            repeat: Repeat::Never,
-        }
-    }
-
-    pub fn link(mut self, space: Space) -> Self {
-        self.links.push(space);
-        self
-    }
-
-    pub fn loop_forever(mut self) -> Self {
-        self.repeat = Repeat::Forever;
-        self
-    }
-
-    pub fn loop_once(mut self) -> Self {
-        self.repeat = Repeat::Never;
-        self
-    }
-}
-
-impl From<Chain> for crate::timeline::Chain {
-    fn from(chain: Chain) -> Self {
-        crate::timeline::Chain::new(
-            chain.id.into(),
-            chain.repeat,
-            chain
-                .links
-                .into_iter()
-                .map(std::convert::Into::into)
-                .collect::<Vec<_>>(),
-        )
-    }
-}
-
-#[must_use = "Keyframes are intended to be used in an animation chain."]
-#[derive(Debug, Clone, Copy)]
-pub struct Space {
-    at: MovementType,
-    ease: Ease,
-    width: Option<Length>,
-    height: Option<Length>,
-    is_eager: bool,
-}
-
-impl Space {
-    pub fn new(at: impl Into<MovementType>) -> Self {
-        let at = at.into();
-        Space {
-            at,
-            ease: Linear::InOut.into(),
-            width: None,
-            height: None,
-            is_eager: true,
-        }
-    }
-
-    pub fn lazy(at: impl Into<MovementType>) -> Self {
-        let at = at.into();
-        Space {
-            at,
-            ease: Linear::InOut.into(),
-            width: None,
-            height: None,
-            is_eager: false,
-        }
-    }
-
-    pub fn as_widget(id: Id, timeline: &crate::Timeline) -> iced_widget::Space {
-        let id: IcedId = id.into();
-
-        iced_widget::Space::new(
-            get_length(&id, timeline, 0, Length::Shrink),
-            get_length(&id, timeline, 1, Length::Shrink),
-        )
-    }
-
-    // does nothing if lazy
-    pub fn width(mut self, width: impl Into<Length>) -> Self {
-        self.width = Some(width.into());
-        self
-    }
-
-    // does nothing if lazy
-    pub fn height(mut self, height: impl Into<Length>) -> Self {
-        self.height = Some(height.into());
-        self
-    }
-
-    pub fn ease<E: Into<Ease>>(mut self, ease: E) -> Self {
-        self.ease = ease.into();
-        self
-    }
-}
-
-#[rustfmt::skip]
-impl From<Space> for Vec<Option<Frame>> {
-    fn from(space: Space) -> Vec<Option<Frame>> {
-      if space.is_eager {
-        vec![as_f32(space.width).map(|w| Frame::eager(space.at, w, space.ease)), // 0 = width
-          as_f32(space.height).map(|h| Frame::eager(space.at, h, space.ease)) // 1 = height
-        ]
-      } else {
-        vec![Some(Frame::lazy(space.at, 0., space.ease)); 2] // lazy calculates for both width & height
-      }
-    }
-}
diff --git a/src/keyframes/style_button.rs b/src/keyframes/style_button.rs
deleted file mode 100644
index 079723a..0000000
--- a/src/keyframes/style_button.rs
+++ /dev/null
@@ -1,238 +0,0 @@
-use crate::keyframes::{as_f32, get_length, Repeat};
-use crate::reexports::iced_core::{widget, Element, Length, Padding, Renderer as IcedRenderer};
-use crate::reexports::ButtonStyleSheet;
-use crate::timeline::{Frame, Interped};
-use crate::{Ease, Linear, MovementType};
-
-/// A Button's animation Id. Used for linking animation built in `update()` with widget output in `view()`
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Id(widget::Id);
-
-impl Id {
-    /// Creates a custom [`Id`].
-    pub fn new(id: impl Into<std::borrow::Cow<'static, str>>) -> Self {
-        Self(widget::Id::new(id))
-    }
-
-    /// Creates a unique [`Id`].
-    ///
-    /// This function produces a different [`Id`] every time it is called.
-    #[must_use]
-    pub fn unique() -> Self {
-        Self(widget::Id::unique())
-    }
-
-    /// Used by [`crate::chain!`] macro
-    #[must_use]
-    pub fn into_chain(self) -> Chain {
-        Chain::new(self)
-    }
-
-    /// Used by [`crate::chain!`] macro
-    #[must_use]
-    pub fn into_chain_with_children(self, children: Vec<StyleButton>) -> Chain {
-        Chain::with_children(self, children)
-    }
-
-    /// Used by [`crate::anim!`] macro
-    pub fn as_widget<'a, Message, Theme, Renderer>(
-        self,
-        style: fn(u8) -> <Theme as ButtonStyleSheet>::Style,
-        timeline: &crate::Timeline,
-        content: impl Into<Element<'a, Message, Theme, Renderer>>,
-    ) -> crate::widget::Button<'a, Message, Theme, Renderer>
-    where
-        Renderer: IcedRenderer,
-        Theme: ButtonStyleSheet,
-    {
-        StyleButton::as_widget(self, style, timeline, content)
-    }
-}
-
-impl From<Id> for widget::Id {
-    fn from(id: Id) -> Self {
-        id.0
-    }
-}
-
-#[derive(Debug)]
-pub struct Chain {
-    id: Id,
-    links: Vec<StyleButton>,
-    repeat: Repeat,
-}
-
-impl Chain {
-    pub fn new(id: Id) -> Self {
-        Chain {
-            id,
-            links: Vec::new(),
-            repeat: Repeat::Never,
-        }
-    }
-
-    pub fn with_children(id: Id, children: Vec<StyleButton>) -> Self {
-        Chain {
-            id,
-            links: children,
-            repeat: Repeat::Never,
-        }
-    }
-
-    pub fn link(mut self, button: StyleButton) -> Self {
-        self.links.push(button);
-        self
-    }
-
-    pub fn loop_forever(mut self) -> Self {
-        self.repeat = Repeat::Forever;
-        self
-    }
-
-    pub fn loop_once(mut self) -> Self {
-        self.repeat = Repeat::Never;
-        self
-    }
-}
-
-impl From<Chain> for crate::timeline::Chain {
-    fn from(chain: Chain) -> Self {
-        crate::timeline::Chain::new(
-            chain.id.into(),
-            chain.repeat,
-            chain
-                .links
-                .into_iter()
-                .map(std::convert::Into::into)
-                .collect::<Vec<_>>(),
-        )
-    }
-}
-
-#[must_use = "Keyframes are intended to be used in an animation chain."]
-#[derive(Debug, Clone, Copy)]
-pub struct StyleButton {
-    at: MovementType,
-    ease: Ease,
-    width: Option<Length>,
-    height: Option<Length>,
-    padding: Option<Padding>,
-    style: Option<u8>,
-    is_eager: bool,
-}
-
-impl StyleButton {
-    pub fn new(at: impl Into<MovementType>) -> StyleButton {
-        let at = at.into();
-        StyleButton {
-            at,
-            ease: Linear::InOut.into(),
-            width: None,
-            height: None,
-            padding: None,
-            style: None,
-            is_eager: true,
-        }
-    }
-
-    pub fn lazy(at: impl Into<MovementType>) -> StyleButton {
-        let at = at.into();
-        StyleButton {
-            at,
-            ease: Linear::InOut.into(),
-            width: None,
-            height: None,
-            padding: None,
-            style: None,
-            is_eager: false,
-        }
-    }
-
-    // Returns a cosmic-time button, not a default iced button. The difference shouldn't
-    // matter to the end user. Though it is an implementation detail.
-    pub fn as_widget<'a, Message, Theme, Renderer>(
-        id: Id,
-        style: fn(u8) -> <Theme as ButtonStyleSheet>::Style,
-        timeline: &crate::Timeline,
-        content: impl Into<Element<'a, Message, Theme, Renderer>>,
-    ) -> crate::widget::Button<'a, Message, Theme, Renderer>
-    where
-        Renderer: IcedRenderer,
-        Theme: ButtonStyleSheet,
-    {
-        let id: widget::Id = id.into();
-
-        let button = crate::widget::Button::new(content)
-            .width(get_length(&id, timeline, 0, Length::Shrink))
-            .height(get_length(&id, timeline, 1, Length::Shrink))
-            .padding([
-                timeline.get(&id, 2).map_or(5.0, |m| m.value),
-                timeline.get(&id, 3).map_or(5.0, |m| m.value),
-                timeline.get(&id, 4).map_or(5.0, |m| m.value),
-                timeline.get(&id, 5).map_or(5.0, |m| m.value),
-            ]);
-
-        if let Some(Interped {
-            previous,
-            next,
-            percent,
-            ..
-        }) = timeline.get(&id, 6)
-        {
-            button.blend_style(style(previous as u8), style(next as u8), percent)
-        } else {
-            button
-        }
-    }
-
-    pub fn width(mut self, width: Length) -> Self {
-        self.width = Some(width);
-        self
-    }
-
-    pub fn height(mut self, height: Length) -> Self {
-        self.height = Some(height);
-        self
-    }
-
-    pub fn padding<P: Into<Padding>>(mut self, padding: P) -> Self {
-        self.padding = Some(padding.into());
-        self
-    }
-
-    pub fn ease<E: Into<Ease>>(mut self, ease: E) -> Self {
-        self.ease = ease.into();
-        self
-    }
-
-    pub fn style(mut self, style: impl Into<u8>) -> Self {
-        let style = style.into();
-        self.style = Some(style);
-        self
-    }
-}
-
-#[rustfmt::skip]
-impl From<StyleButton> for Vec<Option<Frame>> {
-    fn from(button: StyleButton) -> Vec<Option<Frame>> {
-      if button.is_eager {
-        vec![as_f32(button.width).map(|w| Frame::eager(button.at, w, button.ease)),  // 0 = width
-             as_f32(button.height).map(|h| Frame::eager(button.at, h, button.ease)), // 1 = height
-             button.padding.map(|p| Frame::eager(button.at, p.top, button.ease)),    // 2 = padding[0] (top)
-             button.padding.map(|p| Frame::eager(button.at, p.right, button.ease)),  // 3 = padding[1] (right)
-             button.padding.map(|p| Frame::eager(button.at, p.bottom, button.ease)), // 4 = padding[2] (bottom)
-             button.padding.map(|p| Frame::eager(button.at, p.left, button.ease)),  // 5 = padding[3] (left)
-             button.style.map(|s| Frame::eager(button.at, f32::from(s), button.ease)),  // 6 = style blend (passed to widget to mix values at `draw` time)
-        ]
-      } else {
-        vec![Some(Frame::lazy(button.at, 0., button.ease)), // 0 = width
-             Some(Frame::lazy(button.at, 0., button.ease)), // 1 = height
-             Some(Frame::lazy(button.at, 5., button.ease)), // 2 = padding[0] (top)
-             Some(Frame::lazy(button.at, 5., button.ease)), // 3 = padding[1] (right)
-             Some(Frame::lazy(button.at, 5., button.ease)), // 4 = padding[2] (bottom)
-             Some(Frame::lazy(button.at, 5., button.ease)), // 5 = padding[3] (left)
-             Some(Frame::lazy(button.at, 0., button.ease)), // 6 = style blend (passed to widget to mix values at `draw` time)
-        ]
-      }
-    }
-}
diff --git a/src/keyframes/style_container.rs b/src/keyframes/style_container.rs
deleted file mode 100644
index cbbad76..0000000
--- a/src/keyframes/style_container.rs
+++ /dev/null
@@ -1,313 +0,0 @@
-use crate::reexports::iced_core::{
-    widget::Id as IcedId, Element, Length, Padding, Pixels, Renderer as IcedRenderer,
-};
-use crate::reexports::iced_style::container::StyleSheet;
-
-use crate::keyframes::{as_f32, get_length, Repeat};
-use crate::timeline::{Frame, Interped};
-use crate::{Ease, Linear, MovementType};
-
-/// A `StyleContainer`'s animation Id. Used for linking animation built in `update()` with widget output in `view()`
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Id(IcedId);
-
-impl Id {
-    /// Creates a custom [`Id`].
-    pub fn new(id: impl Into<std::borrow::Cow<'static, str>>) -> Self {
-        Self(IcedId::new(id))
-    }
-
-    /// Creates a unique [`Id`].
-    ///
-    /// This function produces a different [`Id`] every time it is called.
-    #[must_use]
-    pub fn unique() -> Self {
-        Self(IcedId::unique())
-    }
-
-    /// Used by [`crate::chain!`] macro
-    #[must_use]
-    pub fn into_chain(self) -> Chain {
-        Chain::new(self)
-    }
-
-    /// Used by [`crate::chain!`] macro
-    #[must_use]
-    pub fn into_chain_with_children(self, children: Vec<StyleContainer>) -> Chain {
-        Chain::with_children(self, children)
-    }
-
-    #[cfg(feature = "iced")]
-    /// Used by [`crate::anim!`] macro
-    pub fn as_widget<'a, Message, Theme, Renderer>(
-        self,
-        style: fn(u8) -> <Theme as StyleSheet>::Style,
-        timeline: &crate::Timeline,
-        content: impl Into<Element<'a, Message, Theme, Renderer>>,
-    ) -> crate::widget::Container<'a, Message, Theme, Renderer>
-    where
-        Renderer: IcedRenderer,
-        Theme: StyleSheet,
-    {
-        StyleContainer::as_widget(self, style, timeline, content)
-    }
-
-    #[cfg(feature = "libcosmic")]
-    /// Used by [`crate::anim!`] macro
-    pub fn as_widget<'a, Message, Theme, Renderer>(
-        self,
-        style: fn(u8) -> <Theme as StyleSheet>::Style,
-        timeline: &crate::Timeline,
-        content: impl Into<Element<'a, Message, Theme, Renderer>>,
-    ) -> crate::widget::Container<'a, Message, Theme, Renderer>
-    where
-        Renderer: IcedRenderer,
-        Theme: StyleSheet + cosmic::cosmic_theme::LayeredTheme,
-        <Theme as crate::reexports::iced_style::container::StyleSheet>::Style:
-            From<cosmic::theme::Container>,
-    {
-        StyleContainer::as_widget(self, style, timeline, content)
-    }
-}
-
-impl From<Id> for IcedId {
-    fn from(id: Id) -> Self {
-        id.0
-    }
-}
-
-#[derive(Debug)]
-pub struct Chain {
-    id: Id,
-    links: Vec<StyleContainer>,
-    repeat: Repeat,
-}
-
-impl Chain {
-    pub fn new(id: Id) -> Self {
-        Chain {
-            id,
-            links: Vec::new(),
-            repeat: Repeat::Never,
-        }
-    }
-
-    pub fn with_children(id: Id, children: Vec<StyleContainer>) -> Self {
-        Chain {
-            id,
-            links: children,
-            repeat: Repeat::Never,
-        }
-    }
-
-    pub fn link(mut self, container: StyleContainer) -> Self {
-        self.links.push(container);
-        self
-    }
-
-    pub fn loop_forever(mut self) -> Self {
-        self.repeat = Repeat::Forever;
-        self
-    }
-
-    pub fn loop_once(mut self) -> Self {
-        self.repeat = Repeat::Never;
-        self
-    }
-}
-
-impl From<Chain> for crate::timeline::Chain {
-    fn from(chain: Chain) -> Self {
-        crate::timeline::Chain::new(
-            chain.id.into(),
-            chain.repeat,
-            chain
-                .links
-                .into_iter()
-                .map(std::convert::Into::into)
-                .collect::<Vec<_>>(),
-        )
-    }
-}
-
-#[must_use = "Keyframes are intended to be used in an animation chain."]
-#[derive(Debug, Clone, Copy)]
-pub struct StyleContainer {
-    at: MovementType,
-    ease: Ease,
-    width: Option<Length>,
-    height: Option<Length>,
-    padding: Option<Padding>,
-    max_width: Option<f32>,
-    max_height: Option<f32>,
-    style: Option<u8>,
-    is_eager: bool,
-}
-
-impl StyleContainer {
-    pub fn new(at: impl Into<MovementType>) -> StyleContainer {
-        let at = at.into();
-        StyleContainer {
-            at,
-            ease: Linear::InOut.into(),
-            width: None,
-            height: None,
-            padding: None,
-            max_width: None,
-            max_height: None,
-            style: None,
-            is_eager: true,
-        }
-    }
-
-    pub fn lazy(at: impl Into<MovementType>) -> StyleContainer {
-        let at = at.into();
-        StyleContainer {
-            at,
-            ease: Linear::InOut.into(),
-            width: None,
-            height: None,
-            padding: None,
-            max_width: None,
-            max_height: None,
-            style: None,
-            is_eager: false,
-        }
-    }
-
-    // Returns a cosmic-time container, not a default iced button. The difference shouldn't
-    // matter to the end user. Though it is an implementation detail.
-    #[cfg(feature = "iced")]
-    pub fn as_widget<'a, Message, Theme, Renderer>(
-        id: Id,
-        style: fn(u8) -> <Theme as StyleSheet>::Style,
-        timeline: &crate::Timeline,
-        content: impl Into<Element<'a, Message, Theme, Renderer>>,
-    ) -> crate::widget::Container<'a, Message, Theme, Renderer>
-    where
-        Renderer: IcedRenderer,
-        Theme: StyleSheet,
-    {
-        let id: IcedId = id.into();
-
-        let container = crate::widget::Container::new(content)
-            .width(get_length(&id, timeline, 0, Length::Shrink))
-            .height(get_length(&id, timeline, 1, Length::Shrink))
-            .padding([
-                timeline.get(&id, 2).map_or(0., |m| m.value),
-                timeline.get(&id, 3).map_or(0., |m| m.value),
-                timeline.get(&id, 4).map_or(0., |m| m.value),
-                timeline.get(&id, 5).map_or(0., |m| m.value),
-            ])
-            .max_width(timeline.get(&id, 6).map_or(f32::INFINITY, |m| m.value))
-            .max_height(timeline.get(&id, 7).map_or(f32::INFINITY, |m| m.value));
-
-        if let Some(Interped {
-            previous,
-            next,
-            percent,
-            ..
-        }) = timeline.get(&id, 8)
-        {
-            container.blend_style(style(previous as u8), style(next as u8), percent)
-        } else {
-            container
-        }
-    }
-
-    #[cfg(feature = "libcosmic")]
-    pub fn as_widget<'a, Message, Theme, Renderer>(
-        id: Id,
-        style: fn(u8) -> <Theme as StyleSheet>::Style,
-        timeline: &crate::Timeline,
-        content: impl Into<Element<'a, Message, Theme, Renderer>>,
-    ) -> crate::widget::Container<'a, Message, Theme, Renderer>
-    where
-        Renderer: IcedRenderer,
-        Theme: StyleSheet + cosmic::cosmic_theme::LayeredTheme,
-        <Theme as crate::reexports::iced_style::container::StyleSheet>::Style:
-            From<cosmic::theme::Container>,
-    {
-        let id: IcedId = id.into();
-
-        let container = crate::widget::Container::new(content)
-            .width(get_length(&id, timeline, 0, Length::Shrink))
-            .height(get_length(&id, timeline, 1, Length::Shrink))
-            .padding([
-                timeline.get(&id, 2).map_or(0., |m| m.value),
-                timeline.get(&id, 3).map_or(0., |m| m.value),
-                timeline.get(&id, 4).map_or(0., |m| m.value),
-                timeline.get(&id, 5).map_or(0., |m| m.value),
-            ])
-            .max_width(timeline.get(&id, 6).map_or(f32::INFINITY, |m| m.value))
-            .max_height(timeline.get(&id, 7).map_or(f32::INFINITY, |m| m.value));
-
-        if let Some(Interped {
-            previous,
-            next,
-            percent,
-            ..
-        }) = timeline.get(&id, 8)
-        {
-            container.blend_style(style(previous as u8), style(next as u8), percent)
-        } else {
-            container
-        }
-    }
-
-    pub fn width(mut self, width: impl Into<Length>) -> Self {
-        self.width = Some(width.into());
-        self
-    }
-
-    pub fn max_width(mut self, max_width: impl Into<Pixels>) -> Self {
-        self.max_width = Some(max_width.into().0);
-        self
-    }
-
-    pub fn height(mut self, height: impl Into<Length>) -> Self {
-        self.height = Some(height.into());
-        self
-    }
-
-    pub fn max_height(mut self, max_height: impl Into<Pixels>) -> Self {
-        self.max_height = Some(max_height.into().0);
-        self
-    }
-
-    pub fn padding<P: Into<Padding>>(mut self, padding: P) -> Self {
-        self.padding = Some(padding.into());
-        self
-    }
-
-    pub fn ease<E: Into<Ease>>(mut self, ease: E) -> Self {
-        self.ease = ease.into();
-        self
-    }
-
-    pub fn style(mut self, style: impl Into<u8>) -> Self {
-        let style = style.into();
-        self.style = Some(style);
-        self
-    }
-}
-
-#[rustfmt::skip]
-impl From<StyleContainer> for Vec<Option<Frame>> {
-    fn from(container: StyleContainer) -> Vec<Option<Frame>> {
-      if container.is_eager {
-        vec![as_f32(container.width).map(|w| Frame::eager(container.at, w, container.ease)),  // 0 = width
-             as_f32(container.height).map(|h| Frame::eager(container.at, h, container.ease)), // 1 = height
-             container.padding.map(|p| Frame::eager(container.at, p.top, container.ease)),    // 2 = padding[0] (top)
-             container.padding.map(|p| Frame::eager(container.at, p.right, container.ease)),  // 3 = padding[1] (right)
-             container.padding.map(|p| Frame::eager(container.at, p.bottom, container.ease)), // 4 = padding[2] (bottom)
-             container.padding.map(|p| Frame::eager(container.at, p.left, container.ease)),   // 5 = padding[3] (left)
-             container.max_width.map(|w| Frame::eager(container.at, w, container.ease)),      // 6 = max_width
-             container.max_height.map(|h| Frame::eager(container.at, h, container.ease)),     // 7 = max_height
-             container.style.map(|s| Frame::eager(container.at, f32::from(s), container.ease)),   // 6 = style blend (passed to widget to mix values at `draw` time)
-        ]
-      } else {
-        vec![Some(Frame::lazy(container.at, 0., container.ease)); 9] // lazy evaluates for all values
-      }
-    }
-}
diff --git a/src/keyframes/toggler.rs b/src/keyframes/toggler.rs
index 852c696..ce25d4f 100644
--- a/src/keyframes/toggler.rs
+++ b/src/keyframes/toggler.rs
@@ -1,7 +1,4 @@
-use crate::reexports::{
-    iced_core::{text, widget::Id as IcedId, Renderer as IcedRenderer},
-    iced_style,
-};
+use crate::reexports::iced_core::{text, widget::Id as IcedId, Renderer as IcedRenderer};
 
 use crate::keyframes::Repeat;
 use crate::timeline::Frame;
@@ -39,17 +36,16 @@ impl Id {
     }
 
     /// Used by [`crate::anim!`] macro
-    pub fn as_widget<'a, Message, Theme, Renderer, F>(
+    pub fn as_widget<'a, Message, Renderer, F>(
         self,
         timeline: &crate::Timeline,
         label: impl Into<Option<String>>,
         is_toggled: bool,
         f: F,
-    ) -> crate::widget::Toggler<'a, Message, Theme, Renderer>
+    ) -> crate::widget::Toggler<'a, Message, Renderer>
     where
         Renderer: IcedRenderer + text::Renderer,
         F: 'a + Fn(Chain, bool) -> Message,
-        Theme: iced_style::toggler::StyleSheet,
     {
         Toggler::as_widget(self, timeline, label, is_toggled, f)
     }
@@ -188,17 +184,16 @@ impl Toggler {
         }
     }
 
-    pub fn as_widget<'a, Message, Theme, Renderer, F>(
+    pub fn as_widget<'a, Message, Renderer, F>(
         id: Id,
         timeline: &crate::Timeline,
         label: impl Into<Option<String>>,
         is_toggled: bool,
         f: F,
-    ) -> crate::widget::Toggler<'a, Message, Theme, Renderer>
+    ) -> crate::widget::Toggler<'a, Message, Renderer>
     where
         Renderer: IcedRenderer + text::Renderer,
         F: 'a + Fn(Chain, bool) -> Message,
-        Theme: iced_style::toggler::StyleSheet,
     {
         crate::widget::Toggler::new(id.clone(), label, is_toggled, f).percent(
             timeline
diff --git a/src/lib.rs b/src/lib.rs
index 40939db..9bd52b6 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -144,17 +144,10 @@ pub mod widget;
 mod keyframes;
 mod utils;
 
-#[cfg(feature = "libcosmic")]
-pub use crate::keyframes::cards;
-pub use crate::keyframes::{
-    button, chain, column, container, id, lazy, row, space, style_button, style_container, toggler,
-};
+pub use crate::keyframes::{cards, chain, id, lazy, toggler};
 pub use crate::timeline::{Chain, Timeline};
 
-#[cfg(feature = "libcosmic")]
 pub use cosmic::iced::time::{Duration, Instant};
-#[cfg(not(feature = "libcosmic"))]
-pub use iced::time::{Duration, Instant};
 
 #[cfg(feature = "once_cell")]
 pub use once_cell;
diff --git a/src/reexports/iced.rs b/src/reexports/iced.rs
index 9c7d059..d90d190 100644
--- a/src/reexports/iced.rs
+++ b/src/reexports/iced.rs
@@ -3,5 +3,5 @@ pub use iced_core;
 pub use iced_futures;
 pub use iced_runtime;
 pub use iced_style;
-pub use iced_style::button::StyleSheet as ButtonStyleSheet;
 pub use iced_widget;
+pub use iced_widget::button::Catalog as ButtonStyleSheet;
diff --git a/src/reexports/libcosmic.rs b/src/reexports/libcosmic.rs
index 2feeea0..117cd56 100644
--- a/src/reexports/libcosmic.rs
+++ b/src/reexports/libcosmic.rs
@@ -2,7 +2,6 @@ pub use cosmic::iced;
 pub use cosmic::iced_core;
 pub use cosmic::iced_futures;
 pub use cosmic::iced_runtime;
-pub use cosmic::iced_style;
 pub use cosmic::iced_widget;
-pub use cosmic::widget::button::StyleSheet as ButtonStyleSheet;
+pub use cosmic::widget::button::Catalog as ButtonStyleSheet;
 pub use cosmic::Theme;
diff --git a/src/reexports/mod.rs b/src/reexports/mod.rs
index caa954b..7e54614 100644
--- a/src/reexports/mod.rs
+++ b/src/reexports/mod.rs
@@ -1,17 +1,6 @@
 //! Reexports of all the modules in this crate.
 
-#[cfg(feature = "libcosmic")]
 mod libcosmic;
-#[cfg(feature = "libcosmic")]
 pub use self::libcosmic::{
-    iced, iced_core, iced_futures, iced_runtime, iced_style, iced_widget, ButtonStyleSheet, Theme,
-};
-
-#[cfg(feature = "iced")]
-#[path = "iced.rs"]
-mod _iced;
-#[cfg(feature = "iced")]
-pub use self::_iced::{
-    iced, iced::Theme, iced_core, iced_futures, iced_runtime, iced_style, iced_widget,
-    ButtonStyleSheet,
+    iced, iced_core, iced_futures, iced_runtime, iced_widget, ButtonStyleSheet, Theme,
 };
diff --git a/src/timeline.rs b/src/timeline.rs
index a3f49de..6610c43 100644
--- a/src/timeline.rs
+++ b/src/timeline.rs
@@ -1,4 +1,3 @@
-#[cfg(feature = "libcosmic")]
 mod imports {
     pub use cosmic::iced::time::{Duration, Instant};
     pub use cosmic::iced_core::{
@@ -7,12 +6,6 @@ mod imports {
     };
     pub use cosmic::iced_futures::subscription::Subscription;
 }
-#[cfg(not(feature = "libcosmic"))]
-mod imports {
-    pub use iced::time::{Duration, Instant};
-    pub use iced_core::{event, widget, Event, Hasher};
-    pub use iced_futures::subscription::Subscription;
-}
 
 use imports::{widget, Duration, Instant, Subscription};
 
@@ -567,27 +560,26 @@ impl Timeline {
             }))
     }
 
-    /// Efficiently request redraws for animations.
-    /// Automatically checks if animations are in a state where redraws arn't necessary.
-    #[cfg(not(feature = "libcosmic"))]
-    pub fn as_subscription<Event>(&self) -> Subscription<Instant> {
-        if self.is_idle() {
-            Subscription::none()
-        } else {
-            iced::window::frames()
-        }
-    }
+    // /// Efficiently request redraws for animations.
+    // /// Automatically checks if animations are in a state where redraws arn't necessary.
+    // #[cfg(not(feature = "libcosmic"))]
+    // pub fn as_subscription<Event>(&self) -> Subscription<Instant> {
+    //     if self.is_idle() {
+    //         Subscription::none()
+    //     } else {
+    //         iced::window::frames()
+    //     }
+    // }
 
     /// Efficiently request redraws for animations.
     /// Automatically checks if animations are in a state where redraws arn't necessary.
-    #[cfg(feature = "libcosmic")]
     pub fn as_subscription(&self) -> Subscription<(cosmic::iced::window::Id, Instant)> {
         use cosmic::iced;
 
         if self.is_idle() {
             Subscription::none()
         } else {
-            iced::window::frames() // ~120FPS
+            cosmic::iced_runtime::window::frames() // ~120FPS
         }
     }
 }
diff --git a/src/utils.rs b/src/utils.rs
index b3ff8b1..d8eecf6 100644
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -2,7 +2,6 @@
 
 //! Utility functions for handling data in this library.
 
-#[cfg(feature = "libcosmic")]
 use crate::reexports::iced_core::{
     layout::{Limits, Node},
     Point, Size,
@@ -23,7 +22,6 @@ pub fn static_array_from_iter<T: Copy + Default, const SIZE: usize>(
     array
 }
 
-#[cfg(feature = "libcosmic")]
 /// Produces a [`Node`] with two children nodes one right next to each other.
 pub fn next_to_each_other(
     limits: &Limits,
diff --git a/src/widget.rs b/src/widget.rs
index 14361a1..6798161 100644
--- a/src/widget.rs
+++ b/src/widget.rs
@@ -1,42 +1,13 @@
 #![allow(clippy::too_many_arguments)]
 
-use crate::{
-    reexports::{iced_core, iced_style},
-    utils::static_array_from_iter,
-};
+use crate::{reexports::iced_core, utils::static_array_from_iter};
 
-#[cfg(feature = "libcosmic")]
 pub mod cards;
-#[cfg(feature = "libcosmic")]
-pub mod cosmic_button;
-#[cfg(feature = "libcosmic")]
-pub mod cosmic_container;
-#[cfg(feature = "libcosmic")]
 pub mod cosmic_toggler;
 
-#[cfg(feature = "libcosmic")]
 pub use cards::Cards;
-#[cfg(feature = "libcosmic")]
-pub use cosmic_button::Button;
-#[cfg(feature = "libcosmic")]
-pub use cosmic_container::Container;
-#[cfg(feature = "libcosmic")]
 pub use cosmic_toggler::Toggler;
 
-#[cfg(not(feature = "libcosmic"))]
-pub mod button;
-#[cfg(not(feature = "libcosmic"))]
-pub mod container;
-#[cfg(not(feature = "libcosmic"))]
-pub mod toggler;
-
-#[cfg(not(feature = "libcosmic"))]
-pub use button::Button;
-#[cfg(not(feature = "libcosmic"))]
-pub use container::Container;
-#[cfg(not(feature = "libcosmic"))]
-pub use toggler::Toggler;
-
 /// A convenience type to optimize style-able widgets,
 /// to only do the "expensize" style calculations if needed.
 #[derive(Debug)]
@@ -51,212 +22,3 @@ use self::iced_core::{
     gradient::{ColorStop, Linear},
     Background, Color, Gradient, Radians, Vector,
 };
-
-/// Blend between two button appearances.
-pub fn container_blend_appearances(
-    one: iced_style::container::Appearance,
-    mut two: iced_style::container::Appearance,
-    percent: f32,
-) -> iced_style::container::Appearance {
-    use crate::lerp;
-
-    // background
-    let background_mix: Background = match (one.background, two.background) {
-        (Some(Background::Color(c1)), Some(Background::Color(c2))) => {
-            let background_mix = static_array_from_iter::<f32, 4>(
-                c1.into_linear()
-                    .iter()
-                    .zip(c2.into_linear().iter())
-                    .map(|(o, t)| lerp(*o, *t, percent)),
-            );
-
-            Background::from(Color::from(background_mix))
-        }
-        (
-            Some(Background::Gradient(Gradient::Linear(l1))),
-            Some(Background::Gradient(Gradient::Linear(l2))),
-        ) => {
-            let angle = lerp(l1.angle.0, l2.angle.0, percent);
-            let stops = l1
-                .stops
-                .iter()
-                .zip(l2.stops.iter())
-                .map(|(o, t)| match (o, t) {
-                    (
-                        Some(ColorStop {
-                            offset: o1,
-                            color: c1,
-                        }),
-                        Some(ColorStop {
-                            color: c2,
-                            offset: o2,
-                        }),
-                    ) => {
-                        let color = static_array_from_iter::<f32, 4>(
-                            c1.into_linear()
-                                .iter()
-                                .zip(c2.into_linear().iter())
-                                .map(|(o, t)| lerp(*o, *t, percent)),
-                        );
-
-                        Some(ColorStop {
-                            color: color.into(),
-                            offset: lerp(*o1, *o2, percent),
-                        })
-                    }
-                    (a, b) => *if percent < 0.5 { a } else { b },
-                });
-
-            Background::Gradient(
-                Linear {
-                    angle: Radians(angle),
-                    stops: static_array_from_iter(stops),
-                }
-                .into(),
-            )
-        }
-        _ => Background::from(Color::from([0.0, 0.0, 0.0, 0.0])),
-    };
-    // boarder color
-    let border_color = static_array_from_iter::<f32, 4>(
-        one.border
-            .color
-            .into_linear()
-            .iter()
-            .zip(two.border.color.into_linear().iter())
-            .map(|(o, t)| lerp(*o, *t, percent)),
-    );
-
-    // text
-    let text = one
-        .text_color
-        .map(|t| {
-            static_array_from_iter::<f32, 4>(
-                t.into_linear()
-                    .iter()
-                    .zip(two.text_color.unwrap_or(t).into_linear().iter())
-                    .map(|(o, t)| lerp(*o, *t, percent)),
-            )
-        })
-        .map(Into::<Color>::into);
-
-    let one_border_radius: [f32; 4] = one.border.radius.into();
-    let two_border_radius: [f32; 4] = two.border.radius.into();
-    two.background = Some(background_mix);
-    two.border.radius = [
-        lerp(one_border_radius[0], two_border_radius[0], percent),
-        lerp(one_border_radius[1], two_border_radius[1], percent),
-        lerp(one_border_radius[2], two_border_radius[2], percent),
-        lerp(one_border_radius[3], two_border_radius[3], percent),
-    ]
-    .into();
-    two.border.width = lerp(one.border.width, two.border.width, percent);
-    two.border.color = border_color.into();
-    two.text_color = text;
-    two
-}
-
-/// Blend between two button appearances.
-#[must_use]
-pub fn button_blend_appearances(
-    one: iced_style::button::Appearance,
-    mut two: iced_style::button::Appearance,
-    percent: f32,
-) -> iced_style::button::Appearance {
-    use crate::lerp;
-
-    // shadow offet
-    let x1 = one.shadow_offset.x;
-    let y1 = one.shadow_offset.y;
-    let x2 = two.shadow_offset.x;
-    let y2 = two.shadow_offset.y;
-
-    // background
-    let background_mix: Background = match (one.background, two.background) {
-        (Some(Background::Color(c1)), Some(Background::Color(c2))) => {
-            Background::from(Color::from(static_array_from_iter::<f32, 4>(
-                c1.into_linear()
-                    .iter()
-                    .zip(c2.into_linear().iter())
-                    .map(|(o, t)| lerp(*o, *t, percent)),
-            )))
-        }
-        (
-            Some(Background::Gradient(Gradient::Linear(l1))),
-            Some(Background::Gradient(Gradient::Linear(l2))),
-        ) => {
-            let angle = lerp(l1.angle.0, l2.angle.0, percent);
-            let stops = l1
-                .stops
-                .iter()
-                .zip(l2.stops.iter())
-                .map(|(o, t)| match (o, t) {
-                    (
-                        Some(ColorStop {
-                            offset: o1,
-                            color: c1,
-                        }),
-                        Some(ColorStop {
-                            color: c2,
-                            offset: o2,
-                        }),
-                    ) => Some(ColorStop {
-                        color: static_array_from_iter::<f32, 4>(
-                            c1.into_linear()
-                                .iter()
-                                .zip(c2.into_linear().iter())
-                                .map(|(o, t)| lerp(*o, *t, percent)),
-                        )
-                        .into(),
-                        offset: lerp(*o1, *o2, percent),
-                    }),
-                    (a, b) => *if percent < 0.5 { a } else { b },
-                });
-            Background::Gradient(
-                Linear {
-                    angle: Radians(angle),
-                    stops: static_array_from_iter(stops),
-                }
-                .into(),
-            )
-        }
-        _ => Background::from(Color::from([0.0, 0.0, 0.0, 0.0])),
-    };
-
-    // boarder color
-    let border_color: [f32; 4] = crate::utils::static_array_from_iter(
-        one.border
-            .color
-            .into_linear()
-            .iter()
-            .zip(two.border.color.into_linear().iter())
-            .map(|(o, t)| lerp(*o, *t, percent)),
-    );
-
-    // text
-    let text = static_array_from_iter::<f32, 4>(
-        one.text_color
-            .into_linear()
-            .iter()
-            .zip(two.text_color.into_linear().iter())
-            .map(|(o, t)| lerp(*o, *t, percent)),
-    );
-
-    let br1: [f32; 4] = one.border.radius.into();
-    let br2: [f32; 4] = two.border.radius.into();
-
-    let br = [
-        lerp(br1[0], br2[0], percent),
-        lerp(br1[1], br2[1], percent),
-        lerp(br1[2], br2[2], percent),
-        lerp(br1[3], br2[3], percent),
-    ];
-
-    two.shadow_offset = Vector::new(lerp(x1, x2, percent), lerp(y1, y2, percent));
-    two.background = Some(background_mix);
-    two.border.radius = br.into();
-    two.border.width = lerp(one.border.width, two.border.width, percent);
-    two.border.color = border_color.into();
-    two.text_color = text.into();
-    two
-}
diff --git a/src/widget/button.rs b/src/widget/button.rs
deleted file mode 100644
index 9bd20a5..0000000
--- a/src/widget/button.rs
+++ /dev/null
@@ -1,459 +0,0 @@
-//! Allow your users to perform actions by pressing a button.
-//!
-//! A [`Button`] has some local [`State`].
-use crate::reexports::iced::Size;
-use crate::widget::StyleType;
-use iced_core::event::{self, Event};
-use iced_core::layout;
-use iced_core::mouse;
-use iced_core::overlay;
-use iced_core::renderer;
-use iced_core::touch;
-use iced_core::widget::tree::{self, Tree};
-use iced_core::widget::Operation;
-use iced_core::{
-    Background, Clipboard, Color, Element, Layout, Length, Padding, Point, Rectangle, Shell,
-    Vector, Widget,
-};
-
-pub use iced_style::button::{Appearance, StyleSheet};
-
-use super::button_blend_appearances;
-
-/// A generic widget that produces a message when pressed.
-///
-#[allow(missing_debug_implementations)]
-pub struct Button<'a, Message, Theme, Renderer>
-where
-    Renderer: iced_core::renderer::Renderer,
-    Theme: iced_style::button::StyleSheet,
-{
-    content: Element<'a, Message, Theme, Renderer>,
-    on_press: Option<Message>,
-    width: Length,
-    height: Length,
-    padding: Padding,
-    style: StyleType<<Theme as StyleSheet>::Style>,
-}
-
-impl<'a, Message, Theme, Renderer> Button<'a, Message, Theme, Renderer>
-where
-    Renderer: iced_core::renderer::Renderer,
-    Theme: iced_style::button::StyleSheet,
-{
-    /// Creates a new [`Button`] with the given content.
-    pub fn new(content: impl Into<Element<'a, Message, Theme, Renderer>>) -> Self {
-        Button {
-            content: content.into(),
-            on_press: None,
-            width: Length::Shrink,
-            height: Length::Shrink,
-            padding: Padding::new(5.0),
-            style: StyleType::Static(<Theme as StyleSheet>::Style::default()),
-        }
-    }
-
-    /// Sets the width of the [`Button`].
-    pub fn width(mut self, width: impl Into<Length>) -> Self {
-        self.width = width.into();
-        self
-    }
-
-    /// Sets the height of the [`Button`].
-    pub fn height(mut self, height: impl Into<Length>) -> Self {
-        self.height = height.into();
-        self
-    }
-
-    /// Sets the [`Padding`] of the [`Button`].
-    pub fn padding<P: Into<Padding>>(mut self, padding: P) -> Self {
-        self.padding = padding.into();
-        self
-    }
-
-    /// Sets the message that will be produced when the [`Button`] is pressed.
-    ///
-    /// Unless `on_press` is called, the [`Button`] will be disabled.
-    pub fn on_press(mut self, msg: Message) -> Self {
-        self.on_press = Some(msg);
-        self
-    }
-
-    /// Sets the style variant of this [`Button`].
-    pub fn style(mut self, style: <Theme as StyleSheet>::Style) -> Self {
-        self.style = StyleType::Static(style);
-        self
-    }
-
-    /// Sets the animatable style variant of this [`Button`].
-    pub fn blend_style(
-        mut self,
-        style1: <Theme as StyleSheet>::Style,
-        style2: <Theme as StyleSheet>::Style,
-        percent: f32,
-    ) -> Self {
-        self.style = StyleType::Blend(style1, style2, percent);
-        self
-    }
-}
-
-impl<'a, Message, Theme, Renderer> Widget<Message, Theme, Renderer>
-    for Button<'a, Message, Theme, Renderer>
-where
-    Message: 'a + Clone,
-    Renderer: 'a + iced_core::renderer::Renderer,
-    Theme: iced_style::button::StyleSheet,
-{
-    fn tag(&self) -> tree::Tag {
-        tree::Tag::of::<State>()
-    }
-
-    fn state(&self) -> tree::State {
-        tree::State::new(State::new())
-    }
-
-    fn children(&self) -> Vec<Tree> {
-        vec![Tree::new(&self.content)]
-    }
-
-    fn diff(&self, tree: &mut Tree) {
-        tree.diff_children(std::slice::from_ref(&self.content));
-    }
-
-    fn size(&self) -> Size<Length> {
-        Size::new(self.width, self.height)
-    }
-
-    fn layout(
-        &self,
-        tree: &mut Tree,
-        renderer: &Renderer,
-        limits: &layout::Limits,
-    ) -> layout::Node {
-        layout(
-            renderer,
-            limits,
-            self.width,
-            self.height,
-            self.padding,
-            |renderer, limits| {
-                self.content
-                    .as_widget()
-                    .layout(&mut tree.children[0], renderer, limits)
-            },
-        )
-    }
-
-    fn operate(
-        &self,
-        tree: &mut Tree,
-        layout: Layout<'_>,
-        renderer: &Renderer,
-        operation: &mut dyn Operation<Message>,
-    ) {
-        operation.container(None, layout.bounds(), &mut |operation| {
-            self.content.as_widget().operate(
-                &mut tree.children[0],
-                layout.children().next().unwrap(),
-                renderer,
-                operation,
-            );
-        });
-    }
-
-    fn on_event(
-        &mut self,
-        tree: &mut Tree,
-        event: Event,
-        layout: Layout<'_>,
-        cursor_position: mouse::Cursor,
-        renderer: &Renderer,
-        clipboard: &mut dyn Clipboard,
-        shell: &mut Shell<'_, Message>,
-        _viewport: &Rectangle,
-    ) -> event::Status {
-        if let event::Status::Captured = self.content.as_widget_mut().on_event(
-            &mut tree.children[0],
-            event.clone(),
-            layout.children().next().unwrap(),
-            cursor_position,
-            renderer,
-            clipboard,
-            shell,
-            _viewport,
-        ) {
-            return event::Status::Captured;
-        }
-
-        update(
-            event,
-            layout,
-            cursor_position,
-            shell,
-            &self.on_press,
-            || tree.state.downcast_mut::<State>(),
-        )
-    }
-
-    fn draw(
-        &self,
-        tree: &Tree,
-        renderer: &mut Renderer,
-        theme: &Theme,
-        #[cfg(feature = "libcosmic")] style: &renderer::Style,
-        #[cfg(not(feature = "libcosmic"))] _style: &renderer::Style,
-        layout: Layout<'_>,
-        cursor_position: mouse::Cursor,
-        _viewport: &Rectangle,
-    ) {
-        let bounds = layout.bounds();
-        let content_layout = layout.children().next().unwrap();
-
-        let styling = draw::<_, Theme>(
-            renderer,
-            bounds,
-            cursor_position,
-            self.on_press.is_some(),
-            theme,
-            &self.style,
-            || tree.state.downcast_ref::<State>(),
-        );
-
-        self.content.as_widget().draw(
-            &tree.children[0],
-            renderer,
-            theme,
-            &renderer::Style {
-                #[cfg(feature = "libcosmic")]
-                icon_color: styling.icon_color.unwrap_or(style.icon_color),
-                text_color: styling.text_color,
-            },
-            content_layout,
-            cursor_position,
-            &bounds,
-        );
-    }
-
-    fn mouse_interaction(
-        &self,
-        _tree: &Tree,
-        layout: Layout<'_>,
-        cursor_position: mouse::Cursor,
-        _viewport: &Rectangle,
-        _renderer: &Renderer,
-    ) -> mouse::Interaction {
-        mouse_interaction(layout, cursor_position, self.on_press.is_some())
-    }
-
-    fn overlay<'b>(
-        &'b mut self,
-        tree: &'b mut Tree,
-        layout: Layout<'_>,
-        renderer: &Renderer,
-    ) -> Option<overlay::Element<'b, Message, Theme, Renderer>> {
-        self.content.as_widget_mut().overlay(
-            &mut tree.children[0],
-            layout.children().next().unwrap(),
-            renderer,
-        )
-    }
-}
-
-impl<'a, Message, Theme, Renderer> From<Button<'a, Message, Theme, Renderer>>
-    for Element<'a, Message, Theme, Renderer>
-where
-    Message: Clone + 'a,
-    Renderer: iced_core::renderer::Renderer + 'a,
-    Theme: StyleSheet + 'a,
-{
-    fn from(button: Button<'a, Message, Theme, Renderer>) -> Self {
-        Self::new(button)
-    }
-}
-
-/// The local state of a [`Button`].
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
-pub struct State {
-    is_pressed: bool,
-}
-
-impl State {
-    /// Creates a new [`State`].
-    #[must_use]
-    pub fn new() -> State {
-        State::default()
-    }
-}
-
-/// Processes the given [`Event`] and updates the [`State`] of a [`Button`]
-/// accordingly.
-pub fn update<'a, Message: Clone>(
-    event: Event,
-    layout: Layout<'_>,
-    cursor_position: mouse::Cursor,
-    shell: &mut Shell<'_, Message>,
-    on_press: &Option<Message>,
-    state: impl FnOnce() -> &'a mut State,
-) -> event::Status {
-    match event {
-        Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left))
-        | Event::Touch(touch::Event::FingerPressed { .. }) => {
-            if on_press.is_some() {
-                let bounds = layout.bounds();
-
-                if cursor_position.is_over(bounds) {
-                    let state = state();
-
-                    state.is_pressed = true;
-
-                    return event::Status::Captured;
-                }
-            }
-        }
-        Event::Mouse(mouse::Event::ButtonReleased(mouse::Button::Left))
-        | Event::Touch(touch::Event::FingerLifted { .. }) => {
-            if let Some(on_press) = on_press.clone() {
-                let state = state();
-
-                if state.is_pressed {
-                    state.is_pressed = false;
-
-                    let bounds = layout.bounds();
-
-                    if cursor_position.is_over(bounds) {
-                        shell.publish(on_press);
-                    }
-
-                    return event::Status::Captured;
-                }
-            }
-        }
-        Event::Touch(touch::Event::FingerLost { .. }) => {
-            let state = state();
-
-            state.is_pressed = false;
-        }
-        _ => {}
-    }
-
-    event::Status::Ignored
-}
-
-/// Draws a [`Button`].
-pub fn draw<'a, Renderer: iced_core::renderer::Renderer, Theme: iced_style::button::StyleSheet>(
-    renderer: &mut Renderer,
-    bounds: Rectangle,
-    cursor_position: mouse::Cursor,
-    is_enabled: bool,
-    style_sheet: &dyn StyleSheet<Style = <Theme as StyleSheet>::Style>,
-    style: &StyleType<<Theme as StyleSheet>::Style>,
-    state: impl FnOnce() -> &'a State,
-) -> Appearance {
-    let is_mouse_over = cursor_position.is_over(bounds);
-
-    // todo disable blend if user has applied style.
-    let styling = match style {
-        StyleType::Static(style) => {
-            if !is_enabled {
-                style_sheet.disabled(style)
-            } else if is_mouse_over {
-                let state = state();
-
-                if state.is_pressed {
-                    style_sheet.pressed(style)
-                } else {
-                    style_sheet.hovered(style)
-                }
-            } else {
-                style_sheet.active(style)
-            }
-        }
-        StyleType::Blend(style1, style2, percent) => {
-            let (one, two) = if !is_enabled {
-                (style_sheet.disabled(style1), style_sheet.disabled(style2))
-            } else if is_mouse_over {
-                let state = state();
-
-                if state.is_pressed {
-                    (style_sheet.pressed(style1), style_sheet.pressed(style2))
-                } else {
-                    (style_sheet.hovered(style1), style_sheet.hovered(style2))
-                }
-            } else {
-                (style_sheet.active(style1), style_sheet.active(style2))
-            };
-
-            button_blend_appearances(one, two, *percent)
-        }
-    };
-
-    if styling.background.is_some() || styling.border.width > 0.0 {
-        if styling.shadow_offset != Vector::default() {
-            // TODO: Implement proper shadow support
-            renderer.fill_quad(
-                renderer::Quad {
-                    bounds: Rectangle {
-                        x: bounds.x + styling.shadow_offset.x,
-                        y: bounds.y + styling.shadow_offset.y,
-                        ..bounds
-                    },
-                    border: styling.border,
-                    shadow: Default::default(),
-                },
-                Background::Color([0.0, 0.0, 0.0, 0.5].into()),
-            );
-        }
-
-        renderer.fill_quad(
-            renderer::Quad {
-                bounds,
-                border: styling.border,
-                shadow: Default::default(),
-            },
-            styling
-                .background
-                .unwrap_or(Background::Color(Color::TRANSPARENT)),
-        );
-    }
-
-    styling
-}
-
-/// Computes the layout of a [`Button`].
-pub fn layout<Renderer>(
-    renderer: &Renderer,
-    limits: &layout::Limits,
-    width: Length,
-    height: Length,
-    padding: Padding,
-    layout_content: impl FnOnce(&Renderer, &layout::Limits) -> layout::Node,
-) -> layout::Node {
-    let limits = limits.width(width).height(height);
-
-    let mut content = layout_content(renderer, &limits.shrink(padding));
-    let padding = padding.fit(content.size(), limits.max());
-    let size = limits
-        .shrink(padding)
-        .resolve(width, height, content.size())
-        .expand(padding);
-
-    content = content.move_to(Point::new(padding.left, padding.top));
-
-    layout::Node::with_children(size, vec![content])
-}
-
-/// Returns the [`mouse::Interaction`] of a [`Button`].
-#[must_use]
-pub fn mouse_interaction(
-    layout: Layout<'_>,
-    cursor_position: mouse::Cursor,
-    is_enabled: bool,
-) -> mouse::Interaction {
-    let is_mouse_over = cursor_position.is_over(layout.bounds());
-
-    if is_mouse_over && is_enabled {
-        mouse::Interaction::Pointer
-    } else {
-        mouse::Interaction::default()
-    }
-}
diff --git a/src/widget/cards.rs b/src/widget/cards.rs
index ba52ecb..1c75ef7 100644
--- a/src/widget/cards.rs
+++ b/src/widget/cards.rs
@@ -5,7 +5,13 @@ use self::iced_core::{
 };
 use cosmic::{
     iced_core::{self, Border, Shadow},
-    widget::{button, card::style::StyleSheet, column, icon, icon::Handle, row, text},
+    widget::{
+        button,
+        card::style::{Catalog, Style},
+        column, icon,
+        icon::Handle,
+        row, text,
+    },
 };
 use float_cmp::approx_eq;
 
@@ -116,21 +122,21 @@ where
                 let off_animation = chain::Cards::off(id.clone(), 1.0);
 
                 let button_content = row::with_children(show_less_children)
-                    .align_items(iced_core::Alignment::Center)
+                    .align_y(iced_core::Alignment::Center)
                     .spacing(TOP_SPACING)
                     .width(Length::Shrink);
 
                 Element::from(
                     button::custom(button_content)
-                        .style(cosmic::theme::Button::Text)
+                        .class(cosmic::theme::Button::Text)
                         .width(Length::Shrink)
                         .on_press(on_show_more(off_animation, false))
                         .padding([PADDING / 2, PADDING]),
                 )
             },
             clear_all_button: Element::from(
-                button::custom(text::body(clear_all_label))
-                    .style(cosmic::theme::Button::Text)
+                button::custom(text(clear_all_label))
+                    .class(cosmic::theme::Button::Text)
                     .width(Length::Shrink)
                     .on_press(on_clear_all)
                     .padding([PADDING / 2, PADDING]),
@@ -144,14 +150,14 @@ where
                             .push(w)
                             .push(text::caption(show_more_label))
                             .spacing(VERTICAL_SPACING)
-                            .align_items(iced_core::Alignment::Center)
+                            .align_x(iced_core::Alignment::Center)
                             .into()
                     } else {
                         w
                     };
 
                     let b = cosmic::iced::widget::button(custom_content)
-                        .style(cosmic::theme::iced::Button::Card)
+                        .class(cosmic::theme::iced::Button::Card)
                         .padding(PADDING);
                     if i == 0 && !expanded && can_show_more {
                         let on_animation = chain::Cards::on(id.clone(), 1.0);
@@ -402,7 +408,7 @@ where
         // Draw first to appear behind
         if fully_unexpanded {
             let card_layout = layout.next().unwrap();
-            let appearance = theme.default();
+            let appearance = Style::default();
             let bg_layout = layout.collect::<Vec<_>>();
             for (i, layout) in (0..2).zip(bg_layout.into_iter()).rev() {
                 renderer.fill_quad(
diff --git a/src/widget/container.rs b/src/widget/container.rs
deleted file mode 100644
index 5e00484..0000000
--- a/src/widget/container.rs
+++ /dev/null
@@ -1,393 +0,0 @@
-//! Decorate content and apply alignment.
-
-use crate::reexports::{iced_core, iced_style};
-use iced_core::alignment::{self, Alignment};
-use iced_core::event::{self, Event};
-use iced_core::layout;
-use iced_core::mouse;
-use iced_core::overlay;
-use iced_core::renderer;
-use iced_core::widget::{self, Operation, Tree};
-use iced_core::{
-    Background, Clipboard, Color, Element, Layout, Length, Padding, Pixels, Point, Rectangle,
-    Shell, Size, Widget,
-};
-
-use crate::widget::StyleType;
-
-pub use iced_style::container::{Appearance, StyleSheet};
-
-use super::container_blend_appearances;
-
-/// An element decorating some content.
-///
-/// It is normally used for alignment purposes.
-#[allow(missing_debug_implementations)]
-pub struct Container<'a, Message, Theme, Renderer>
-where
-    Renderer: iced_core::Renderer,
-    Theme: iced_style::container::StyleSheet,
-{
-    id: Option<Id>,
-    padding: Padding,
-    width: Length,
-    height: Length,
-    max_width: f32,
-    max_height: f32,
-    horizontal_alignment: alignment::Horizontal,
-    vertical_alignment: alignment::Vertical,
-    style: StyleType<<Theme as StyleSheet>::Style>,
-    content: Element<'a, Message, Theme, Renderer>,
-}
-
-impl<'a, Message, Theme, Renderer> Container<'a, Message, Theme, Renderer>
-where
-    Renderer: iced_core::Renderer,
-    Theme: iced_style::container::StyleSheet,
-{
-    /// Creates an empty [`Container`].
-    pub fn new<T>(content: T) -> Self
-    where
-        T: Into<Element<'a, Message, Theme, Renderer>>,
-    {
-        Container {
-            id: None,
-            padding: Padding::ZERO,
-            width: Length::Shrink,
-            height: Length::Shrink,
-            max_width: f32::INFINITY,
-            max_height: f32::INFINITY,
-            horizontal_alignment: alignment::Horizontal::Left,
-            vertical_alignment: alignment::Vertical::Top,
-            style: StyleType::Static(Default::default()),
-            content: content.into(),
-        }
-    }
-
-    /// Sets the [`Id`] of the [`Container`].
-    pub fn id(mut self, id: Id) -> Self {
-        self.id = Some(id);
-        self
-    }
-
-    /// Sets the [`Padding`] of the [`Container`].
-    pub fn padding<P: Into<Padding>>(mut self, padding: P) -> Self {
-        self.padding = padding.into();
-        self
-    }
-
-    /// Sets the width of the [`Container`].
-    pub fn width(mut self, width: impl Into<Length>) -> Self {
-        self.width = width.into();
-        self
-    }
-
-    /// Sets the height of the [`Container`].
-    pub fn height(mut self, height: impl Into<Length>) -> Self {
-        self.height = height.into();
-        self
-    }
-
-    /// Sets the maximum width of the [`Container`].
-    pub fn max_width(mut self, max_width: impl Into<Pixels>) -> Self {
-        self.max_width = max_width.into().0;
-        self
-    }
-
-    /// Sets the maximum height of the [`Container`].
-    pub fn max_height(mut self, max_height: impl Into<Pixels>) -> Self {
-        self.max_height = max_height.into().0;
-        self
-    }
-
-    /// Sets the content alignment for the horizontal axis of the [`Container`].
-    pub fn align_x(mut self, alignment: alignment::Horizontal) -> Self {
-        self.horizontal_alignment = alignment;
-        self
-    }
-
-    /// Sets the content alignment for the vertical axis of the [`Container`].
-    pub fn align_y(mut self, alignment: alignment::Vertical) -> Self {
-        self.vertical_alignment = alignment;
-        self
-    }
-
-    /// Centers the contents in the horizontal axis of the [`Container`].
-    pub fn center_x(mut self) -> Self {
-        self.horizontal_alignment = alignment::Horizontal::Center;
-        self
-    }
-
-    /// Centers the contents in the vertical axis of the [`Container`].
-    pub fn center_y(mut self) -> Self {
-        self.vertical_alignment = alignment::Vertical::Center;
-        self
-    }
-
-    /// Sets the style of the [`Container`].
-    pub fn style(mut self, style: impl Into<<Theme as StyleSheet>::Style>) -> Self {
-        self.style = StyleType::Static(style.into());
-        self
-    }
-
-    /// Set the appearance this [`Container`] to a blend of two styles.
-    ///
-    /// Percent is a f32 of 0.0 -> 1.0.
-    /// Where 0 is 100% style1 and 1 is 100% style2.
-    pub fn blend_style(
-        mut self,
-        style1: <Theme as StyleSheet>::Style,
-        style2: <Theme as StyleSheet>::Style,
-        percent: f32,
-    ) -> Self {
-        self.style = StyleType::Blend(style1, style2, percent);
-        self
-    }
-}
-
-impl<'a, Message, Theme, Renderer> Widget<Message, Theme, Renderer>
-    for Container<'a, Message, Theme, Renderer>
-where
-    Renderer: iced_core::Renderer,
-    Theme: iced_style::container::StyleSheet,
-{
-    fn children(&self) -> Vec<Tree> {
-        vec![Tree::new(&self.content)]
-    }
-
-    fn diff(&self, tree: &mut Tree) {
-        tree.diff_children(std::slice::from_ref(&self.content))
-    }
-
-    fn size(&self) -> Size<Length> {
-        Size::new(self.width, self.height)
-    }
-
-    fn layout(
-        &self,
-        tree: &mut Tree,
-        renderer: &Renderer,
-        limits: &layout::Limits,
-    ) -> layout::Node {
-        layout(
-            renderer,
-            limits,
-            self.width,
-            self.height,
-            self.max_width,
-            self.max_height,
-            self.padding,
-            self.horizontal_alignment,
-            self.vertical_alignment,
-            |renderer, limits| {
-                self.content
-                    .as_widget()
-                    .layout(&mut tree.children[0], renderer, limits)
-            },
-        )
-    }
-
-    fn operate(
-        &self,
-        tree: &mut Tree,
-        layout: Layout<'_>,
-        renderer: &Renderer,
-        operation: &mut dyn Operation<Message>,
-    ) {
-        operation.container(
-            self.id.as_ref().map(|id| &id.0),
-            layout.bounds(),
-            &mut |operation| {
-                self.content.as_widget().operate(
-                    &mut tree.children[0],
-                    layout.children().next().unwrap(),
-                    renderer,
-                    operation,
-                );
-            },
-        );
-    }
-
-    fn on_event(
-        &mut self,
-        tree: &mut Tree,
-        event: Event,
-        layout: Layout<'_>,
-        cursor_position: mouse::Cursor,
-        renderer: &Renderer,
-        clipboard: &mut dyn Clipboard,
-        shell: &mut Shell<'_, Message>,
-        viewport: &Rectangle,
-    ) -> event::Status {
-        self.content.as_widget_mut().on_event(
-            &mut tree.children[0],
-            event,
-            layout.children().next().unwrap(),
-            cursor_position,
-            renderer,
-            clipboard,
-            shell,
-            viewport,
-        )
-    }
-
-    fn mouse_interaction(
-        &self,
-        tree: &Tree,
-        layout: Layout<'_>,
-        cursor_position: mouse::Cursor,
-        viewport: &Rectangle,
-        renderer: &Renderer,
-    ) -> mouse::Interaction {
-        self.content.as_widget().mouse_interaction(
-            &tree.children[0],
-            layout.children().next().unwrap(),
-            cursor_position,
-            viewport,
-            renderer,
-        )
-    }
-
-    fn draw(
-        &self,
-        tree: &Tree,
-        renderer: &mut Renderer,
-        theme: &Theme,
-        renderer_style: &renderer::Style,
-        layout: Layout<'_>,
-        cursor_position: mouse::Cursor,
-        viewport: &Rectangle,
-    ) {
-        let style = match &self.style {
-            StyleType::Static(style) => theme.appearance(style),
-            StyleType::Blend(one, two, percent) => {
-                container_blend_appearances(theme.appearance(one), theme.appearance(two), *percent)
-            }
-        };
-
-        draw_background(renderer, &style, layout.bounds());
-
-        self.content.as_widget().draw(
-            &tree.children[0],
-            renderer,
-            theme,
-            &renderer::Style {
-                text_color: style.text_color.unwrap_or(renderer_style.text_color),
-            },
-            layout.children().next().unwrap(),
-            cursor_position,
-            viewport,
-        );
-    }
-
-    fn overlay<'b>(
-        &'b mut self,
-        tree: &'b mut Tree,
-        layout: Layout<'_>,
-        renderer: &Renderer,
-    ) -> Option<overlay::Element<'b, Message, Theme, Renderer>> {
-        self.content.as_widget_mut().overlay(
-            &mut tree.children[0],
-            layout.children().next().unwrap(),
-            renderer,
-        )
-    }
-}
-
-impl<'a, Message, Theme, Renderer> From<Container<'a, Message, Theme, Renderer>>
-    for Element<'a, Message, Theme, Renderer>
-where
-    Message: 'a,
-    Renderer: 'a + iced_core::Renderer,
-    Theme: iced_style::container::StyleSheet + 'a,
-{
-    fn from(
-        column: Container<'a, Message, Theme, Renderer>,
-    ) -> Element<'a, Message, Theme, Renderer> {
-        Element::new(column)
-    }
-}
-
-/// Computes the layout of a [`Container`].
-pub fn layout<Renderer>(
-    renderer: &Renderer,
-    limits: &layout::Limits,
-    width: Length,
-    height: Length,
-    max_width: f32,
-    max_height: f32,
-    padding: Padding,
-    horizontal_alignment: alignment::Horizontal,
-    vertical_alignment: alignment::Vertical,
-    layout_content: impl FnOnce(&Renderer, &layout::Limits) -> layout::Node,
-) -> layout::Node {
-    let limits = limits
-        .loose()
-        .max_width(max_width)
-        .max_height(max_height)
-        .width(width)
-        .height(height);
-
-    let mut content = layout_content(renderer, &limits.shrink(padding).loose());
-    let padding = padding.fit(content.size(), limits.max());
-    let size = limits
-        .shrink(padding)
-        .resolve(width, height, content.size());
-
-    content = content
-        .move_to(Point::new(padding.left, padding.top))
-        .align(
-            Alignment::from(horizontal_alignment),
-            Alignment::from(vertical_alignment),
-            size,
-        );
-
-    layout::Node::with_children(size.expand(padding), vec![content])
-}
-
-/// Draws the background of a [`Container`] given its [`Appearance`] and its `bounds`.
-pub fn draw_background<Renderer>(
-    renderer: &mut Renderer,
-    appearance: &Appearance,
-    bounds: Rectangle,
-) where
-    Renderer: iced_core::Renderer,
-{
-    if appearance.background.is_some() || appearance.border.width > 0.0 {
-        renderer.fill_quad(
-            renderer::Quad {
-                bounds,
-                border: appearance.border,
-                shadow: appearance.shadow,
-            },
-            appearance
-                .background
-                .unwrap_or(Background::Color(Color::TRANSPARENT)),
-        );
-    }
-}
-
-/// The identifier of a [`Container`].
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Id(widget::Id);
-
-impl Id {
-    /// Creates a custom [`Id`].
-    pub fn new(id: impl Into<std::borrow::Cow<'static, str>>) -> Self {
-        Self(widget::Id::new(id))
-    }
-
-    /// Creates a unique [`Id`].
-    ///
-    /// This function produces a different [`Id`] every time it is called.
-    #[must_use]
-    pub fn unique() -> Self {
-        Self(widget::Id::unique())
-    }
-}
-
-impl From<Id> for widget::Id {
-    fn from(id: Id) -> Self {
-        id.0
-    }
-}
diff --git a/src/widget/cosmic_button.rs b/src/widget/cosmic_button.rs
deleted file mode 100644
index afd6e99..0000000
--- a/src/widget/cosmic_button.rs
+++ /dev/null
@@ -1,780 +0,0 @@
-//! Allow your users to perform actions by pressing a button.
-//!
-//! A [`Button`] has some local [`State`].
-use cosmic::iced_core::gradient::{ColorStop, Linear};
-use cosmic::iced_core::keyboard::key::Named;
-use cosmic::iced_runtime::core::widget::Id;
-use cosmic::iced_runtime::{keyboard, Command};
-
-use crate::utils::static_array_from_iter;
-use crate::widget::StyleType;
-use cosmic::iced_core::event::{self, Event};
-use cosmic::iced_core::renderer;
-use cosmic::iced_core::touch;
-use cosmic::iced_core::widget::tree::{self, Tree};
-use cosmic::iced_core::widget::Operation;
-use cosmic::iced_core::{layout, Gradient};
-use cosmic::iced_core::{mouse, Radians};
-use cosmic::iced_core::{overlay, Border};
-use cosmic::iced_core::{
-    Background, Clipboard, Color, Element, Layout, Length, Padding, Point, Rectangle, Shell,
-    Vector, Widget,
-};
-use cosmic::iced_renderer::core::widget::{operation, OperationOutputWrapper};
-use cosmic::widget::button::{Appearance, StyleSheet};
-
-// TODO update to match libcosmic implementation
-
-/// A generic widget that produces a message when pressed.
-#[allow(missing_debug_implementations)]
-pub struct Button<'a, Message, Theme, Renderer = cosmic::Renderer>
-where
-    Renderer: cosmic::iced_core::Renderer,
-    Theme: StyleSheet,
-{
-    id: Id,
-    #[cfg(feature = "a11y")]
-    name: Option<Cow<'a, str>>,
-    #[cfg(feature = "a11y")]
-    description: Option<iced_accessibility::Description<'a>>,
-    #[cfg(feature = "a11y")]
-    label: Option<Vec<iced_accessibility::accesskit::NodeId>>,
-    content: Element<'a, Message, Theme, Renderer>,
-    on_press: Option<Message>,
-    width: Length,
-    height: Length,
-    padding: Padding,
-    style: StyleType<<Theme as StyleSheet>::Style>,
-}
-
-impl<'a, Message, Theme, Renderer> Button<'a, Message, Theme, Renderer>
-where
-    Renderer: cosmic::iced_core::Renderer,
-    Theme: StyleSheet,
-{
-    /// Creates a new [`Button`] with the given content.
-    pub fn new(content: impl Into<Element<'a, Message, Theme, Renderer>>) -> Self {
-        Button {
-            id: Id::unique(),
-            #[cfg(feature = "a11y")]
-            name: None,
-            #[cfg(feature = "a11y")]
-            description: None,
-            #[cfg(feature = "a11y")]
-            label: None,
-            content: content.into(),
-            on_press: None,
-            width: Length::Shrink,
-            height: Length::Shrink,
-            padding: Padding::new(5.0),
-            style: StyleType::Static(<Theme as StyleSheet>::Style::default()),
-        }
-    }
-
-    /// Sets the width of the [`Button`].
-    pub fn width(mut self, width: impl Into<Length>) -> Self {
-        self.width = width.into();
-        self
-    }
-
-    /// Sets the height of the [`Button`].
-    pub fn height(mut self, height: impl Into<Length>) -> Self {
-        self.height = height.into();
-        self
-    }
-
-    /// Sets the [`Padding`] of the [`Button`].
-    pub fn padding<P: Into<Padding>>(mut self, padding: P) -> Self {
-        self.padding = padding.into();
-        self
-    }
-
-    /// Sets the message that will be produced when the [`Button`] is pressed.
-    ///
-    /// Unless `on_press` is called, the [`Button`] will be disabled.
-    pub fn on_press(mut self, msg: Message) -> Self {
-        self.on_press = Some(msg);
-        self
-    }
-
-    /// Sets the style variant of this [`Button`].
-    pub fn style(mut self, style: <Theme as StyleSheet>::Style) -> Self {
-        self.style = StyleType::Static(style);
-        self
-    }
-
-    /// Sets the animatable style variant of this [`Button`].
-    pub fn blend_style(
-        mut self,
-        style1: <Theme as StyleSheet>::Style,
-        style2: <Theme as StyleSheet>::Style,
-        percent: f32,
-    ) -> Self {
-        self.style = StyleType::Blend(style1, style2, percent);
-        self
-    }
-
-    /// Sets the [`Id`] of the [`Button`].
-    pub fn id(mut self, id: Id) -> Self {
-        self.id = id;
-        self
-    }
-
-    #[cfg(feature = "a11y")]
-    /// Sets the name of the [`Button`].
-    pub fn name(mut self, name: impl Into<Cow<'a, str>>) -> Self {
-        self.name = Some(name.into());
-        self
-    }
-
-    #[cfg(feature = "a11y")]
-    /// Sets the description of the [`Button`].
-    pub fn description_widget<T: iced_accessibility::Describes>(mut self, description: &T) -> Self {
-        self.description = Some(iced_accessibility::Description::Id(
-            description.description(),
-        ));
-        self
-    }
-
-    #[cfg(feature = "a11y")]
-    /// Sets the description of the [`Button`].
-    pub fn description(mut self, description: impl Into<Cow<'a, str>>) -> Self {
-        self.description = Some(iced_accessibility::Description::Text(description.into()));
-        self
-    }
-
-    #[cfg(feature = "a11y")]
-    /// Sets the label of the [`Button`].
-    pub fn label(mut self, label: &dyn iced_accessibility::Labels) -> Self {
-        self.label = Some(label.label().into_iter().map(|l| l.into()).collect());
-        self
-    }
-}
-
-impl<'a, Message, Theme, Renderer> Widget<Message, Theme, Renderer>
-    for Button<'a, Message, Theme, Renderer>
-where
-    Message: 'a + Clone,
-    Renderer: 'a + cosmic::iced_core::Renderer,
-    Theme: StyleSheet,
-{
-    fn tag(&self) -> tree::Tag {
-        tree::Tag::of::<State>()
-    }
-
-    fn state(&self) -> tree::State {
-        tree::State::new(State::new())
-    }
-
-    fn children(&self) -> Vec<Tree> {
-        vec![Tree::new(&self.content)]
-    }
-
-    fn diff(&mut self, tree: &mut Tree) {
-        tree.diff_children(std::slice::from_mut(&mut self.content))
-    }
-
-    fn size(&self) -> cosmic::iced_core::Size<Length> {
-        cosmic::iced_core::Size::new(self.width, self.height)
-    }
-
-    fn layout(
-        &self,
-        tree: &mut Tree,
-        renderer: &Renderer,
-        limits: &layout::Limits,
-    ) -> layout::Node {
-        layout(
-            renderer,
-            limits,
-            self.width,
-            self.height,
-            self.padding,
-            |renderer, limits| {
-                self.content
-                    .as_widget()
-                    .layout(&mut tree.children[0], renderer, limits)
-            },
-        )
-    }
-
-    fn operate(
-        &self,
-        tree: &mut Tree,
-        layout: Layout<'_>,
-        renderer: &Renderer,
-        operation: &mut dyn Operation<OperationOutputWrapper<Message>>,
-    ) {
-        operation.container(None, layout.bounds(), &mut |operation| {
-            self.content.as_widget().operate(
-                &mut tree.children[0],
-                layout.children().next().unwrap(),
-                renderer,
-                operation,
-            );
-        });
-        let state = tree.state.downcast_mut::<State>();
-        operation.focusable(state, Some(&self.id));
-    }
-
-    fn on_event(
-        &mut self,
-        tree: &mut Tree,
-        event: Event,
-        layout: Layout<'_>,
-        cursor_position: mouse::Cursor,
-        renderer: &Renderer,
-        clipboard: &mut dyn Clipboard,
-        shell: &mut Shell<'_, Message>,
-        _viewport: &Rectangle,
-    ) -> event::Status {
-        if let event::Status::Captured = self.content.as_widget_mut().on_event(
-            &mut tree.children[0],
-            event.clone(),
-            layout.children().next().unwrap(),
-            cursor_position,
-            renderer,
-            clipboard,
-            shell,
-            _viewport,
-        ) {
-            return event::Status::Captured;
-        }
-
-        update(
-            self.id.clone(),
-            event,
-            layout,
-            cursor_position,
-            shell,
-            &self.on_press,
-            || tree.state.downcast_mut::<State>(),
-        )
-    }
-
-    fn draw(
-        &self,
-        tree: &Tree,
-        renderer: &mut Renderer,
-        theme: &Theme,
-        style: &renderer::Style,
-        layout: Layout<'_>,
-        cursor_position: mouse::Cursor,
-        _viewport: &Rectangle,
-    ) {
-        let bounds = layout.bounds();
-        let content_layout = layout.children().next().unwrap();
-
-        let styling = draw::<_, Theme>(
-            renderer,
-            bounds,
-            cursor_position,
-            self.on_press.is_some(),
-            theme,
-            &self.style,
-            || tree.state.downcast_ref::<State>(),
-        );
-
-        self.content.as_widget().draw(
-            &tree.children[0],
-            renderer,
-            theme,
-            &renderer::Style {
-                #[cfg(feature = "libcosmic")]
-                icon_color: styling.icon_color.unwrap_or(style.icon_color),
-                text_color: styling.text_color.unwrap_or(style.text_color),
-                scale_factor: style.scale_factor,
-            },
-            content_layout,
-            cursor_position,
-            &bounds,
-        );
-    }
-
-    fn mouse_interaction(
-        &self,
-        _tree: &Tree,
-        layout: Layout<'_>,
-        cursor_position: mouse::Cursor,
-        _viewport: &Rectangle,
-        _renderer: &Renderer,
-    ) -> mouse::Interaction {
-        mouse_interaction(layout, cursor_position, self.on_press.is_some())
-    }
-
-    fn overlay<'b>(
-        &'b mut self,
-        tree: &'b mut Tree,
-        layout: Layout<'_>,
-        renderer: &Renderer,
-    ) -> Option<overlay::Element<'b, Message, Theme, Renderer>> {
-        self.content.as_widget_mut().overlay(
-            &mut tree.children[0],
-            layout.children().next().unwrap(),
-            renderer,
-        )
-    }
-
-    #[cfg(feature = "a11y")]
-    /// get the a11y nodes for the widget
-    fn a11y_nodes(
-        &self,
-        layout: Layout<'_>,
-        state: &Tree,
-        p: Point,
-    ) -> iced_accessibility::A11yTree {
-        use iced_accessibility::{
-            accesskit::{Action, DefaultActionVerb, NodeBuilder, NodeId, Rect, Role},
-            A11yNode, A11yTree,
-        };
-
-        let child_layout = layout.children().next().unwrap();
-        let child_tree = &state.children[0];
-        let child_tree = self
-            .content
-            .as_widget()
-            .a11y_nodes(child_layout, &child_tree, p);
-
-        let Rectangle {
-            x,
-            y,
-            width,
-            height,
-        } = layout.bounds();
-        let bounds = Rect::new(x as f64, y as f64, (x + width) as f64, (y + height) as f64);
-        let is_hovered = state.state.downcast_ref::<State>().is_hovered;
-
-        let mut node = NodeBuilder::new(Role::Button);
-        node.add_action(Action::Focus);
-        node.add_action(Action::Default);
-        node.set_bounds(bounds);
-        if let Some(name) = self.name.as_ref() {
-            node.set_name(name.clone());
-        }
-        match self.description.as_ref() {
-            Some(iced_accessibility::Description::Id(id)) => {
-                node.set_described_by(
-                    id.iter()
-                        .cloned()
-                        .map(|id| NodeId::from(id))
-                        .collect::<Vec<_>>(),
-                );
-            }
-            Some(iced_accessibility::Description::Text(text)) => {
-                node.set_description(text.clone());
-            }
-            None => {}
-        }
-
-        if let Some(label) = self.label.as_ref() {
-            node.set_labelled_by(label.clone());
-        }
-
-        if self.on_press.is_none() {
-            node.set_disabled()
-        }
-        if is_hovered {
-            node.set_hovered()
-        }
-        node.set_default_action_verb(DefaultActionVerb::Click);
-
-        A11yTree::node_with_child_tree(A11yNode::new(node, self.id.clone()), child_tree)
-    }
-
-    fn id(&self) -> Option<Id> {
-        Some(self.id.clone())
-    }
-
-    fn set_id(&mut self, id: Id) {
-        self.id = id;
-    }
-}
-
-impl<'a, Message, Theme, Renderer> From<Button<'a, Message, Theme, Renderer>>
-    for Element<'a, Message, Theme, Renderer>
-where
-    Message: Clone + 'a,
-    Renderer: cosmic::iced_core::Renderer + 'a,
-    Theme: StyleSheet + 'a,
-{
-    fn from(button: Button<'a, Message, Theme, Renderer>) -> Self {
-        Self::new(button)
-    }
-}
-
-/// The local state of a [`Button`].
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
-pub struct State {
-    is_hovered: bool,
-    is_pressed: bool,
-    is_focused: bool,
-}
-
-impl State {
-    /// Creates a new [`State`].
-    #[must_use]
-    pub fn new() -> State {
-        State::default()
-    }
-
-    /// Returns whether the [`Button`] is currently focused or not.
-    #[must_use]
-    pub fn is_focused(&self) -> bool {
-        self.is_focused
-    }
-
-    /// Returns whether the [`Button`] is currently hovered or not.
-    #[must_use]
-    pub fn is_hovered(&self) -> bool {
-        self.is_hovered
-    }
-
-    /// Focuses the [`Button`].
-    pub fn focus(&mut self) {
-        self.is_focused = true;
-    }
-
-    /// Unfocuses the [`Button`].
-    pub fn unfocus(&mut self) {
-        self.is_focused = false;
-    }
-}
-
-/// Processes the given [`Event`] and updates the [`State`] of a [`Button`]
-/// accordingly.
-pub fn update<'a, Message: Clone>(
-    _id: Id,
-    event: Event,
-    layout: Layout<'_>,
-    cursor_position: mouse::Cursor,
-    shell: &mut Shell<'_, Message>,
-    on_press: &Option<Message>,
-    state: impl FnOnce() -> &'a mut State,
-) -> event::Status {
-    match event {
-        Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left))
-        | Event::Touch(touch::Event::FingerPressed { .. }) => {
-            if on_press.is_some() {
-                let bounds = layout.bounds();
-
-                if cursor_position.is_over(bounds) {
-                    let state = state();
-
-                    state.is_pressed = true;
-
-                    return event::Status::Captured;
-                }
-            }
-        }
-        Event::Mouse(mouse::Event::ButtonReleased(mouse::Button::Left))
-        | Event::Touch(touch::Event::FingerLifted { .. }) => {
-            if let Some(on_press) = on_press.clone() {
-                let state = state();
-
-                if state.is_pressed {
-                    state.is_pressed = false;
-
-                    let bounds = layout.bounds();
-
-                    if cursor_position.is_over(bounds) {
-                        shell.publish(on_press);
-                    }
-
-                    return event::Status::Captured;
-                }
-            }
-        }
-        #[cfg(feature = "a11y")]
-        Event::A11y(event_id, iced_accessibility::accesskit::ActionRequest { action, .. }) => {
-            let state = state();
-            if let Some(Some(on_press)) = (id == event_id
-                && matches!(action, iced_accessibility::accesskit::Action::Default))
-            .then(|| on_press.clone())
-            {
-                state.is_pressed = false;
-                shell.publish(on_press);
-            }
-            return event::Status::Captured;
-        }
-        Event::Keyboard(keyboard::Event::KeyPressed { key, .. }) => {
-            if let Some(on_press) = on_press.clone() {
-                let state = state();
-                if state.is_focused && key == keyboard::Key::Named(Named::Enter) {
-                    state.is_pressed = true;
-                    shell.publish(on_press);
-                    return event::Status::Captured;
-                }
-            }
-        }
-        Event::Touch(touch::Event::FingerLost { .. }) => {
-            let state = state();
-            state.is_hovered = false;
-            state.is_pressed = false;
-        }
-        _ => {}
-    }
-
-    event::Status::Ignored
-}
-
-/// Draws a [`Button`].
-pub fn draw<'a, Renderer: cosmic::iced_core::Renderer, Theme: StyleSheet>(
-    renderer: &mut Renderer,
-    bounds: Rectangle,
-    cursor_position: mouse::Cursor,
-    is_enabled: bool,
-    style_sheet: &dyn StyleSheet<Style = <Theme as StyleSheet>::Style>,
-    style: &StyleType<<Theme as StyleSheet>::Style>,
-    state: impl FnOnce() -> &'a State,
-) -> Appearance {
-    let is_mouse_over = cursor_position.is_over(bounds);
-
-    let state = state();
-
-    let focused = state.is_focused;
-
-    let styling = match style {
-        StyleType::Static(style) => {
-            if !is_enabled {
-                style_sheet.disabled(style)
-            } else if is_mouse_over {
-                if state.is_pressed {
-                    style_sheet.pressed(focused, false, style)
-                } else {
-                    style_sheet.hovered(focused, focused, style)
-                }
-            } else {
-                style_sheet.active(focused, focused, style)
-            }
-        }
-        StyleType::Blend(style1, style2, percent) => {
-            let (one, two) = if !is_enabled {
-                (style_sheet.disabled(style1), style_sheet.disabled(style2))
-            } else if is_mouse_over {
-                if state.is_pressed {
-                    (
-                        style_sheet.pressed(focused, false, style1),
-                        style_sheet.pressed(focused, false, style2),
-                    )
-                } else {
-                    (
-                        style_sheet.hovered(focused, false, style1),
-                        style_sheet.hovered(focused, false, style2),
-                    )
-                }
-            } else {
-                (
-                    style_sheet.active(focused, false, style1),
-                    style_sheet.active(focused, false, style2),
-                )
-            };
-
-            blend_appearances(one, two, *percent)
-        }
-    };
-
-    if styling.background.is_some() || styling.border_width > 0.0 {
-        if styling.shadow_offset != Vector::default() {
-            // TODO: Implement proper shadow support
-            renderer.fill_quad(
-                renderer::Quad {
-                    bounds: Rectangle {
-                        x: bounds.x + styling.shadow_offset.x,
-                        y: bounds.y + styling.shadow_offset.y,
-                        ..bounds
-                    },
-                    border: Border {
-                        radius: styling.border_radius,
-                        ..Default::default()
-                    },
-                    shadow: Default::default(),
-                },
-                Background::Color([0.0, 0.0, 0.0, 0.5].into()),
-            );
-        }
-
-        renderer.fill_quad(
-            renderer::Quad {
-                bounds,
-                border: Border {
-                    radius: styling.border_radius,
-                    width: styling.border_width,
-                    color: styling.border_color,
-                },
-                shadow: Default::default(),
-            },
-            styling
-                .background
-                .unwrap_or(Background::Color(Color::TRANSPARENT)),
-        );
-    }
-
-    styling
-}
-
-/// Computes the layout of a [`Button`].
-pub fn layout<Renderer>(
-    renderer: &Renderer,
-    limits: &layout::Limits,
-    width: Length,
-    height: Length,
-    padding: Padding,
-    layout_content: impl FnOnce(&Renderer, &layout::Limits) -> layout::Node,
-) -> layout::Node {
-    let limits = limits.width(width).height(height);
-
-    let mut content = layout_content(renderer, &limits.shrink(padding));
-    let padding = padding.fit(content.size(), limits.max());
-    let size = limits
-        .shrink(padding)
-        .resolve(width, height, content.size())
-        .expand(padding);
-
-    content = content.move_to(Point::new(padding.left, padding.top));
-
-    layout::Node::with_children(size, vec![content])
-}
-
-/// Returns the [`mouse::Interaction`] of a [`Button`].
-#[must_use]
-pub fn mouse_interaction(
-    layout: Layout<'_>,
-    cursor_position: mouse::Cursor,
-    is_enabled: bool,
-) -> mouse::Interaction {
-    let is_mouse_over = cursor_position.is_over(layout.bounds());
-
-    if is_mouse_over && is_enabled {
-        mouse::Interaction::Pointer
-    } else {
-        mouse::Interaction::default()
-    }
-}
-
-/// Produces a [`Command`] that focuses the [`Button`] with the given [`Id`].
-pub fn focus<Message: 'static>(id: Id) -> Command<Message> {
-    Command::widget(operation::focusable::focus(id))
-}
-
-impl operation::Focusable for State {
-    fn is_focused(&self) -> bool {
-        State::is_focused(self)
-    }
-
-    fn focus(&mut self) {
-        State::focus(self)
-    }
-
-    fn unfocus(&mut self) {
-        State::unfocus(self)
-    }
-}
-
-fn blend_appearances(one: Appearance, mut two: Appearance, percent: f32) -> Appearance {
-    use crate::lerp;
-
-    // shadow offet
-    let x1 = one.shadow_offset.x;
-    let y1 = one.shadow_offset.y;
-    let x2 = two.shadow_offset.x;
-    let y2 = two.shadow_offset.y;
-
-    // background
-    let background_mix: Background = match (one.background, two.background) {
-        (Some(Background::Color(c1)), Some(Background::Color(c2))) => {
-            Background::from(Color::from(static_array_from_iter::<f32, 4>(
-                c1.into_linear()
-                    .iter()
-                    .zip(c2.into_linear().iter())
-                    .map(|(o, t)| lerp(*o, *t, percent)),
-            )))
-        }
-        (
-            Some(Background::Gradient(Gradient::Linear(l1))),
-            Some(Background::Gradient(Gradient::Linear(l2))),
-        ) => {
-            let angle = lerp(l1.angle.0, l2.angle.0, percent);
-            let stops = l1
-                .stops
-                .iter()
-                .zip(l2.stops.iter())
-                .map(|(o, t)| match (o, t) {
-                    (
-                        Some(ColorStop {
-                            offset: o1,
-                            color: c1,
-                        }),
-                        Some(ColorStop {
-                            color: c2,
-                            offset: o2,
-                        }),
-                    ) => Some(ColorStop {
-                        color: static_array_from_iter::<f32, 4>(
-                            c1.into_linear()
-                                .iter()
-                                .zip(c2.into_linear().iter())
-                                .map(|(o, t)| lerp(*o, *t, percent)),
-                        )
-                        .into(),
-                        offset: lerp(*o1, *o2, percent),
-                    }),
-                    (a, b) => *if percent < 0.5 { a } else { b },
-                });
-            Background::Gradient(
-                Linear {
-                    angle: Radians(angle),
-                    stops: static_array_from_iter(stops),
-                }
-                .into(),
-            )
-        }
-        _ => Background::from(Color::from([0.0, 0.0, 0.0, 0.0])),
-    };
-
-    // boarder color
-    let border_color = static_array_from_iter::<f32, 4>(
-        one.border_color
-            .into_linear()
-            .iter()
-            .zip(two.border_color.into_linear().iter())
-            .map(|(o, t)| lerp(*o, *t, percent)),
-    );
-
-    // text
-    let text = one
-        .text_color
-        .iter()
-        .zip(two.text_color.iter())
-        .map(|(c1, c2)| {
-            static_array_from_iter::<f32, 4>(
-                c1.into_linear()
-                    .iter()
-                    .zip(c2.into_linear().iter())
-                    .map(|(o, t)| lerp(*o, *t, percent)),
-            )
-        })
-        .next()
-        .or_else(|| {
-            one.text_color
-                .or(two.text_color)
-                .map(|c| static_array_from_iter::<f32, 4>(c.into_linear().into_iter()))
-        });
-
-    let br1: [f32; 4] = one.border_radius.into();
-    let br2: [f32; 4] = two.border_radius.into();
-
-    let br = [
-        lerp(br1[0], br2[0], percent),
-        lerp(br1[1], br2[1], percent),
-        lerp(br1[2], br2[2], percent),
-        lerp(br1[3], br2[3], percent),
-    ];
-
-    two.shadow_offset = Vector::new(lerp(x1, x2, percent), lerp(y1, y2, percent));
-    two.background = Some(background_mix);
-    two.border_radius = br.into();
-    two.border_width = lerp(one.border_width, two.border_width, percent);
-    two.border_color = border_color.into();
-    two.text_color = text.map(|c| c.into());
-    two
-}
diff --git a/src/widget/cosmic_container.rs b/src/widget/cosmic_container.rs
deleted file mode 100644
index 91a5bdf..0000000
--- a/src/widget/cosmic_container.rs
+++ /dev/null
@@ -1,482 +0,0 @@
-//! Decorate content and apply alignment.
-use cosmic::cosmic_theme::LayeredTheme;
-use cosmic::iced_core::alignment::{self, Alignment};
-use cosmic::iced_core::event::{self, Event};
-use cosmic::iced_core::gradient::{ColorStop, Linear};
-use cosmic::iced_core::renderer;
-use cosmic::iced_core::widget::{Id, Operation, Tree};
-use cosmic::iced_core::{layout, Gradient};
-use cosmic::iced_core::{mouse, Radians};
-use cosmic::iced_core::{overlay, Border};
-use cosmic::iced_core::{
-    Background, Clipboard, Color, Element, Layout, Length, Padding, Pixels, Point, Rectangle,
-    Shell, Widget,
-};
-use cosmic::iced_style;
-
-use crate::utils::static_array_from_iter;
-use crate::widget::StyleType;
-
-use cosmic::iced_renderer::core::widget::OperationOutputWrapper;
-pub use cosmic::iced_style::container::{Appearance, StyleSheet};
-
-/// An element decorating some content.
-///
-/// It is normally used for alignment purposes.
-#[allow(missing_debug_implementations)]
-pub struct Container<'a, Message, Theme, Renderer = cosmic::iced::Renderer>
-where
-    Renderer: cosmic::iced_core::Renderer,
-    Theme: iced_style::container::StyleSheet + LayeredTheme,
-    <Theme as iced_style::container::StyleSheet>::Style: From<cosmic::theme::Container>,
-{
-    id: Option<Id>,
-    padding: Padding,
-    width: Length,
-    height: Length,
-    max_width: f32,
-    max_height: f32,
-    horizontal_alignment: alignment::Horizontal,
-    vertical_alignment: alignment::Vertical,
-    style: StyleType<<Theme as StyleSheet>::Style>,
-    content: Element<'a, Message, Theme, Renderer>,
-}
-
-impl<'a, Message, Theme, Renderer> Container<'a, Message, Theme, Renderer>
-where
-    Renderer: cosmic::iced_core::Renderer,
-    Theme: iced_style::container::StyleSheet + LayeredTheme,
-    <Theme as iced_style::container::StyleSheet>::Style: From<cosmic::theme::Container>,
-{
-    /// Creates an empty [`Container`].
-    pub fn new<T>(content: T) -> Self
-    where
-        T: Into<Element<'a, Message, Theme, Renderer>>,
-    {
-        Container {
-            id: None,
-            padding: Padding::ZERO,
-            width: Length::Shrink,
-            height: Length::Shrink,
-            max_width: f32::INFINITY,
-            max_height: f32::INFINITY,
-            horizontal_alignment: alignment::Horizontal::Left,
-            vertical_alignment: alignment::Vertical::Top,
-            style: StyleType::Static(Default::default()),
-            content: content.into(),
-        }
-    }
-
-    /// Sets the [`Id`] of the [`Container`].
-    pub fn id(mut self, id: Id) -> Self {
-        self.id = Some(id);
-        self
-    }
-
-    /// Sets the [`Padding`] of the [`Container`].
-    pub fn padding<P: Into<Padding>>(mut self, padding: P) -> Self {
-        self.padding = padding.into();
-        self
-    }
-
-    /// Sets the width of the [`Container`].
-    pub fn width(mut self, width: impl Into<Length>) -> Self {
-        self.width = width.into();
-        self
-    }
-
-    /// Sets the height of the [`Container`].
-    pub fn height(mut self, height: impl Into<Length>) -> Self {
-        self.height = height.into();
-        self
-    }
-
-    /// Sets the maximum width of the [`Container`].
-    pub fn max_width(mut self, max_width: impl Into<Pixels>) -> Self {
-        self.max_width = max_width.into().0;
-        self
-    }
-
-    /// Sets the maximum height of the [`Container`].
-    pub fn max_height(mut self, max_height: impl Into<Pixels>) -> Self {
-        self.max_height = max_height.into().0;
-        self
-    }
-
-    /// Sets the content alignment for the horizontal axis of the [`Container`].
-    pub fn align_x(mut self, alignment: alignment::Horizontal) -> Self {
-        self.horizontal_alignment = alignment;
-        self
-    }
-
-    /// Sets the content alignment for the vertical axis of the [`Container`].
-    pub fn align_y(mut self, alignment: alignment::Vertical) -> Self {
-        self.vertical_alignment = alignment;
-        self
-    }
-
-    /// Centers the contents in the horizontal axis of the [`Container`].
-    pub fn center_x(mut self) -> Self {
-        self.horizontal_alignment = alignment::Horizontal::Center;
-        self
-    }
-
-    /// Centers the contents in the vertical axis of the [`Container`].
-    pub fn center_y(mut self) -> Self {
-        self.vertical_alignment = alignment::Vertical::Center;
-        self
-    }
-
-    /// Sets the style of the [`Container`].
-    pub fn style(mut self, style: impl Into<<Theme as StyleSheet>::Style>) -> Self {
-        self.style = StyleType::Static(style.into());
-        self
-    }
-
-    /// Sets the animatable style variant of this [`Container`].
-    pub fn blend_style(
-        mut self,
-        style1: <Theme as StyleSheet>::Style,
-        style2: <Theme as StyleSheet>::Style,
-        percent: f32,
-    ) -> Self {
-        self.style = StyleType::Blend(style1, style2, percent);
-        self
-    }
-}
-
-impl<'a, Message, Theme, Renderer> Widget<Message, Theme, Renderer>
-    for Container<'a, Message, Theme, Renderer>
-where
-    Renderer: cosmic::iced_core::Renderer,
-    Theme: iced_style::container::StyleSheet + LayeredTheme,
-    <Theme as iced_style::container::StyleSheet>::Style: From<cosmic::theme::Container>,
-{
-    fn children(&self) -> Vec<Tree> {
-        vec![Tree::new(&self.content)]
-    }
-
-    fn diff(&mut self, tree: &mut Tree) {
-        tree.diff_children(std::slice::from_mut(&mut self.content))
-    }
-
-    fn size(&self) -> cosmic::iced_core::Size<Length> {
-        cosmic::iced_core::Size::new(self.width, self.height)
-    }
-
-    fn layout(
-        &self,
-        tree: &mut Tree,
-        renderer: &Renderer,
-        limits: &layout::Limits,
-    ) -> layout::Node {
-        layout(
-            renderer,
-            limits,
-            self.width,
-            self.height,
-            self.max_width,
-            self.max_height,
-            self.padding,
-            self.horizontal_alignment,
-            self.vertical_alignment,
-            |renderer, limits| {
-                self.content
-                    .as_widget()
-                    .layout(&mut tree.children[0], renderer, limits)
-            },
-        )
-    }
-
-    fn operate(
-        &self,
-        tree: &mut Tree,
-        layout: Layout<'_>,
-        renderer: &Renderer,
-        operation: &mut dyn Operation<OperationOutputWrapper<Message>>,
-    ) {
-        operation.container(self.id.as_ref(), layout.bounds(), &mut |operation| {
-            self.content.as_widget().operate(
-                &mut tree.children[0],
-                layout.children().next().unwrap(),
-                renderer,
-                operation,
-            );
-        });
-    }
-
-    fn on_event(
-        &mut self,
-        tree: &mut Tree,
-        event: Event,
-        layout: Layout<'_>,
-        cursor_position: mouse::Cursor,
-        renderer: &Renderer,
-        clipboard: &mut dyn Clipboard,
-        shell: &mut Shell<'_, Message>,
-        viewport: &Rectangle,
-    ) -> event::Status {
-        self.content.as_widget_mut().on_event(
-            &mut tree.children[0],
-            event,
-            layout.children().next().unwrap(),
-            cursor_position,
-            renderer,
-            clipboard,
-            shell,
-            viewport,
-        )
-    }
-
-    fn mouse_interaction(
-        &self,
-        tree: &Tree,
-        layout: Layout<'_>,
-        cursor_position: mouse::Cursor,
-        viewport: &Rectangle,
-        renderer: &Renderer,
-    ) -> mouse::Interaction {
-        self.content.as_widget().mouse_interaction(
-            &tree.children[0],
-            layout.children().next().unwrap(),
-            cursor_position,
-            viewport,
-            renderer,
-        )
-    }
-
-    fn draw(
-        &self,
-        tree: &Tree,
-        renderer: &mut Renderer,
-        theme: &Theme,
-        renderer_style: &renderer::Style,
-        layout: Layout<'_>,
-        cursor_position: mouse::Cursor,
-        viewport: &Rectangle,
-    ) {
-        let style = match &self.style {
-            StyleType::Static(style) => theme.appearance(style),
-            StyleType::Blend(one, two, percent) => {
-                blend_appearances(theme.appearance(one), theme.appearance(two), *percent)
-            }
-        };
-
-        draw_background(renderer, &style, layout.bounds());
-
-        self.content.as_widget().draw(
-            &tree.children[0],
-            renderer,
-            theme,
-            &renderer::Style {
-                icon_color: style.icon_color.unwrap_or(renderer_style.icon_color),
-                text_color: style.text_color.unwrap_or(renderer_style.text_color),
-                scale_factor: renderer_style.scale_factor,
-            },
-            layout.children().next().unwrap(),
-            cursor_position,
-            viewport,
-        );
-    }
-
-    fn overlay<'b>(
-        &'b mut self,
-        tree: &'b mut Tree,
-        layout: Layout<'_>,
-        renderer: &Renderer,
-    ) -> Option<overlay::Element<'b, Message, Theme, Renderer>> {
-        self.content.as_widget_mut().overlay(
-            &mut tree.children[0],
-            layout.children().next().unwrap(),
-            renderer,
-        )
-    }
-
-    #[cfg(feature = "a11y")]
-    /// get the a11y nodes for the widget
-    fn a11y_nodes(
-        &self,
-        layout: Layout<'_>,
-        state: &Tree,
-        p: Point,
-    ) -> iced_accessibility::A11yTree {
-        let c_layout = layout.children().next().unwrap();
-        let c_state = &state.children[0];
-        self.content.as_widget().a11y_nodes(c_layout, c_state, p)
-    }
-}
-
-impl<'a, Message, Theme, Renderer> From<Container<'a, Message, Theme, Renderer>>
-    for Element<'a, Message, Theme, Renderer>
-where
-    Message: 'a,
-    Renderer: 'a + cosmic::iced_core::Renderer,
-    Theme: iced_style::container::StyleSheet + LayeredTheme + 'a,
-    <Theme as iced_style::container::StyleSheet>::Style: From<cosmic::theme::Container>,
-{
-    fn from(
-        column: Container<'a, Message, Theme, Renderer>,
-    ) -> Element<'a, Message, Theme, Renderer> {
-        Element::new(column)
-    }
-}
-
-/// Computes the layout of a [`Container`].
-pub fn layout<Renderer>(
-    renderer: &Renderer,
-    limits: &layout::Limits,
-    width: Length,
-    height: Length,
-    max_width: f32,
-    max_height: f32,
-    padding: Padding,
-    horizontal_alignment: alignment::Horizontal,
-    vertical_alignment: alignment::Vertical,
-    layout_content: impl FnOnce(&Renderer, &layout::Limits) -> layout::Node,
-) -> layout::Node {
-    let limits = limits
-        .loose()
-        .max_width(max_width)
-        .max_height(max_height)
-        .width(width)
-        .height(height);
-
-    let mut content = layout_content(renderer, &limits.shrink(padding).loose());
-    let padding = padding.fit(content.size(), limits.max());
-    let size = limits
-        .shrink(padding)
-        .resolve(width, height, content.size());
-
-    content = content
-        .move_to(Point::new(padding.left, padding.top))
-        .align(
-            Alignment::from(horizontal_alignment),
-            Alignment::from(vertical_alignment),
-            size,
-        );
-
-    layout::Node::with_children(size.expand(padding), vec![content])
-}
-
-/// Draws the background of a [`Container`] given its [`Appearance`] and its `bounds`.
-pub fn draw_background<Renderer>(
-    renderer: &mut Renderer,
-    appearance: &Appearance,
-    bounds: Rectangle,
-) where
-    Renderer: cosmic::iced_core::Renderer,
-{
-    if appearance.background.is_some() || appearance.border.width > 0.0 {
-        renderer.fill_quad(
-            renderer::Quad {
-                bounds,
-                border: Border {
-                    width: appearance.border.width,
-                    color: appearance.border.color,
-                    radius: appearance.border.radius,
-                },
-                shadow: appearance.shadow,
-            },
-            appearance
-                .background
-                .unwrap_or(Background::Color(Color::TRANSPARENT)),
-        );
-    }
-}
-
-fn blend_appearances(
-    one: cosmic::iced_style::container::Appearance,
-    mut two: cosmic::iced_style::container::Appearance,
-    percent: f32,
-) -> cosmic::iced_style::container::Appearance {
-    use crate::lerp;
-
-    // background
-    let background_mix: Background = match (one.background, two.background) {
-        (Some(Background::Color(c1)), Some(Background::Color(c2))) => {
-            Background::from(Color::from(static_array_from_iter::<f32, 4>(
-                c1.into_linear()
-                    .iter()
-                    .zip(c2.into_linear().iter())
-                    .map(|(o, t)| lerp(*o, *t, percent)),
-            )))
-        }
-        (
-            Some(Background::Gradient(Gradient::Linear(l1))),
-            Some(Background::Gradient(Gradient::Linear(l2))),
-        ) => {
-            let angle = lerp(l1.angle.0, l2.angle.0, percent);
-            let stops = l1
-                .stops
-                .iter()
-                .zip(l2.stops.iter())
-                .map(|(o, t)| match (o, t) {
-                    (
-                        Some(ColorStop {
-                            offset: o1,
-                            color: c1,
-                        }),
-                        Some(ColorStop {
-                            color: c2,
-                            offset: o2,
-                        }),
-                    ) => Some(ColorStop {
-                        color: static_array_from_iter::<f32, 4>(
-                            c1.into_linear()
-                                .iter()
-                                .zip(c2.into_linear().iter())
-                                .map(|(o, t)| lerp(*o, *t, percent)),
-                        )
-                        .into(),
-                        offset: lerp(*o1, *o2, percent),
-                    }),
-                    (a, b) => *if percent < 0.5 { a } else { b },
-                });
-            Background::Gradient(
-                Linear {
-                    angle: Radians(angle),
-                    stops: static_array_from_iter(stops),
-                }
-                .into(),
-            )
-        }
-        _ => Background::from(Color::from([0.0, 0.0, 0.0, 0.0])),
-    };
-    // boarder color
-    let border_color = static_array_from_iter::<f32, 4>(
-        one.border
-            .color
-            .into_linear()
-            .iter()
-            .zip(two.border.color.into_linear().iter())
-            .map(|(o, t)| lerp(*o, *t, percent)),
-    );
-
-    // text
-    let text = one
-        .text_color
-        .map(|t| {
-            static_array_from_iter::<f32, 4>(
-                t.into_linear()
-                    .iter()
-                    .zip(two.text_color.unwrap_or(t).into_linear().iter())
-                    .map(|(o, t)| lerp(*o, *t, percent)),
-            )
-        })
-        .map(Into::<Color>::into);
-
-    let one_border_radius: [f32; 4] = one.border.radius.into();
-    let two_border_radius: [f32; 4] = two.border.radius.into();
-    two.background = Some(background_mix);
-    two.border.radius = [
-        lerp(one_border_radius[0], two_border_radius[0], percent),
-        lerp(one_border_radius[1], two_border_radius[1], percent),
-        lerp(one_border_radius[2], two_border_radius[2], percent),
-        lerp(one_border_radius[3], two_border_radius[3], percent),
-    ]
-    .into();
-    two.border.width = lerp(one.border.width, two.border.width, percent);
-    two.border.color = border_color.into();
-    two.text_color = text;
-    two
-}
diff --git a/src/widget/cosmic_toggler.rs b/src/widget/cosmic_toggler.rs
index a94d226..39b65cc 100644
--- a/src/widget/cosmic_toggler.rs
+++ b/src/widget/cosmic_toggler.rs
@@ -1,6 +1,6 @@
 //! Show toggle controls using togglers.
 
-use cosmic::iced_core::Border;
+use cosmic::{iced_core::Border, iced_widget::toggler::Status};
 use iced_core::{
     alignment, event, layout, mouse, renderer, text,
     widget::{self, tree, Tree},
@@ -9,16 +9,15 @@ use iced_core::{
 
 use crate::{
     chain, id, lerp,
-    reexports::{iced, iced_core, iced_style, iced_widget},
+    reexports::{iced, iced_core, iced_widget},
 };
-pub use cosmic::iced_style::toggler::{Appearance, StyleSheet};
+pub use cosmic::iced_widget::toggler::{Catalog, Style};
 
 /// A toggler widget.
 #[allow(missing_debug_implementations)]
-pub struct Toggler<'a, Message, Theme, Renderer>
+pub struct Toggler<'a, Message, Renderer>
 where
     Renderer: text::Renderer,
-    Theme: iced_style::toggler::StyleSheet,
 {
     id: id::Toggler,
     is_toggled: bool,
@@ -32,15 +31,13 @@ where
     text_shaping: text::Shaping,
     spacing: f32,
     font: Option<Renderer::Font>,
-    style: <Theme as StyleSheet>::Style,
     percent: f32,
     anim_multiplier: f32,
 }
 
-impl<'a, Message, Theme, Renderer> Toggler<'a, Message, Theme, Renderer>
+impl<'a, Message, Renderer> Toggler<'a, Message, Renderer>
 where
     Renderer: text::Renderer,
-    Theme: cosmic::iced_style::toggler::StyleSheet,
 {
     /// The default size of a [`Toggler`].
     pub const DEFAULT_SIZE: f32 = 24.0;
@@ -70,7 +67,6 @@ where
             text_shaping: text::Shaping::Advanced,
             spacing: 0.0,
             font: None,
-            style: Default::default(),
             percent: if is_toggled { 1.0 } else { 0.0 },
             anim_multiplier: 1.0,
         }
@@ -126,12 +122,6 @@ where
         self
     }
 
-    /// Sets the style of the [`Toggler`].
-    pub fn style(mut self, style: impl Into<<Theme as StyleSheet>::Style>) -> Self {
-        self.style = style.into();
-        self
-    }
-
     /// The percent completion of the toggler animation.
     /// This is indented to automated cosmic-time use, and shouldn't
     /// need to be called manually.
@@ -141,11 +131,10 @@ where
     }
 }
 
-impl<'a, Message, Theme, Renderer> Widget<Message, Theme, Renderer>
-    for Toggler<'a, Message, Theme, Renderer>
+impl<'a, Message, Renderer> Widget<Message, cosmic::Theme, Renderer>
+    for Toggler<'a, Message, Renderer>
 where
     Renderer: text::Renderer,
-    Theme: cosmic::iced_style::toggler::StyleSheet,
 {
     fn size(&self) -> Size<Length> {
         Size::new(self.width, Length::Shrink)
@@ -185,7 +174,7 @@ where
                         self.text_alignment,
                         alignment::Vertical::Top,
                         self.text_shaping,
-                        cosmic::iced_core::text::Wrap::default(),
+                        cosmic::iced_core::text::Wrapping::default(),
                     );
                     match self.width {
                         Length::Fill => {
@@ -259,30 +248,23 @@ where
         &self,
         tree: &Tree,
         renderer: &mut Renderer,
-        theme: &Theme,
+        theme: &cosmic::Theme,
         style: &renderer::Style,
         layout: Layout<'_>,
         cursor_position: mouse::Cursor,
         viewport: &Rectangle,
     ) {
-        /// Makes sure that the border radius of the toggler looks good at every size.
-        const BORDER_RADIUS_RATIO: f32 = 32.0 / 13.0;
-
-        /// The space ratio between the background Quad and the Toggler bounds, and
-        /// between the background Quad and foreground Quad.
-        const SPACE_RATIO: f32 = 0.05;
-
         let mut children = layout.children();
 
         if let Some(_label) = &self.label {
             let label_layout = children.next().unwrap();
-
+            let state: &iced_widget::text::State<Renderer::Paragraph> = tree.state.downcast_ref();
             iced_widget::text::draw(
                 renderer,
                 style,
                 label_layout,
-                tree.state.downcast_ref(),
-                iced_widget::text::Appearance::default(),
+                state.0.raw(),
+                iced_widget::text::Style::default(),
                 viewport,
             );
         }
@@ -292,19 +274,25 @@ where
 
         let is_mouse_over = cursor_position.is_over(bounds);
 
-        let style = if is_mouse_over {
-            blend_appearances(
-                theme.hovered(&self.style, false),
-                theme.hovered(&self.style, true),
-                self.percent,
-            )
-        } else {
-            blend_appearances(
-                theme.active(&self.style, false),
-                theme.active(&self.style, true),
-                self.percent,
-            )
-        };
+        let style = blend_appearances(
+            theme.style(
+                &(),
+                if is_mouse_over {
+                    Status::Hovered { is_toggled: false }
+                } else {
+                    Status::Active { is_toggled: false }
+                },
+            ),
+            theme.style(
+                &(),
+                if is_mouse_over {
+                    Status::Hovered { is_toggled: true }
+                } else {
+                    Status::Active { is_toggled: true }
+                },
+            ),
+            self.percent,
+        );
 
         let space = style.handle_margin;
 
@@ -354,21 +342,20 @@ where
     }
 }
 
-impl<'a, Message, Theme, Renderer> From<Toggler<'a, Message, Theme, Renderer>>
-    for Element<'a, Message, Theme, Renderer>
+impl<'a, Message, Renderer> From<Toggler<'a, Message, Renderer>>
+    for Element<'a, Message, cosmic::Theme, Renderer>
 where
     Message: 'a,
     Renderer: 'a + text::Renderer,
-    Theme: cosmic::iced_style::toggler::StyleSheet + 'a,
 {
     fn from(
-        toggler: Toggler<'a, Message, Theme, Renderer>,
-    ) -> Element<'a, Message, Theme, Renderer> {
+        toggler: Toggler<'a, Message, Renderer>,
+    ) -> Element<'a, Message, cosmic::Theme, Renderer> {
         Element::new(toggler)
     }
 }
 
-fn blend_appearances(first: Appearance, mut other: Appearance, percent: f32) -> Appearance {
+fn blend_appearances(first: Style, mut other: Style, percent: f32) -> Style {
     if percent == 0. {
         first
     } else if percent == 1. {
diff --git a/src/widget/toggler.rs b/src/widget/toggler.rs
index 5e7bb94..297c8d5 100644
--- a/src/widget/toggler.rs
+++ b/src/widget/toggler.rs
@@ -18,7 +18,7 @@ use iced_core::{
 
 use crate::{chain, id, lerp};
 
-pub use iced_style::toggler::{Appearance, StyleSheet};
+pub use iced_widget::toggler::{Appearance, StyleSheet};
 
 /// A toggler widget.
 ///
@@ -26,7 +26,7 @@ pub use iced_style::toggler::{Appearance, StyleSheet};
 pub struct Toggler<'a, Message, Theme, Renderer>
 where
     Renderer: text::Renderer,
-    Theme: iced_widget::toggler::StyleSheet,
+    Theme: iced_widget::toggler::Catalog,
 {
     id: id::Toggler,
     is_toggled: bool,
@@ -46,7 +46,7 @@ where
 impl<'a, Message, Theme, Renderer> Toggler<'a, Message, Theme, Renderer>
 where
     Renderer: text::Renderer,
-    Theme: iced_widget::toggler::StyleSheet,
+    Theme: iced_widget::toggler::Catalog,
 {
     /// The default size of a [`Toggler`].
     pub const DEFAULT_SIZE: f32 = 20.0;
@@ -145,7 +145,7 @@ impl<'a, Message, Theme, Renderer> Widget<Message, Theme, Renderer>
     for Toggler<'a, Message, Theme, Renderer>
 where
     Renderer: text::Renderer,
-    Theme: StyleSheet + widget::text::StyleSheet,
+    Theme: StyleSheet + widget::text::Catalog,
 {
     fn size(&self) -> Size<Length> {
         Size {
@@ -274,7 +274,7 @@ where
                 style,
                 label_layout,
                 tree.state.downcast_ref(),
-                iced_widget::text::Appearance::default(),
+                iced_widget::text::Style::default(),
                 viewport,
             );
         }
@@ -353,7 +353,7 @@ impl<'a, Message, Theme, Renderer> From<Toggler<'a, Message, Theme, Renderer>>
 where
     Message: 'a,
     Renderer: 'a + text::Renderer,
-    Theme: StyleSheet + widget::text::StyleSheet + 'a,
+    Theme: StyleSheet + widget::text::Catalog + 'a,
 {
     fn from(
         toggler: Toggler<'a, Message, Theme, Renderer>,
@@ -363,10 +363,10 @@ where
 }
 
 fn blend_appearances(
-    one: iced_style::toggler::Appearance,
-    mut two: iced_style::toggler::Appearance,
+    one: iced_widget::toggler::Appearance,
+    mut two: iced_widget::toggler::Appearance,
     percent: f32,
-) -> iced_style::toggler::Appearance {
+) -> iced_widget::toggler::Appearance {
     if percent == 0. {
         one
     } else if percent == 1. {