chore: remove once_cell dependency

Cargo.toml

@@ -160,7 +160,6 @@ log = "0.4"
 lyon = "1.0"
 lyon_path = "1.0"
 num-traits = "0.2"
-once_cell = "1.0"
 ouroboros = "0.18"
 palette = "0.7"
 pulldown-cmark = "0.11"

core/Cargo.toml

@@ -23,7 +23,6 @@ bytes.workspace = true
 glam.workspace = true
 log.workspace = true
 num-traits.workspace = true
-once_cell.workspace = true
 palette.workspace = true
 rustc-hash.workspace = true
 smol_str.workspace = true

core/src/theme.rs

@@ -164,10 +164,10 @@ impl Default for Theme {
     fn default() -> Self {
         #[cfg(feature = "auto-detect-theme")]
         {
-            use once_cell::sync::Lazy;
+            use std::sync::LazyLock;
 
-            static DEFAULT: Lazy<Theme> =
-                Lazy::new(|| match dark_light::detect() {
+            static DEFAULT: LazyLock<Theme> =
+                LazyLock::new(|| match dark_light::detect() {
                     dark_light::Mode::Dark => Theme::Dark,
                     dark_light::Mode::Light | dark_light::Mode::Default => {
                         Theme::Light

core/src/theme/palette.rs

@@ -1,7 +1,8 @@
 //! Define the colors of a theme.
+use std::sync::LazyLock;
+
 use crate::{color, Color};
 
-use once_cell::sync::Lazy;
 use palette::color_difference::Wcag21RelativeContrast;
 use palette::rgb::Rgb;
 use palette::{FromColor, Hsl, Mix};
@@ -307,92 +308,92 @@ pub struct Extended {
 }
 
 /// The built-in light variant of an [`Extended`] palette.
-pub static EXTENDED_LIGHT: Lazy<Extended> =
-    Lazy::new(|| Extended::generate(Palette::LIGHT));
+pub static EXTENDED_LIGHT: LazyLock<Extended> =
+    LazyLock::new(|| Extended::generate(Palette::LIGHT));
 
 /// The built-in dark variant of an [`Extended`] palette.
-pub static EXTENDED_DARK: Lazy<Extended> =
-    Lazy::new(|| Extended::generate(Palette::DARK));
+pub static EXTENDED_DARK: LazyLock<Extended> =
+    LazyLock::new(|| Extended::generate(Palette::DARK));
 
 /// The built-in Dracula variant of an [`Extended`] palette.
-pub static EXTENDED_DRACULA: Lazy<Extended> =
-    Lazy::new(|| Extended::generate(Palette::DRACULA));
+pub static EXTENDED_DRACULA: LazyLock<Extended> =
+    LazyLock::new(|| Extended::generate(Palette::DRACULA));
 
 /// The built-in Nord variant of an [`Extended`] palette.
-pub static EXTENDED_NORD: Lazy<Extended> =
-    Lazy::new(|| Extended::generate(Palette::NORD));
+pub static EXTENDED_NORD: LazyLock<Extended> =
+    LazyLock::new(|| Extended::generate(Palette::NORD));
 
 /// The built-in Solarized Light variant of an [`Extended`] palette.
-pub static EXTENDED_SOLARIZED_LIGHT: Lazy<Extended> =
-    Lazy::new(|| Extended::generate(Palette::SOLARIZED_LIGHT));
+pub static EXTENDED_SOLARIZED_LIGHT: LazyLock<Extended> =
+    LazyLock::new(|| Extended::generate(Palette::SOLARIZED_LIGHT));
 
 /// The built-in Solarized Dark variant of an [`Extended`] palette.
-pub static EXTENDED_SOLARIZED_DARK: Lazy<Extended> =
-    Lazy::new(|| Extended::generate(Palette::SOLARIZED_DARK));
+pub static EXTENDED_SOLARIZED_DARK: LazyLock<Extended> =
+    LazyLock::new(|| Extended::generate(Palette::SOLARIZED_DARK));
 
 /// The built-in Gruvbox Light variant of an [`Extended`] palette.
-pub static EXTENDED_GRUVBOX_LIGHT: Lazy<Extended> =
-    Lazy::new(|| Extended::generate(Palette::GRUVBOX_LIGHT));
+pub static EXTENDED_GRUVBOX_LIGHT: LazyLock<Extended> =
+    LazyLock::new(|| Extended::generate(Palette::GRUVBOX_LIGHT));
 
 /// The built-in Gruvbox Dark variant of an [`Extended`] palette.
-pub static EXTENDED_GRUVBOX_DARK: Lazy<Extended> =
-    Lazy::new(|| Extended::generate(Palette::GRUVBOX_DARK));
+pub static EXTENDED_GRUVBOX_DARK: LazyLock<Extended> =
+    LazyLock::new(|| Extended::generate(Palette::GRUVBOX_DARK));
 
 /// The built-in Catppuccin Latte variant of an [`Extended`] palette.
-pub static EXTENDED_CATPPUCCIN_LATTE: Lazy<Extended> =
-    Lazy::new(|| Extended::generate(Palette::CATPPUCCIN_LATTE));
+pub static EXTENDED_CATPPUCCIN_LATTE: LazyLock<Extended> =
+    LazyLock::new(|| Extended::generate(Palette::CATPPUCCIN_LATTE));
 
 /// The built-in Catppuccin Frappé variant of an [`Extended`] palette.
-pub static EXTENDED_CATPPUCCIN_FRAPPE: Lazy<Extended> =
-    Lazy::new(|| Extended::generate(Palette::CATPPUCCIN_FRAPPE));
+pub static EXTENDED_CATPPUCCIN_FRAPPE: LazyLock<Extended> =
+    LazyLock::new(|| Extended::generate(Palette::CATPPUCCIN_FRAPPE));
 
 /// The built-in Catppuccin Macchiato variant of an [`Extended`] palette.
-pub static EXTENDED_CATPPUCCIN_MACCHIATO: Lazy<Extended> =
-    Lazy::new(|| Extended::generate(Palette::CATPPUCCIN_MACCHIATO));
+pub static EXTENDED_CATPPUCCIN_MACCHIATO: LazyLock<Extended> =
+    LazyLock::new(|| Extended::generate(Palette::CATPPUCCIN_MACCHIATO));
 
 /// The built-in Catppuccin Mocha variant of an [`Extended`] palette.
-pub static EXTENDED_CATPPUCCIN_MOCHA: Lazy<Extended> =
-    Lazy::new(|| Extended::generate(Palette::CATPPUCCIN_MOCHA));
+pub static EXTENDED_CATPPUCCIN_MOCHA: LazyLock<Extended> =
+    LazyLock::new(|| Extended::generate(Palette::CATPPUCCIN_MOCHA));
 
 /// The built-in Tokyo Night variant of an [`Extended`] palette.
-pub static EXTENDED_TOKYO_NIGHT: Lazy<Extended> =
-    Lazy::new(|| Extended::generate(Palette::TOKYO_NIGHT));
+pub static EXTENDED_TOKYO_NIGHT: LazyLock<Extended> =
+    LazyLock::new(|| Extended::generate(Palette::TOKYO_NIGHT));
 
 /// The built-in Tokyo Night Storm variant of an [`Extended`] palette.
-pub static EXTENDED_TOKYO_NIGHT_STORM: Lazy<Extended> =
-    Lazy::new(|| Extended::generate(Palette::TOKYO_NIGHT_STORM));
+pub static EXTENDED_TOKYO_NIGHT_STORM: LazyLock<Extended> =
+    LazyLock::new(|| Extended::generate(Palette::TOKYO_NIGHT_STORM));
 
 /// The built-in Tokyo Night variant of an [`Extended`] palette.
-pub static EXTENDED_TOKYO_NIGHT_LIGHT: Lazy<Extended> =
-    Lazy::new(|| Extended::generate(Palette::TOKYO_NIGHT_LIGHT));
+pub static EXTENDED_TOKYO_NIGHT_LIGHT: LazyLock<Extended> =
+    LazyLock::new(|| Extended::generate(Palette::TOKYO_NIGHT_LIGHT));
 
 /// The built-in Kanagawa Wave variant of an [`Extended`] palette.
-pub static EXTENDED_KANAGAWA_WAVE: Lazy<Extended> =
-    Lazy::new(|| Extended::generate(Palette::KANAGAWA_WAVE));
+pub static EXTENDED_KANAGAWA_WAVE: LazyLock<Extended> =
+    LazyLock::new(|| Extended::generate(Palette::KANAGAWA_WAVE));
 
 /// The built-in Kanagawa Dragon variant of an [`Extended`] palette.
-pub static EXTENDED_KANAGAWA_DRAGON: Lazy<Extended> =
-    Lazy::new(|| Extended::generate(Palette::KANAGAWA_DRAGON));
+pub static EXTENDED_KANAGAWA_DRAGON: LazyLock<Extended> =
+    LazyLock::new(|| Extended::generate(Palette::KANAGAWA_DRAGON));
 
 /// The built-in Kanagawa Lotus variant of an [`Extended`] palette.
-pub static EXTENDED_KANAGAWA_LOTUS: Lazy<Extended> =
-    Lazy::new(|| Extended::generate(Palette::KANAGAWA_LOTUS));
+pub static EXTENDED_KANAGAWA_LOTUS: LazyLock<Extended> =
+    LazyLock::new(|| Extended::generate(Palette::KANAGAWA_LOTUS));
 
 /// The built-in Moonfly variant of an [`Extended`] palette.
-pub static EXTENDED_MOONFLY: Lazy<Extended> =
-    Lazy::new(|| Extended::generate(Palette::MOONFLY));
+pub static EXTENDED_MOONFLY: LazyLock<Extended> =
+    LazyLock::new(|| Extended::generate(Palette::MOONFLY));
 
 /// The built-in Nightfly variant of an [`Extended`] palette.
-pub static EXTENDED_NIGHTFLY: Lazy<Extended> =
-    Lazy::new(|| Extended::generate(Palette::NIGHTFLY));
+pub static EXTENDED_NIGHTFLY: LazyLock<Extended> =
+    LazyLock::new(|| Extended::generate(Palette::NIGHTFLY));
 
 /// The built-in Oxocarbon variant of an [`Extended`] palette.
-pub static EXTENDED_OXOCARBON: Lazy<Extended> =
-    Lazy::new(|| Extended::generate(Palette::OXOCARBON));
+pub static EXTENDED_OXOCARBON: LazyLock<Extended> =
+    LazyLock::new(|| Extended::generate(Palette::OXOCARBON));
 
 /// The built-in Ferra variant of an [`Extended`] palette.
-pub static EXTENDED_FERRA: Lazy<Extended> =
-    Lazy::new(|| Extended::generate(Palette::FERRA));
+pub static EXTENDED_FERRA: LazyLock<Extended> =
+    LazyLock::new(|| Extended::generate(Palette::FERRA));
 
 impl Extended {
     /// Generates an [`Extended`] palette from a simple [`Palette`].

examples/loading_spinners/Cargo.toml

@@ -10,4 +10,3 @@ iced.workspace = true
 iced.features = ["advanced", "canvas"]
 
 lyon_algorithms = "1.0"
-once_cell.workspace = true

examples/loading_spinners/src/easing.rs

@@ -1,41 +1,42 @@
+use std::sync::LazyLock;
+
 use iced::Point;
 
 use lyon_algorithms::measure::PathMeasurements;
 use lyon_algorithms::path::{builder::NoAttributes, path::BuilderImpl, Path};
-use once_cell::sync::Lazy;
 
-pub static EMPHASIZED: Lazy<Easing> = Lazy::new(|| {
+pub static EMPHASIZED: LazyLock<Easing> = LazyLock::new(|| {
     Easing::builder()
         .cubic_bezier_to([0.05, 0.0], [0.133333, 0.06], [0.166666, 0.4])
         .cubic_bezier_to([0.208333, 0.82], [0.25, 1.0], [1.0, 1.0])
         .build()
 });
 
-pub static EMPHASIZED_DECELERATE: Lazy<Easing> = Lazy::new(|| {
+pub static EMPHASIZED_DECELERATE: LazyLock<Easing> = LazyLock::new(|| {
     Easing::builder()
         .cubic_bezier_to([0.05, 0.7], [0.1, 1.0], [1.0, 1.0])
         .build()
 });
 
-pub static EMPHASIZED_ACCELERATE: Lazy<Easing> = Lazy::new(|| {
+pub static EMPHASIZED_ACCELERATE: LazyLock<Easing> = LazyLock::new(|| {
     Easing::builder()
         .cubic_bezier_to([0.3, 0.0], [0.8, 0.15], [1.0, 1.0])
         .build()
 });
 
-pub static STANDARD: Lazy<Easing> = Lazy::new(|| {
+pub static STANDARD: LazyLock<Easing> = LazyLock::new(|| {
     Easing::builder()
         .cubic_bezier_to([0.2, 0.0], [0.0, 1.0], [1.0, 1.0])
         .build()
 });
 
-pub static STANDARD_DECELERATE: Lazy<Easing> = Lazy::new(|| {
+pub static STANDARD_DECELERATE: LazyLock<Easing> = LazyLock::new(|| {
     Easing::builder()
         .cubic_bezier_to([0.0, 0.0], [0.0, 1.0], [1.0, 1.0])
         .build()
 });
 
-pub static STANDARD_ACCELERATE: Lazy<Easing> = Lazy::new(|| {
+pub static STANDARD_ACCELERATE: LazyLock<Easing> = LazyLock::new(|| {
     Easing::builder()
         .cubic_bezier_to([0.3, 0.0], [1.0, 1.0], [1.0, 1.0])
         .build()

examples/scrollable/Cargo.toml

@@ -8,5 +8,3 @@ publish = false
 [dependencies]
 iced.workspace = true
 iced.features = ["debug"]
-
-once_cell.workspace = true

examples/scrollable/src/main.rs

@@ -1,12 +1,13 @@
+use std::sync::LazyLock;
+
 use iced::widget::{
     button, column, container, horizontal_space, progress_bar, radio, row,
     scrollable, slider, text, vertical_space,
 };
 use iced::{Border, Center, Color, Element, Fill, Task, Theme};
 
-use once_cell::sync::Lazy;
-
-static SCROLLABLE_ID: Lazy<scrollable::Id> = Lazy::new(scrollable::Id::unique);
+static SCROLLABLE_ID: LazyLock<scrollable::Id> =
+    LazyLock::new(scrollable::Id::unique);
 
 pub fn main() -> iced::Result {
     iced::application(

examples/visible_bounds/Cargo.toml

@@ -8,5 +8,3 @@ publish = false
 [dependencies]
 iced.workspace = true
 iced.features = ["debug"]
-
-once_cell.workspace = true

examples/visible_bounds/src/main.rs

@@ -157,9 +157,9 @@ impl Example {
     }
 }
 
-use once_cell::sync::Lazy;
+use std::sync::LazyLock;
 
-static OUTER_CONTAINER: Lazy<container::Id> =
-    Lazy::new(|| container::Id::new("outer"));
-static INNER_CONTAINER: Lazy<container::Id> =
-    Lazy::new(|| container::Id::new("inner"));
+static OUTER_CONTAINER: LazyLock<container::Id> =
+    LazyLock::new(|| container::Id::new("outer"));
+static INNER_CONTAINER: LazyLock<container::Id> =
+    LazyLock::new(|| container::Id::new("inner"));

examples/websocket/Cargo.toml

@@ -9,7 +9,6 @@ publish = false
 iced.workspace = true
 iced.features = ["debug", "tokio"]
 
-once_cell.workspace = true
 warp = "0.3"
 
 [dependencies.async-tungstenite]

examples/websocket/src/main.rs

@@ -1,10 +1,11 @@
 mod echo;
 
+use std::sync::LazyLock;
+
 use iced::widget::{
     self, button, center, column, row, scrollable, text, text_input,
 };
 use iced::{color, Center, Element, Fill, Subscription, Task};
-use once_cell::sync::Lazy;
 
 pub fn main() -> iced::Result {
     iced::application("WebSocket - Iced", WebSocket::update, WebSocket::view)
@@ -138,4 +139,5 @@ enum State {
     Connected(echo::Connection),
 }
 
-static MESSAGE_LOG: Lazy<scrollable::Id> = Lazy::new(scrollable::Id::unique);
+static MESSAGE_LOG: LazyLock<scrollable::Id> =
+    LazyLock::new(scrollable::Id::unique);

graphics/Cargo.toml

@@ -33,7 +33,6 @@ bytemuck.workspace = true
 cosmic-text.workspace = true
 half.workspace = true
 log.workspace = true
-once_cell.workspace = true
 raw-window-handle.workspace = true
 rustc-hash.workspace = true
 thiserror.workspace = true

graphics/src/text.rs

@@ -14,9 +14,8 @@ use crate::core::font::{self, Font};
 use crate::core::text::{Shaping, Wrapping};
 use crate::core::{Color, Pixels, Point, Rectangle, Size, Transformation};
 
-use once_cell::sync::OnceCell;
 use std::borrow::Cow;
-use std::sync::{Arc, RwLock, Weak};
+use std::sync::{Arc, OnceLock, RwLock, Weak};
 
 /// A text primitive.
 #[derive(Debug, Clone, PartialEq)]
@@ -155,7 +154,7 @@ pub const FIRA_SANS_REGULAR: &'static [u8] =
 
 /// Returns the global [`FontSystem`].
 pub fn font_system() -> &'static RwLock<FontSystem> {
-    static FONT_SYSTEM: OnceCell<RwLock<FontSystem>> = OnceCell::new();
+    static FONT_SYSTEM: OnceLock<RwLock<FontSystem>> = OnceLock::new();
 
     FONT_SYSTEM.get_or_init(|| {
         RwLock::new(FontSystem {

highlighter/Cargo.toml

@@ -16,5 +16,4 @@ workspace = true
 [dependencies]
 iced_core.workspace = true
 
-once_cell.workspace = true
 syntect.workspace = true

highlighter/src/lib.rs

@@ -5,16 +5,16 @@ use crate::core::font::{self, Font};
 use crate::core::text::highlighter::{self, Format};
 use crate::core::Color;
 
-use once_cell::sync::Lazy;
 use std::ops::Range;
+use std::sync::LazyLock;
 use syntect::highlighting;
 use syntect::parsing;
 
-static SYNTAXES: Lazy<parsing::SyntaxSet> =
-    Lazy::new(parsing::SyntaxSet::load_defaults_nonewlines);
+static SYNTAXES: LazyLock<parsing::SyntaxSet> =
+    LazyLock::new(parsing::SyntaxSet::load_defaults_nonewlines);
 
-static THEMES: Lazy<highlighting::ThemeSet> =
-    Lazy::new(highlighting::ThemeSet::load_defaults);
+static THEMES: LazyLock<highlighting::ThemeSet> =
+    LazyLock::new(highlighting::ThemeSet::load_defaults);
 
 const LINES_PER_SNAPSHOT: usize = 50;
 

wgpu/Cargo.toml

@@ -35,7 +35,6 @@ glam.workspace = true
 glyphon.workspace = true
 guillotiere.workspace = true
 log.workspace = true
-once_cell.workspace = true
 rustc-hash.workspace = true
 thiserror.workspace = true
 wgpu.workspace = true

widget/Cargo.toml

@@ -33,7 +33,6 @@ iced_renderer.workspace = true
 iced_runtime.workspace = true
 
 num-traits.workspace = true
-once_cell.workspace = true
 rustc-hash.workspace = true
 thiserror.workspace = true
 unicode-segmentation.workspace = true

widget/src/helpers.rs

@@ -1676,11 +1676,12 @@ where
         + 'a,
     Theme: text::Catalog + crate::svg::Catalog + 'a,
 {
+    use std::sync::LazyLock;
+
     use crate::core::{Alignment, Font};
     use crate::svg;
-    use once_cell::sync::Lazy;
 
-    static LOGO: Lazy<svg::Handle> = Lazy::new(|| {
+    static LOGO: LazyLock<svg::Handle> = LazyLock::new(|| {
         svg::Handle::from_memory(include_bytes!("../assets/iced-logo.svg"))
     });