Add EventLoopProxy::into_waker

2026-06-26 22:53:15 -04:00 · 2025-09-05 02:00:44 +02:00
156 changed files with 1961 additions and 3395 deletions
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -55,7 +55,7 @@ jobs:
    strategy:
      fail-fast: false
      matrix:
-        toolchain: [stable, nightly, '1.85']
+        toolchain: [stable, nightly, '1.80']
        platform:
          # Note: Make sure that we test all the `docs.rs` targets defined in Cargo.toml!
          - { name: 'Windows 64bit MSVC', target: x86_64-pc-windows-msvc,   os: windows-latest,  }
@@ -82,13 +82,13 @@ jobs:
          - toolchain: nightly
            platform: { name: 'Windows 32bit GNU' }
          # Android is tested on stable-3
-          - toolchain: '1.85'
+          - toolchain: '1.80'
            platform: { name: 'Android' }
          # Redox OS doesn't follow MSRV
-          - toolchain: '1.85'
+          - toolchain: '1.80'
            platform: { name: 'Redox OS' }
        include:
-          - toolchain: '1.85'
+          - toolchain: '1.80'
            platform: { name: 'Android', target: aarch64-linux-android, os: ubuntu-latest, options: '--package winit --features=android-native-activity', cmd: 'apk -- ' }
          - toolchain: 'nightly'
            platform: { name: 'Web', target: wasm32-unknown-unknown, os: ubuntu-latest, test-options: -Zdoctest-xcompile }
@@ -136,7 +136,7 @@ jobs:

    - name: Generate lockfile
      # Also updates the crates.io index
-      run: cargo generate-lockfile && cargo update -p smol_str --precise 0.3.2
+      run: cargo generate-lockfile && cargo update -p ahash --precise 0.8.7 && cargo update -p bumpalo --precise 3.14.0

    - name: Install GCC Multilib
      if: (matrix.platform.os == 'ubuntu-latest') && contains(matrix.platform.target, 'i686')
@@ -230,19 +230,19 @@ jobs:
    - name: Test dpi crate
      if: >
        contains(matrix.platform.name, 'Linux 64bit') &&
-        matrix.toolchain != '1.85'
+        matrix.toolchain != '1.80'
      run: cargo test -p dpi

    - name: Check dpi crate (no_std)
      if: >
        contains(matrix.platform.name, 'Linux 64bit') &&
-        matrix.toolchain != '1.85'
+        matrix.toolchain != '1.80'
      run: cargo check -p dpi --no-default-features

    - name: Build tests
      if: >
        !contains(matrix.platform.target, 'redox') &&
-        matrix.toolchain != '1.85'
+        matrix.toolchain != '1.80'
      run: cargo $CMD test --no-run $OPTIONS

    - name: Run tests
@@ -251,7 +251,7 @@ jobs:
        !contains(matrix.platform.target, 'ios') &&
        (!contains(matrix.platform.target, 'wasm32') || matrix.toolchain == 'nightly') &&
        !contains(matrix.platform.target, 'redox') &&
-        matrix.toolchain != '1.85'
+        matrix.toolchain != '1.80'
      run: cargo $CMD test $OPTIONS

    - name: Lint with clippy
@@ -261,7 +261,7 @@ jobs:
    - name: Build tests with serde enabled
      if: >
        !contains(matrix.platform.target, 'redox') &&
-        matrix.toolchain != '1.85'
+        matrix.toolchain != '1.80'
      run: cargo $CMD test --no-run $OPTIONS $TEST_OPTIONS --features serde

    - name: Run tests with serde enabled
@@ -270,7 +270,7 @@ jobs:
        !contains(matrix.platform.target, 'ios') &&
        (!contains(matrix.platform.target, 'wasm32') || matrix.toolchain == 'nightly') &&
        !contains(matrix.platform.target, 'redox') &&
-        matrix.toolchain != '1.85'
+        matrix.toolchain != '1.80'
      run: cargo $CMD test $OPTIONS $TEST_OPTIONS --features serde

    - name: Check docs.rs documentation
@@ -329,7 +329,7 @@ jobs:
      - name: Setup NPM
        run: npm install
      - name: Run ESLint
-        run: npx eslint@9.38.0
+        run: npx eslint

  swc:
    name: Minimize JavaScript
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -4,26 +4,26 @@ members = ["dpi", "winit*"]
 resolver = "2"

 [workspace.package]
-edition = "2024"
+edition = "2021"
 license = "Apache-2.0"
 repository = "https://github.com/rust-windowing/winit"
-rust-version = "1.85"
-version = "0.31.0-beta.2"
+rust-version = "1.80"
+version = "0.30.12"

 [workspace.dependencies]
 # Workspace dependencies.
 # `winit` has no version here to allow using it in dev deps for docs.
 winit = { path = "winit" }
-winit-android = { version = "=0.31.0-beta.2", path = "winit-android" }
-winit-appkit = { version = "=0.31.0-beta.2", path = "winit-appkit" }
-winit-common = { version = "=0.31.0-beta.2", path = "winit-common" }
-winit-core = { version = "=0.31.0-beta.2", path = "winit-core" }
-winit-orbital = { version = "=0.31.0-beta.2", path = "winit-orbital" }
-winit-uikit = { version = "=0.31.0-beta.2", path = "winit-uikit" }
-winit-wayland = { version = "=0.31.0-beta.2", path = "winit-wayland", default-features = false }
-winit-web = { version = "=0.31.0-beta.2", path = "winit-web" }
-winit-win32 = { version = "=0.31.0-beta.2", path = "winit-win32" }
-winit-x11 = { version = "=0.31.0-beta.2", path = "winit-x11" }
+winit-android = { version = "0.30.12", path = "winit-android" }
+winit-appkit = { version = "0.30.12", path = "winit-appkit" }
+winit-common = { version = "0.30.12", path = "winit-common" }
+winit-core = { version = "0.30.12", path = "winit-core" }
+winit-orbital = { version = "0.30.12", path = "winit-orbital" }
+winit-uikit = { version = "0.30.12", path = "winit-uikit" }
+winit-wayland = { version = "0.30.12", path = "winit-wayland", default-features = false }
+winit-web = { version = "0.30.12", path = "winit-web" }
+winit-win32 = { version = "0.30.12", path = "winit-win32" }
+winit-x11 = { version = "0.30.12", path = "winit-x11" }

 # Core dependencies.
 bitflags = "2"
@@ -55,12 +55,12 @@ ndk = { version = "0.9.0", features = ["rwh_06"], default-features = false }
 block2 = "0.6.1"
 dispatch2 = { version = "0.3.0", default-features = false, features = ["std", "objc2"] }
 objc2 = { version = "0.6.1", features = ["relax-sign-encoding"] }
-objc2-app-kit = { version = "0.3.2", default-features = false }
-objc2-core-foundation = { version = "0.3.2", default-features = false }
-objc2-core-graphics = { version = "0.3.2", default-features = false }
-objc2-core-video = { version = "0.3.2", default-features = false }
-objc2-foundation = { version = "0.3.2", default-features = false }
-objc2-ui-kit = { version = "0.3.2", default-features = false }
+objc2-app-kit = { version = "0.3.1", default-features = false }
+objc2-core-foundation = { version = "0.3.1", default-features = false }
+objc2-core-graphics = { version = "0.3.1", default-features = false }
+objc2-core-video = { version = "0.3.1", default-features = false }
+objc2-foundation = { version = "0.3.1", default-features = false }
+objc2-ui-kit = { version = "0.3.1", default-features = false }

 # Windows dependencies.
 unicode-segmentation = "1.7.1"
@@ -69,11 +69,19 @@ windows-sys = "0.59.0"
 # Linux dependencies.
 ahash = { version = "0.8.7", features = ["no-rng"] }
 bytemuck = { version = "1.13.1", default-features = false }
-calloop = "0.14.3"
+calloop = "0.13.0"
 libc = "0.2.64"
 memmap2 = "0.9.0"
 percent-encoding = "2.0"
 rustix = { version = "1.0.7", default-features = false }
+sctk = { package = "smithay-client-toolkit", version = "0.19.2", default-features = false, features = [
+    "calloop",
+] }
+sctk-adwaita = { version = "0.10.1", default-features = false }
+wayland-backend = { version = "0.3.10", default-features = false, features = ["client_system"] }
+wayland-client = "0.31.10"
+wayland-protocols = { version = "0.32.8", features = ["staging"] }
+wayland-protocols-plasma = { version = "0.3.8", features = ["client"] }
 x11-dl = "2.19.1"
 x11rb = { version = "0.13.0", default-features = false }
 xkbcommon-dl = "0.4.2"
--- a/README.md
+++ b/README.md
@@ -8,7 +8,7 @@

 ```toml
 [dependencies]
-winit = "0.31.0-beta.2"
+winit = "0.30.12"
 ```

 ## [Documentation](https://docs.rs/winit)
@@ -39,7 +39,7 @@ For contributing guidelines see [CONTRIBUTING.md](./CONTRIBUTING.md).

 ## MSRV Policy

-This crate's Minimum Supported Rust Version (MSRV) is **1.85**. Changes to
+This crate's Minimum Supported Rust Version (MSRV) is **1.80**. Changes to
 the MSRV will be accompanied by a minor version bump.

 As a **tentative** policy, the upper bound of the MSRV is given by the following
--- a/clippy.toml
+++ b/clippy.toml
@@ -10,9 +10,6 @@ disallowed-methods = [
    { allow-invalid = true, path = "web_sys::HtmlCanvasElement::set_width", reason = "Winit shouldn't touch the internal canvas size" },
    { allow-invalid = true, path = "web_sys::HtmlCanvasElement::width", reason = "Winit shouldn't touch the internal canvas size" },
    { allow-invalid = true, path = "web_sys::HtmlElement::style", reason = "cache this to reduce calls to JS" },
-    { allow-invalid = true, path = "web_sys::MouseEvent::buttons", reason = "Use `backend::event::cursor_buttons()` to avoid wrong conversions" },
-    { allow-invalid = true, path = "web_sys::MouseEvent::button", reason = "Use `backend::event::cursor_button()` to avoid wrong conversions" },
-    { allow-invalid = true, path = "web_sys::PointerEvent::pointer_type", reason = "Use `WebPointerType` to emit warnings" },
    { allow-invalid = true, path = "web_sys::Window::document", reason = "cache this to reduce calls to JS" },
    { allow-invalid = true, path = "web_sys::Window::get_computed_style", reason = "cache this to reduce calls to JS" },
    { allow-invalid = true, path = "web_sys::Window::navigator", reason = "cache this to reduce calls to JS" },
--- a/deny.toml
+++ b/deny.toml
@@ -59,10 +59,6 @@ crate = "android-activity"
 allow-globs = ["ci/*", "githooks/*"]
 crate = "zerocopy"

-[[bans.build.bypass]]
-allow-globs = ["cherry-pick-stable.sh"]
-crate = "libc"
-
 [[bans.build.bypass]]
 allow-globs = ["freetype2/*"]
 crate = "freetype-sys"
--- a/dpi/src/lib.rs
+++ b/dpi/src/lib.rs
@@ -64,7 +64,7 @@
 //! [points]: https://en.wikipedia.org/wiki/Point_(typography)
 //! [picas]: https://en.wikipedia.org/wiki/Pica_(typography)

-#![cfg_attr(docsrs, feature(doc_cfg), doc(auto_cfg(hide(doc, docsrs))))]
+#![cfg_attr(docsrs, feature(doc_auto_cfg, doc_cfg_hide), doc(cfg_hide(doc, docsrs)))]
 #![cfg_attr(feature = "std", forbid(unsafe_code))]
 #![no_std]

--- a/1
+++ b/1
@@ -1 +0,0 @@
-winit/examples
--- a/winit/examples/application.rs
+++ b/winit/examples/application.rs
@@ -1,33 +1,30 @@
 //! Simple winit application.
-//!
-//! Note that a real application accepting text input **should** support
-//! the IME interface. See the `ime` example.

-use std::borrow::Cow;
 use std::collections::HashMap;
 use std::error::Error;
 use std::fmt::Debug;
 #[cfg(not(android_platform))]
 use std::num::NonZeroU32;
-use std::sync::Arc;
 use std::sync::mpsc::{self, Receiver, Sender};
+use std::sync::Arc;
 #[cfg(all(not(android_platform), not(web_platform)))]
 use std::time::Instant;
-use std::{fmt, mem};
+use std::{cmp, fmt, mem};

+use ::tracing::{error, info};
 use cursor_icon::CursorIcon;
+use dpi::LogicalPosition;
 #[cfg(not(android_platform))]
 use rwh_06::{DisplayHandle, HasDisplayHandle};
 #[cfg(not(android_platform))]
 use softbuffer::{Context, Surface};
-use tracing::{error, info};
 #[cfg(all(web_platform, not(android_platform)))]
 use web_time::Instant;
 use winit::application::ApplicationHandler;
 use winit::cursor::{Cursor, CustomCursor, CustomCursorSource};
 use winit::dpi::{LogicalSize, PhysicalPosition, PhysicalSize};
 use winit::error::RequestError;
-use winit::event::{DeviceEvent, DeviceId, MouseButton, MouseScrollDelta, WindowEvent};
+use winit::event::{DeviceEvent, DeviceId, Ime, MouseButton, MouseScrollDelta, WindowEvent};
 use winit::event_loop::{ActiveEventLoop, EventLoop};
 use winit::icon::{Icon, RgbaIcon};
 use winit::keyboard::{Key, ModifiersState};
@@ -42,23 +39,28 @@ use winit::platform::wayland::{ActiveEventLoopExtWayland, WindowAttributesWaylan
 use winit::platform::web::{ActiveEventLoopExtWeb, WindowAttributesWeb};
 #[cfg(x11_platform)]
 use winit::platform::x11::{ActiveEventLoopExtX11, WindowAttributesX11};
-use winit::window::{CursorGrabMode, ResizeDirection, Theme, Window, WindowAttributes, WindowId};
+use winit::window::{
+    CursorGrabMode, ImeCapabilities, ImeEnableRequest, ImePurpose, ImeRequestData,
+    ImeSurroundingText, ResizeDirection, Theme, Window, WindowAttributes, WindowId,
+};
 use winit_core::application::macos::ApplicationHandlerExtMacOS;
+use winit_core::window::ImeRequest;

 #[path = "util/tracing.rs"]
-mod tracing_init;
+mod tracing;

 #[path = "util/fill.rs"]
 mod fill;

 /// The amount of points to around the window for drag resize direction calculations.
 const BORDER_SIZE: f64 = 20.;
+const IME_CURSOR_SIZE: PhysicalSize<u32> = PhysicalSize::new(20, 20);

 fn main() -> Result<(), Box<dyn Error>> {
    #[cfg(web_platform)]
    console_error_panic_hook::set_once();

-    tracing_init::init();
+    tracing::init();

    let event_loop = EventLoop::new()?;
    let (sender, receiver) = mpsc::channel();
@@ -203,15 +205,6 @@ impl Application {
            Action::DumpMonitors => self.dump_monitors(_event_loop),
            Action::Message => {
                info!("User wake up");
-                for (id, window) in self.windows.iter() {
-                    if window.emit_surface_size {
-                        let size = window.window.surface_size();
-                        info!(
-                            "Window {id:?} has physical surface size {}x{}",
-                            size.width, size.height
-                        );
-                    }
-                }
            },
            _ => unreachable!("Tried to execute invalid action without `WindowId`"),
        }
@@ -252,6 +245,7 @@ impl Application {
                window.window.set_simple_fullscreen(!window.window.simple_fullscreen());
            },
            Action::ToggleMaximize => window.toggle_maximize(),
+            Action::ToggleImeInput => window.toggle_ime(),
            Action::Minimize => window.minimize(),
            Action::NextCursor => window.next_cursor(),
            Action::NextCustomCursor => {
@@ -324,9 +318,6 @@ impl Application {
                window.continuous_redraw = !window.continuous_redraw;
                window.window.request_redraw();
            },
-            Action::EmitSurfaceSize => {
-                window.toggle_emit_surface_size();
-            },
        }
    }

@@ -498,9 +489,8 @@ impl ApplicationHandler for Application {
                let mods = window.modifiers;
                if let Some(action) = state
                    .is_pressed()
-                    .then(|| button.mouse_button())
+                    .then(|| Self::process_mouse_binding(button.mouse_button(), &mods))
                    .flatten()
-                    .and_then(|button| Self::process_mouse_binding(button, &mods))
                {
                    self.handle_action_with_window(event_loop, window_id, action);
                }
@@ -522,6 +512,41 @@ impl ApplicationHandler for Application {
                    }
                }
            },
+            WindowEvent::Ime(event) => match event {
+                Ime::Enabled => info!("IME enabled for Window={window_id:?}"),
+                Ime::Preedit(text, caret_pos) => {
+                    info!("Preedit: {}, with caret at {:?}", text, caret_pos);
+                },
+                Ime::Commit(text) => {
+                    window.text_field_contents.0.push_str(&text);
+                    window.text_field_contents.1 += text.len();
+
+                    info!("Committed: {}", text);
+                    let request_data = window.get_ime_update();
+                    window.window.request_ime_update(ImeRequest::Update(request_data)).unwrap();
+                },
+                Ime::DeleteSurrounding { before_bytes, after_bytes } => {
+                    let (text, cursor) = &window.text_field_contents;
+
+                    // To anyone copying this, keep in mind that this doesn't take text selection
+                    // into account. The deletion happens *around* the pre-edit,
+                    // and may remove the whole selection or a part of it.
+                    let delete_start = cursor.saturating_sub(before_bytes);
+                    let delete_end = cmp::min(cursor.saturating_add(after_bytes), text.len());
+                    if text.is_char_boundary(delete_start) && text.is_char_boundary(delete_end) {
+                        let new_text = {
+                            let mut t = String::from(&text[..delete_start]);
+                            t.push_str(&text[delete_end..]);
+                            t
+                        };
+                        window.text_field_contents = (new_text, delete_start);
+                        info!("IME deleted bytes: {before_bytes}, {after_bytes}");
+                    } else {
+                        error!("Buggy IME tried to delete with indices not on char boundary.");
+                    }
+                },
+                Ime::Disabled => info!("IME disabled for Window={window_id:?}"),
+            },
            WindowEvent::PinchGesture { delta, .. } => {
                window.zoom += delta;
                let zoom = window.zoom;
@@ -556,7 +581,6 @@ impl ApplicationHandler for Application {
            | WindowEvent::DragMoved { .. }
            | WindowEvent::DragDropped { .. }
            | WindowEvent::Destroyed
-            | WindowEvent::Ime(_)
            | WindowEvent::Moved(_) => (),
        }
    }
@@ -611,6 +635,10 @@ impl ApplicationHandlerExtMacOS for Application {

 /// State of the window.
 struct WindowState {
+    ime_enabled: bool,
+    /// The contents of the emulated text field for IME purposes (not displayed).
+    /// (text, cursor position in bytes).
+    text_field_contents: (String, usize),
    /// Render surface.
    ///
    /// NOTE: This surface must be dropped before the `Window`.
@@ -627,8 +655,6 @@ struct WindowState {
    start_time: Instant,
    /// Redraw continuously
    continuous_redraw: bool,
-    /// Periodically emit the surface size
-    emit_surface_size: bool,
    /// Cursor position over the window.
    cursor_position: Option<PhysicalPosition<f64>>,
    /// Window modifiers state.
@@ -667,6 +693,21 @@ impl WindowState {
        let named_idx = 0;
        window.set_cursor(CURSORS[named_idx].into());

+        // Allow IME out of the box.
+        let request_data = ImeRequestData::default()
+            .with_purpose(ImePurpose::Normal)
+            .with_cursor_area(LogicalPosition { x: 0, y: 0 }.into(), IME_CURSOR_SIZE.into())
+            .with_surrounding_text(ImeSurroundingText::new(String::new(), 0, 0).unwrap());
+        let enable_request = ImeEnableRequest::new(
+            ImeCapabilities::new().with_purpose().with_cursor_area().with_surrounding_text(),
+            request_data,
+        )
+        .unwrap();
+        let enable_ime = ImeRequest::Enable(enable_request);
+
+        // Initial update
+        window.request_ime_update(enable_ime).unwrap();
+
        let size = window.surface_size();
        let mut state = Self {
            #[cfg(macos_platform)]
@@ -680,9 +721,10 @@ impl WindowState {
            theme,
            animated_fill_color: false,
            continuous_redraw: false,
-            emit_surface_size: false,
            #[cfg(not(android_platform))]
            start_time: Instant::now(),
+            ime_enabled: true,
+            text_field_contents: (String::new(), 0),
            cursor_position: Default::default(),
            cursor_hidden: Default::default(),
            modifiers: Default::default(),
@@ -696,12 +738,65 @@ impl WindowState {
        Ok(state)
    }

+    pub fn get_ime_update(&self) -> ImeRequestData {
+        let (text, cursor) = &self.text_field_contents;
+        // A rudimentary text field emulation: the caret moves right by a constant amount for each
+        // code point.
+
+        let text_before_caret = if text.is_char_boundary(*cursor) { &text[..*cursor] } else { "" };
+        let chars_before_caret = text_before_caret.chars().count();
+        let cursor_pos = LogicalPosition { x: 10 * chars_before_caret as u32, y: 0 }.into();
+
+        // Limit text field size
+        const MAX_BYTES: usize = ImeSurroundingText::MAX_TEXT_BYTES;
+        let minimal_offset = cursor / MAX_BYTES * MAX_BYTES;
+        let first_char_boundary =
+            (minimal_offset..*cursor).find(|off| text.is_char_boundary(*off)).unwrap_or(*cursor);
+        let last_char_boundary = (*cursor..(first_char_boundary + MAX_BYTES))
+            .rev()
+            .find(|off| text.is_char_boundary(*off))
+            .unwrap_or(*cursor);
+        let surrounding_text = &text[first_char_boundary..last_char_boundary];
+        let relative_cursor = cursor - first_char_boundary;
+        let surrounding_text =
+            ImeSurroundingText::new(surrounding_text.into(), relative_cursor, relative_cursor)
+                .expect("Bug in example: bad byte calculations");
+        ImeRequestData::default()
+            .with_purpose(ImePurpose::Normal)
+            .with_cursor_area(cursor_pos, IME_CURSOR_SIZE.into())
+            .with_surrounding_text(surrounding_text)
+    }
+
+    pub fn toggle_ime(&mut self) {
+        if self.ime_enabled {
+            self.window.request_ime_update(ImeRequest::Disable).expect("disable can not fail");
+        } else {
+            let enable_request = ImeEnableRequest::new(
+                ImeCapabilities::new().with_purpose().with_cursor_area().with_surrounding_text(),
+                self.get_ime_update(),
+            )
+            .unwrap();
+            self.window.request_ime_update(ImeRequest::Enable(enable_request)).unwrap();
+        };
+
+        self.ime_enabled = !self.ime_enabled;
+    }
+
    pub fn minimize(&mut self) {
        self.window.set_minimized(true);
    }

    pub fn cursor_moved(&mut self, position: PhysicalPosition<f64>) {
+        // the IME really cares about the caret,
+        // but there's nothing else to demonstrate a position
        self.cursor_position = Some(position);
+        if self.ime_enabled {
+            let request_data =
+                ImeRequestData::default().with_cursor_area(position.into(), IME_CURSOR_SIZE.into());
+            self.window
+                .request_ime_update(ImeRequest::Update(request_data))
+                .expect("A capability was not initially declared");
+        }
    }

    pub fn cursor_left(&mut self) {
@@ -753,10 +848,6 @@ impl WindowState {
        self.window.set_fullscreen(fullscreen);
    }

-    fn toggle_emit_surface_size(&mut self) {
-        self.emit_surface_size = !self.emit_surface_size;
-    }
-
    /// Cycle through the grab modes ignoring errors.
    fn cycle_cursor_grab(&mut self) {
        self.cursor_grab = match self.cursor_grab {
@@ -1022,6 +1113,7 @@ enum Action {
    ToggleCursorVisibility,
    CreateNewWindow,
    ToggleResizeIncrements,
+    ToggleImeInput,
    ToggleDecorations,
    ToggleResizable,
    ToggleFullscreen,
@@ -1050,7 +1142,6 @@ enum Action {
    Message,
    ToggleAnimatedFillColor,
    ToggleContinuousRedraw,
-    EmitSurfaceSize,
 }

 impl Action {
@@ -1059,6 +1150,7 @@ impl Action {
            Action::CloseWindow => "Close window",
            Action::ToggleCursorVisibility => "Hide cursor",
            Action::CreateNewWindow => "Create new window",
+            Action::ToggleImeInput => "Toggle IME input",
            Action::ToggleDecorations => "Toggle decorations",
            Action::ToggleResizable => "Toggle window resizable state",
            Action::ToggleFullscreen => "Toggle fullscreen",
@@ -1096,7 +1188,6 @@ impl Action {
            Action::Message => "Prints a message through a user wake up",
            Action::ToggleAnimatedFillColor => "Toggle animated fill color",
            Action::ToggleContinuousRedraw => "Toggle continuous redraw",
-            Action::EmitSurfaceSize => "Periodically print the surface size",
        }
    }
 }
@@ -1168,16 +1259,15 @@ fn modifiers_to_string(mods: ModifiersState) -> String {
    mods_line
 }

-fn mouse_button_to_string(button: MouseButton) -> Cow<'static, str> {
+fn mouse_button_to_string(button: MouseButton) -> &'static str {
    match button {
        MouseButton::Left => "LMB",
        MouseButton::Right => "RMB",
        MouseButton::Middle => "MMB",
        MouseButton::Back => "Back",
        MouseButton::Forward => "Forward",
-        other => return format!("button {}", other as u8 + 1).into(),
+        MouseButton::Other(_) => "",
    }
-    .into()
 }

 #[cfg(web_platform)]
@@ -1280,6 +1370,7 @@ const KEY_BINDINGS: &[Binding<&'static str>] = &[
    #[cfg(macos_platform)]
    Binding::new("F", ModifiersState::ALT, Action::ToggleSimpleFullscreen),
    Binding::new("D", ModifiersState::CONTROL, Action::ToggleDecorations),
+    Binding::new("I", ModifiersState::CONTROL, Action::ToggleImeInput),
    Binding::new("L", ModifiersState::CONTROL, Action::CycleCursorGrab),
    Binding::new("P", ModifiersState::CONTROL, Action::ToggleResizeIncrements),
    Binding::new("R", ModifiersState::CONTROL, Action::ToggleResizable),
@@ -1315,7 +1406,6 @@ const KEY_BINDINGS: &[Binding<&'static str>] = &[
    Binding::new("T", ModifiersState::META, Action::CreateNewTab),
    #[cfg(macos_platform)]
    Binding::new("O", ModifiersState::CONTROL, Action::CycleOptionAsAlt),
-    Binding::new("S", ModifiersState::ALT, Action::EmitSurfaceSize),
    Binding::new("S", ModifiersState::CONTROL, Action::Message),
 ];

--- a/winit/examples/child_window.rs
+++ b/winit/examples/child_window.rs
--- a/winit/examples/control_flow.rs
+++ b/winit/examples/control_flow.rs
--- a/winit/examples/data/cross.png
+++ b/winit/examples/data/cross.png
--- a/winit/examples/data/cross2.png
+++ b/winit/examples/data/cross2.png
--- a/winit/examples/data/gradient.png
+++ b/winit/examples/data/gradient.png
--- a/winit/examples/data/icon.png
+++ b/winit/examples/data/icon.png
--- a/winit/examples/dnd.rs
+++ b/winit/examples/dnd.rs
--- a/winit/examples/pump_events.rs
+++ b/winit/examples/pump_events.rs
--- a/winit/examples/run_on_demand.rs
+++ b/winit/examples/run_on_demand.rs
@@ -1,7 +1,7 @@
 #![allow(clippy::single_match)]

 // Limit this example to only compatible platforms.
-#[cfg(any(windows_platform, macos_platform, x11_platform, wayland_platform, orbital_platform))]
+#[cfg(any(windows_platform, macos_platform, x11_platform, wayland_platform,))]
 fn main() -> Result<(), Box<dyn std::error::Error>> {
    use std::time::Duration;

@@ -93,13 +93,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
    Ok(())
 }

-#[cfg(not(any(
-    windows_platform,
-    macos_platform,
-    x11_platform,
-    wayland_platform,
-    orbital_platform
-)))]
+#[cfg(not(any(windows_platform, macos_platform, x11_platform, wayland_platform,)))]
 fn main() {
    println!("This example is not supported on this platform");
 }
--- a/winit/examples/util/fill.rs
+++ b/winit/examples/util/fill.rs
--- a/winit/examples/util/tracing.rs
+++ b/winit/examples/util/tracing.rs
--- a/winit/examples/window.rs
+++ b/winit/examples/window.rs
--- a/winit/examples/x11_embed.rs
+++ b/winit/examples/x11_embed.rs
--- a/winit-android/src/event_loop.rs
+++ b/winit-android/src/event_loop.rs
@@ -500,6 +500,10 @@ impl EventLoop {
        input_status
    }

+    pub fn run_app<A: ApplicationHandler>(mut self, app: A) -> Result<(), EventLoopError> {
+        self.run_app_on_demand(app)
+    }
+
    pub fn run_app_on_demand<A: ApplicationHandler>(
        &mut self,
        mut app: A,
--- a/winit-android/src/keycodes.rs
+++ b/winit-android/src/keycodes.rs
@@ -1,5 +1,5 @@
-use android_activity::AndroidApp;
 use android_activity::input::{KeyAction, KeyEvent, KeyMapChar, Keycode};
+use android_activity::AndroidApp;
 use winit_core::keyboard::{
    Key, KeyCode, KeyLocation, NamedKey, NativeKey, NativeKeyCode, PhysicalKey,
 };
--- a/winit-android/src/lib.rs
+++ b/winit-android/src/lib.rs
@@ -62,8 +62,8 @@
 //! If your application is currently based on `NativeActivity` via the `ndk-glue` crate and building
 //! with `cargo apk`, then the minimal changes would be:
 //! 1. Remove `ndk-glue` from your `Cargo.toml`
-//! 2. Enable the `"android-native-activity"` feature for Winit: `winit = { version =
-//!    "0.31.0-beta.2", features = [ "android-native-activity" ] }`
+//! 2. Enable the `"android-native-activity"` feature for Winit: `winit = { version = "0.30.12",
+//!    features = [ "android-native-activity" ] }`
 //! 3. Add an `android_main` entrypoint (as above), instead of using the '`[ndk_glue::main]` proc
 //!    macro from `ndk-macros` (optionally add a dependency on `android_logger` and initialize
 //!    logging as above).
--- a/winit-appkit/Cargo.toml
+++ b/winit-appkit/Cargo.toml
@@ -18,6 +18,7 @@ rwh_06.workspace = true
 serde = { workspace = true, optional = true }
 smol_str.workspace = true
 tracing.workspace = true
+winit-common = { workspace = true, features = ["core-foundation", "event-handler"] }
 winit-core.workspace = true

 # Platform-specific
@@ -106,7 +107,6 @@ objc2-foundation = { workspace = true, features = [
    "NSThread",
    "NSValue",
 ] }
-winit-common = { workspace = true, features = ["core-foundation", "event-handler"] }

 [dev-dependencies]
 winit.workspace = true
--- a/winit-appkit/src/app.rs
+++ b/winit-appkit/src/app.rs
@@ -30,8 +30,8 @@ extern "C-unwind" fn send_event(app: &NSApplication, sel: Sel, event: &NSEvent)
    // For posterity, there are some undocumented event types
    // (https://github.com/servo/cocoa-rs/issues/155)
    // but that doesn't really matter here.
-    let event_type = event.r#type();
-    let modifier_flags = event.modifierFlags();
+    let event_type = unsafe { event.r#type() };
+    let modifier_flags = unsafe { event.modifierFlags() };
    if event_type == NSEventType::KeyUp && modifier_flags.contains(NSEventModifierFlags::Command) {
        if let Some(key_window) = app.keyWindow() {
            key_window.sendEvent(event);
@@ -98,15 +98,15 @@ pub(crate) fn override_send_event(global_app: &NSApplication) {
 }

 fn maybe_dispatch_device_event(app_state: &Rc<AppState>, event: &NSEvent) {
-    let event_type = event.r#type();
+    let event_type = unsafe { event.r#type() };
    #[allow(non_upper_case_globals)]
    match event_type {
        NSEventType::MouseMoved
        | NSEventType::LeftMouseDragged
        | NSEventType::OtherMouseDragged
        | NSEventType::RightMouseDragged => {
-            let delta_x = event.deltaX() as f64;
-            let delta_y = event.deltaY() as f64;
+            let delta_x = unsafe { event.deltaX() } as f64;
+            let delta_y = unsafe { event.deltaY() } as f64;

            if delta_x != 0.0 || delta_y != 0.0 {
                app_state.maybe_queue_with_handler(move |app, event_loop| {
@@ -117,7 +117,7 @@ fn maybe_dispatch_device_event(app_state: &Rc<AppState>, event: &NSEvent) {
            }
        },
        NSEventType::LeftMouseDown | NSEventType::RightMouseDown | NSEventType::OtherMouseDown => {
-            let button = event.buttonNumber() as u32;
+            let button = unsafe { event.buttonNumber() } as u32;
            app_state.maybe_queue_with_handler(move |app, event_loop| {
                app.device_event(event_loop, None, DeviceEvent::Button {
                    button,
@@ -126,7 +126,7 @@ fn maybe_dispatch_device_event(app_state: &Rc<AppState>, event: &NSEvent) {
            });
        },
        NSEventType::LeftMouseUp | NSEventType::RightMouseUp | NSEventType::OtherMouseUp => {
-            let button = event.buttonNumber() as u32;
+            let button = unsafe { event.buttonNumber() } as u32;
            app_state.maybe_queue_with_handler(move |app, event_loop| {
                app.device_event(event_loop, None, DeviceEvent::Button {
                    button,
@@ -141,7 +141,7 @@ fn maybe_dispatch_device_event(app_state: &Rc<AppState>, event: &NSEvent) {
 #[cfg(test)]
 mod tests {
    use objc2::rc::Retained;
-    use objc2::{ClassType, define_class, msg_send};
+    use objc2::{define_class, msg_send, ClassType};
    use objc2_app_kit::NSResponder;
    use objc2_foundation::NSObject;

@@ -153,14 +153,16 @@ mod tests {
        let Some(mtm) = MainThreadMarker::new() else { return };

        // Create a new application, without making it the shared application.
-        let app = NSApplication::new(mtm);
+        let app = unsafe { NSApplication::new(mtm) };
        override_send_event(&app);
        // Test calling twice works.
        override_send_event(&app);

        // FIXME(madsmtm): Can't test this yet, need some way to mock AppState.
-        // let event = super::super::event::dummy_event().unwrap();
-        // app.sendEvent(&event)
+        // unsafe {
+        //     let event = super::super::event::dummy_event().unwrap();
+        //     app.sendEvent(&event)
+        // }
    }

    #[test]
--- a/winit-appkit/src/app_state.rs
+++ b/winit-appkit/src/app_state.rs
@@ -15,7 +15,7 @@ use winit_core::event::{StartCause, WindowEvent};
 use winit_core::event_loop::ControlFlow;
 use winit_core::window::WindowId;

-use super::event_loop::{ActiveEventLoop, notify_windows_of_exit, stop_app_immediately};
+use super::event_loop::{notify_windows_of_exit, stop_app_immediately, ActiveEventLoop};
 use super::menu;
 use super::observer::{EventLoopWaker, RunLoop};

@@ -117,7 +117,7 @@ impl AppState {
            // - https://github.com/rust-windowing/winit/issues/261
            // - https://github.com/rust-windowing/winit/issues/3958
            let is_bundled =
-                NSRunningApplication::currentApplication().bundleIdentifier().is_some();
+                unsafe { NSRunningApplication::currentApplication().bundleIdentifier().is_some() };
            if !is_bundled {
                app.setActivationPolicy(NSApplicationActivationPolicy::Regular);
            }
--- a/winit-appkit/src/cursor.rs
+++ b/winit-appkit/src/cursor.rs
@@ -4,10 +4,10 @@ use std::sync::OnceLock;

 use objc2::rc::Retained;
 use objc2::runtime::Sel;
-use objc2::{AllocAnyThread, ClassType, available, msg_send, sel};
+use objc2::{available, msg_send, sel, AllocAnyThread, ClassType};
 use objc2_app_kit::{NSBitmapImageRep, NSCursor, NSDeviceRGBColorSpace, NSImage};
 use objc2_foundation::{
-    NSData, NSDictionary, NSNumber, NSObject, NSPoint, NSSize, NSString, ns_string,
+    ns_string, NSData, NSDictionary, NSNumber, NSObject, NSPoint, NSSize, NSString,
 };
 use winit_core::cursor::{CursorIcon, CursorImage, CustomCursorProvider, CustomCursorSource};
 use winit_core::error::{NotSupportedError, RequestError};
@@ -31,7 +31,7 @@ impl CustomCursor {
        let cursor = match cursor {
            CustomCursorSource::Image(cursor_image) => cursor_image,
            CustomCursorSource::Animation { .. } | CustomCursorSource::Url { .. } => {
-                return Err(NotSupportedError::new("unsupported cursor kind").into());
+                return Err(NotSupportedError::new("unsupported cursor kind").into())
            },
        };

@@ -62,8 +62,10 @@ pub(crate) fn cursor_from_image(cursor: &CursorImage) -> Result<Retained<NSCurso
        unsafe { slice::from_raw_parts_mut(bitmap.bitmapData(), cursor.buffer().len()) };
    bitmap_data.copy_from_slice(cursor.buffer());

-    let image = NSImage::initWithSize(NSImage::alloc(), NSSize::new(width.into(), height.into()));
-    image.addRepresentation(&bitmap);
+    let image = unsafe {
+        NSImage::initWithSize(NSImage::alloc(), NSSize::new(width.into(), height.into()))
+    };
+    unsafe { image.addRepresentation(&bitmap) };

    let hotspot = NSPoint::new(cursor.hotspot_x() as f64, cursor.hotspot_y() as f64);

@@ -138,9 +140,12 @@ unsafe fn load_webkit_cursor(name: &NSString) -> Retained<NSCursor> {

    // TODO: Handle PLists better
    let info_path = cursor_path.stringByAppendingPathComponent(ns_string!("info.plist"));
-    #[allow(deprecated)]
-    let info: Retained<NSDictionary<NSObject, NSObject>> =
-        unsafe { NSDictionary::dictionaryWithContentsOfFile(&info_path) }.unwrap();
+    let info: Retained<NSDictionary<NSObject, NSObject>> = unsafe {
+        msg_send![
+            <NSDictionary<NSObject, NSObject>>::class(),
+            dictionaryWithContentsOfFile: &*info_path,
+        ]
+    };
    let mut x = 0.0;
    if let Some(n) = info.objectForKey(ns_string!("hotx")) {
        if let Ok(n) = n.downcast::<NSNumber>() {
@@ -211,9 +216,9 @@ pub(crate) fn cursor_from_icon(icon: CursorIcon) -> Retained<NSCursor> {
        CursorIcon::EwResize | CursorIcon::ColResize => NSCursor::resizeLeftRightCursor(),
        CursorIcon::NsResize | CursorIcon::RowResize => NSCursor::resizeUpDownCursor(),
        CursorIcon::Help => _helpCursor(),
-        CursorIcon::ZoomIn if available!(macos = 15.0) => NSCursor::zoomInCursor(),
+        CursorIcon::ZoomIn if available!(macos = 15.0) => unsafe { NSCursor::zoomInCursor() },
        CursorIcon::ZoomIn => _zoomInCursor(),
-        CursorIcon::ZoomOut if available!(macos = 15.0) => NSCursor::zoomOutCursor(),
+        CursorIcon::ZoomOut if available!(macos = 15.0) => unsafe { NSCursor::zoomOutCursor() },
        CursorIcon::ZoomOut => _zoomOutCursor(),
        CursorIcon::NeResize => _windowResizeNorthEastCursor(),
        CursorIcon::NwResize => _windowResizeNorthWestCursor(),
--- a/winit-appkit/src/event.rs
+++ b/winit-appkit/src/event.rs
@@ -67,7 +67,9 @@ pub fn get_modifierless_char(scancode: u16) -> Key {

 // Ignores all modifiers except for SHIFT (yes, even ALT is ignored).
 fn get_logical_key_char(ns_event: &NSEvent, modifierless_chars: &str) -> Key {
-    let string = ns_event.charactersIgnoringModifiers().map(|s| s.to_string()).unwrap_or_default();
+    let string = unsafe { ns_event.charactersIgnoringModifiers() }
+        .map(|s| s.to_string())
+        .unwrap_or_default();
    if string.is_empty() {
        // Probably a dead key
        let first_char = modifierless_chars.chars().next();
@@ -83,7 +85,7 @@ pub(crate) fn create_key_event(ns_event: &NSEvent, is_press: bool, is_repeat: bo
    use ElementState::{Pressed, Released};
    let state = if is_press { Pressed } else { Released };

-    let scancode = ns_event.keyCode();
+    let scancode = unsafe { ns_event.keyCode() };
    let mut physical_key = scancode_to_physicalkey(scancode as u32);

    // NOTE: The logical key should heed both SHIFT and ALT if possible.
@@ -93,7 +95,7 @@ pub(crate) fn create_key_event(ns_event: &NSEvent, is_press: bool, is_repeat: bo
    // * Pressing CTRL SHIFT A: logical key should also be "A"
    // This is not easy to tease out of `NSEvent`, but we do our best.

-    let characters = ns_event.characters().map(|s| s.to_string()).unwrap_or_default();
+    let characters = unsafe { ns_event.characters() }.map(|s| s.to_string()).unwrap_or_default();
    let text_with_all_modifiers = if characters.is_empty() {
        None
    } else {
@@ -109,13 +111,13 @@ pub(crate) fn create_key_event(ns_event: &NSEvent, is_press: bool, is_repeat: bo
        // `get_modifierless_char/key_without_modifiers` ignores ALL modifiers.
        let key_without_modifiers = get_modifierless_char(scancode);

-        let modifiers = ns_event.modifierFlags();
+        let modifiers = unsafe { ns_event.modifierFlags() };
        let has_ctrl = modifiers.contains(NSEventModifierFlags::Control);
        let has_cmd = modifiers.contains(NSEventModifierFlags::Command);

        let logical_key = match text_with_all_modifiers.as_ref() {
            // Only checking for ctrl and cmd here, not checking for alt because we DO want to
-            // include its effect in the key. For example if -on the German layout- one
+            // include its effect in the key. For example if -on the Germay layout- one
            // presses alt+8, the logical key should be "{"
            // Also not checking if this is a release event because then this issue would
            // still affect the key release.
@@ -300,15 +302,15 @@ const NX_DEVICERALTKEYMASK: NSEventModifierFlags = NSEventModifierFlags(0x000000
 const NX_DEVICERCTLKEYMASK: NSEventModifierFlags = NSEventModifierFlags(0x00002000);

 pub(super) fn lalt_pressed(event: &NSEvent) -> bool {
-    event.modifierFlags().contains(NX_DEVICELALTKEYMASK)
+    unsafe { event.modifierFlags() }.contains(NX_DEVICELALTKEYMASK)
 }

 pub(super) fn ralt_pressed(event: &NSEvent) -> bool {
-    event.modifierFlags().contains(NX_DEVICERALTKEYMASK)
+    unsafe { event.modifierFlags() }.contains(NX_DEVICERALTKEYMASK)
 }

 pub(super) fn event_mods(event: &NSEvent) -> Modifiers {
-    let flags = event.modifierFlags();
+    let flags = unsafe { event.modifierFlags() };
    let mut state = ModifiersState::empty();
    let mut pressed_mods = ModifiersKeys::empty();

@@ -332,7 +334,8 @@ pub(super) fn event_mods(event: &NSEvent) -> Modifiers {
 }

 pub(super) fn dummy_event() -> Option<Retained<NSEvent>> {
-    NSEvent::otherEventWithType_location_modifierFlags_timestamp_windowNumber_context_subtype_data1_data2(
+    unsafe {
+        NSEvent::otherEventWithType_location_modifierFlags_timestamp_windowNumber_context_subtype_data1_data2(
            NSEventType::ApplicationDefined,
            NSPoint::new(0.0, 0.0),
            NSEventModifierFlags(0),
@@ -343,6 +346,7 @@ pub(super) fn dummy_event() -> Option<Retained<NSEvent>> {
            0,
            0,
        )
+    }
 }

 pub fn physicalkey_to_scancode(physical_key: PhysicalKey) -> Option<u32> {
--- a/winit-appkit/src/event_loop.rs
+++ b/winit-appkit/src/event_loop.rs
@@ -2,9 +2,9 @@ use std::rc::Rc;
 use std::sync::Arc;
 use std::time::{Duration, Instant};

-use objc2::rc::{Retained, autoreleasepool};
+use objc2::rc::{autoreleasepool, Retained};
 use objc2::runtime::ProtocolObject;
-use objc2::{MainThreadMarker, available};
+use objc2::{available, MainThreadMarker};
 use objc2_app_kit::{
    NSApplication, NSApplicationActivationPolicy, NSApplicationDidFinishLaunchingNotification,
    NSApplicationWillTerminateNotification, NSWindow,
@@ -29,8 +29,8 @@ use super::event::dummy_event;
 use super::monitor;
 use super::notification_center::create_observer;
 use super::observer::setup_control_flow_observers;
-use crate::ActivationPolicy;
 use crate::window::Window;
+use crate::ActivationPolicy;

 #[derive(Debug)]
 pub struct ActiveEventLoop {
@@ -191,7 +191,7 @@ impl EventLoop {
        // Override `sendEvent:` on the application to forward to our application state.
        override_send_event(&app);

-        let center = NSNotificationCenter::defaultCenter();
+        let center = unsafe { NSNotificationCenter::defaultCenter() };

        let weak_app_state = Rc::downgrade(&app_state);
        let _did_finish_launching_observer = create_observer(
@@ -232,6 +232,10 @@ impl EventLoop {
        &self.window_target
    }

+    pub fn run_app<A: ApplicationHandler>(mut self, app: A) -> Result<(), EventLoopError> {
+        self.run_app_on_demand(app)
+    }
+
    // NB: we don't base this on `pump_events` because for `MacOs` we can't support
    // `pump_events` elegantly (we just ask to run the loop for a "short" amount of
    // time and so a layered implementation would end up using a lot of CPU due to
--- a/winit-appkit/src/ffi.rs
+++ b/winit-appkit/src/ffi.rs
@@ -6,7 +6,7 @@ use std::ffi::c_void;

 use objc2::ffi::NSInteger;
 use objc2::runtime::AnyObject;
-use objc2_core_foundation::{CFString, CFUUID, cf_type};
+use objc2_core_foundation::{cf_type, CFString, CFUUID};
 use objc2_core_graphics::CGDirectDisplayID;

 pub const IO16BitDirectPixels: &str = "-RRRRRGGGGGBBBBB";
@@ -22,14 +22,14 @@ pub const kIO64BitDirectPixels: &str = "-16R16G16B16";
 // `ApplicationServices`, see:
 // https://developer.apple.com/library/archive/documentation/MacOSX/Conceptual/OSX_Technology_Overview/SystemFrameworks/SystemFrameworks.html#//apple_ref/doc/uid/TP40001067-CH210-BBCFFIEG
 #[link(name = "ApplicationServices", kind = "framework")]
-unsafe extern "C" {
+extern "C" {
    pub fn CGDisplayCreateUUIDFromDisplayID(display: CGDirectDisplayID) -> *mut CFUUID;

    pub fn CGDisplayGetDisplayIDFromUUID(uuid: &CFUUID) -> CGDirectDisplayID;
 }

 #[link(name = "CoreGraphics", kind = "framework")]
-unsafe extern "C" {
+extern "C" {
    // Wildly used private APIs; Apple uses them for their Terminal.app.
    pub fn CGSMainConnectionID() -> *mut AnyObject;
    pub fn CGSSetWindowBackgroundBlurRadius(
@@ -60,7 +60,7 @@ pub const kUCKeyActionDisplay: u16 = 3;
 pub const kUCKeyTranslateNoDeadKeysMask: OptionBits = 1;

 #[link(name = "Carbon", kind = "framework")]
-unsafe extern "C" {
+extern "C" {
    pub static kTISPropertyUnicodeKeyLayoutData: &'static CFString;

    #[allow(non_snake_case)]
--- a/winit-appkit/src/lib.rs
+++ b/winit-appkit/src/lib.rs
@@ -20,7 +20,7 @@
 //! ```
 //! use objc2::rc::Retained;
 //! use objc2::runtime::ProtocolObject;
-//! use objc2::{DefinedClass, MainThreadMarker, MainThreadOnly, define_class, msg_send};
+//! use objc2::{define_class, msg_send, DefinedClass, MainThreadMarker, MainThreadOnly};
 //! use objc2_app_kit::{NSApplication, NSApplicationDelegate};
 //! use objc2_foundation::{NSArray, NSObject, NSObjectProtocol, NSURL};
 //! use winit::event_loop::EventLoop;
--- a/winit-appkit/src/menu.rs
+++ b/winit-appkit/src/menu.rs
@@ -1,8 +1,8 @@
 use objc2::rc::Retained;
 use objc2::runtime::Sel;
-use objc2::{MainThreadMarker, sel};
+use objc2::{sel, MainThreadMarker};
 use objc2_app_kit::{NSApplication, NSEventModifierFlags, NSMenu, NSMenuItem};
-use objc2_foundation::{NSBundle, NSProcessInfo, NSString, ns_string};
+use objc2_foundation::{ns_string, NSBundle, NSProcessInfo, NSString};

 struct KeyEquivalent<'a> {
    key: &'a NSString,
@@ -82,7 +82,7 @@ pub fn initialize(app: &NSApplication) {
    app_menu.addItem(&quit_item);
    app_menu_item.setSubmenu(Some(&app_menu));

-    app.setServicesMenu(Some(&services_menu));
+    unsafe { app.setServicesMenu(Some(&services_menu)) };
    app.setMainMenu(Some(&menubar));
 }

--- a/winit-appkit/src/monitor.rs
+++ b/winit-appkit/src/monitor.rs
@@ -7,16 +7,16 @@ use std::{fmt, ptr};

 use dispatch2::run_on_main;
 use dpi::{LogicalPosition, PhysicalPosition, PhysicalSize};
-use objc2::MainThreadMarker;
 use objc2::rc::Retained;
+use objc2::MainThreadMarker;
 use objc2_app_kit::NSScreen;
 use objc2_core_foundation::{CFArray, CFRetained, CFUUID};
 use objc2_core_graphics::{
    CGDirectDisplayID, CGDisplayBounds, CGDisplayCopyAllDisplayModes, CGDisplayCopyDisplayMode,
    CGDisplayMode, CGDisplayModelNumber, CGGetActiveDisplayList, CGMainDisplayID,
 };
-use objc2_core_video::{CVDisplayLink, CVTimeFlags, kCVReturnSuccess};
-use objc2_foundation::{NSNumber, NSPoint, NSRect, ns_string};
+use objc2_core_video::{kCVReturnSuccess, CVDisplayLink, CVTimeFlags};
+use objc2_foundation::{ns_string, NSNumber, NSPoint, NSRect};
 use tracing::warn;
 use winit_core::monitor::{MonitorHandleProvider, VideoMode};

@@ -65,33 +65,35 @@ impl VideoModeHandle {
        native_mode: NativeDisplayMode,
        refresh_rate_millihertz: Option<NonZeroU32>,
    ) -> Self {
-        // The bit-depth is basically always 32 since macOS 10.12.
-        #[allow(deprecated)]
-        let pixel_encoding =
-            CGDisplayMode::pixel_encoding(Some(&native_mode.0)).unwrap().to_string();
-        let bit_depth = if pixel_encoding.eq_ignore_ascii_case(ffi::IO32BitDirectPixels) {
-            NonZeroU16::new(32)
-        } else if pixel_encoding.eq_ignore_ascii_case(ffi::IO16BitDirectPixels) {
-            NonZeroU16::new(16)
-        } else if pixel_encoding.eq_ignore_ascii_case(ffi::kIO30BitDirectPixels) {
-            NonZeroU16::new(30)
-        } else if pixel_encoding.eq_ignore_ascii_case(ffi::kIO64BitDirectPixels) {
-            NonZeroU16::new(64)
-        } else {
-            warn!(?pixel_encoding, "unknown bit depth");
-            None
-        };
+        unsafe {
+            // The bit-depth is basically always 32 since macOS 10.12.
+            #[allow(deprecated)]
+            let pixel_encoding =
+                CGDisplayMode::pixel_encoding(Some(&native_mode.0)).unwrap().to_string();
+            let bit_depth = if pixel_encoding.eq_ignore_ascii_case(ffi::IO32BitDirectPixels) {
+                NonZeroU16::new(32)
+            } else if pixel_encoding.eq_ignore_ascii_case(ffi::IO16BitDirectPixels) {
+                NonZeroU16::new(16)
+            } else if pixel_encoding.eq_ignore_ascii_case(ffi::kIO30BitDirectPixels) {
+                NonZeroU16::new(30)
+            } else if pixel_encoding.eq_ignore_ascii_case(ffi::kIO64BitDirectPixels) {
+                NonZeroU16::new(64)
+            } else {
+                warn!(?pixel_encoding, "unknown bit depth");
+                None
+            };

-        let mode = VideoMode::new(
-            PhysicalSize::new(
-                CGDisplayMode::pixel_width(Some(&native_mode.0)) as u32,
-                CGDisplayMode::pixel_height(Some(&native_mode.0)) as u32,
-            ),
-            bit_depth,
-            refresh_rate_millihertz,
-        );
+            let mode = VideoMode::new(
+                PhysicalSize::new(
+                    CGDisplayMode::pixel_width(Some(&native_mode.0)) as u32,
+                    CGDisplayMode::pixel_height(Some(&native_mode.0)) as u32,
+                ),
+                bit_depth,
+                refresh_rate_millihertz,
+            );

-        Self { mode, monitor: monitor.clone(), native_mode }
+            VideoModeHandle { mode, monitor: monitor.clone(), native_mode }
+        }
    }
 }

@@ -135,11 +137,11 @@ impl MonitorHandle {

    fn refresh_rate_millihertz(&self) -> Option<NonZeroU32> {
        let current_display_mode =
-            NativeDisplayMode(CGDisplayCopyDisplayMode(self.display_id()).unwrap());
+            NativeDisplayMode(unsafe { CGDisplayCopyDisplayMode(self.display_id()) }.unwrap());
        refresh_rate_millihertz(self.display_id(), &current_display_mode)
    }

-    pub fn video_mode_handles(&self) -> impl Iterator<Item = VideoModeHandle> + 'static {
+    pub fn video_mode_handles(&self) -> impl Iterator<Item = VideoModeHandle> {
        let refresh_rate_millihertz = self.refresh_rate_millihertz();
        let monitor = self.clone();

@@ -157,7 +159,7 @@ impl MonitorHandle {
        };

        modes.into_iter().map(move |mode| {
-            let cg_refresh_rate_hertz = CGDisplayMode::refresh_rate(Some(&mode));
+            let cg_refresh_rate_hertz = unsafe { CGDisplayMode::refresh_rate(Some(&mode)) };

            // CGDisplayModeGetRefreshRate returns 0.0 for any display that
            // isn't a CRT
@@ -200,7 +202,7 @@ impl MonitorHandleProvider for MonitorHandle {
    //
    // <https://github.com/glfw/glfw/blob/57cbded0760a50b9039ee0cb3f3c14f60145567c/src/cocoa_monitor.m#L44-L126>
    fn name(&self) -> Option<std::borrow::Cow<'_, str>> {
-        let screen_num = CGDisplayModelNumber(self.display_id());
+        let screen_num = unsafe { CGDisplayModelNumber(self.display_id()) };
        Some(format!("Monitor #{screen_num}").into())
    }

@@ -208,7 +210,7 @@ impl MonitorHandleProvider for MonitorHandle {
        // This is already in screen coordinates. If we were using `NSScreen`,
        // then a conversion would've been needed:
        // flip_window_screen_coordinates(self.ns_screen(mtm)?.frame())
-        let bounds = CGDisplayBounds(self.display_id());
+        let bounds = unsafe { CGDisplayBounds(self.display_id()) };
        let position = LogicalPosition::new(bounds.origin.x, bounds.origin.y);
        Some(position.to_physical(self.scale_factor()))
    }
@@ -223,7 +225,8 @@ impl MonitorHandleProvider for MonitorHandle {
    }

    fn current_video_mode(&self) -> Option<VideoMode> {
-        let mode = NativeDisplayMode(CGDisplayCopyDisplayMode(self.display_id()).unwrap());
+        let mode =
+            NativeDisplayMode(unsafe { CGDisplayCopyDisplayMode(self.display_id()) }.unwrap());
        let refresh_rate_millihertz = refresh_rate_millihertz(self.display_id(), &mode);
        Some(VideoModeHandle::new(self.clone(), mode, refresh_rate_millihertz).mode)
    }
@@ -261,7 +264,7 @@ pub fn available_monitors() -> VecDeque<MonitorHandle> {

 pub fn primary_monitor() -> MonitorHandle {
    // Display ID just fetched from `CGMainDisplayID`, should be fine to unwrap.
-    MonitorHandle::new(CGMainDisplayID()).expect("invalid display ID")
+    MonitorHandle::new(unsafe { CGMainDisplayID() }).expect("invalid display ID")
 }

 impl fmt::Debug for MonitorHandle {
@@ -312,38 +315,40 @@ pub(crate) fn flip_window_screen_coordinates(frame: NSRect) -> NSPoint {
    // It is intentional that we use `CGMainDisplayID` (as opposed to
    // `NSScreen::mainScreen`), because that's what the screen coordinates
    // are relative to, no matter which display the window is currently on.
-    let main_screen_height = CGDisplayBounds(CGMainDisplayID()).size.height;
+    let main_screen_height = unsafe { CGDisplayBounds(CGMainDisplayID()) }.size.height;

    let y = main_screen_height - frame.size.height - frame.origin.y;
    NSPoint::new(frame.origin.x, y)
 }

 fn refresh_rate_millihertz(id: CGDirectDisplayID, mode: &NativeDisplayMode) -> Option<NonZeroU32> {
-    let refresh_rate = CGDisplayMode::refresh_rate(Some(&mode.0));
-    if refresh_rate > 0.0 {
-        return NonZeroU32::new((refresh_rate * 1000.0).round() as u32);
-    }
+    unsafe {
+        let refresh_rate = CGDisplayMode::refresh_rate(Some(&mode.0));
+        if refresh_rate > 0.0 {
+            return NonZeroU32::new((refresh_rate * 1000.0).round() as u32);
+        }

-    let mut display_link = std::ptr::null_mut();
-    #[allow(deprecated)]
-    if unsafe { CVDisplayLink::create_with_cg_display(id, NonNull::from(&mut display_link)) }
-        != kCVReturnSuccess
-    {
-        return None;
-    }
-    let display_link = unsafe { CFRetained::from_raw(NonNull::new(display_link).unwrap()) };
-    #[allow(deprecated)]
-    let time = display_link.nominal_output_video_refresh_period();
+        let mut display_link = std::ptr::null_mut();
+        #[allow(deprecated)]
+        if CVDisplayLink::create_with_cg_display(id, NonNull::from(&mut display_link))
+            != kCVReturnSuccess
+        {
+            return None;
+        }
+        let display_link = CFRetained::from_raw(NonNull::new(display_link).unwrap());
+        #[allow(deprecated)]
+        let time = display_link.nominal_output_video_refresh_period();

-    // This value is indefinite if an invalid display link was specified
-    if time.flags & CVTimeFlags::IsIndefinite.0 != 0 {
-        return None;
-    }
+        // This value is indefinite if an invalid display link was specified
+        if time.flags & CVTimeFlags::IsIndefinite.0 != 0 {
+            return None;
+        }

-    (time.timeScale as i64)
-        .checked_div(time.timeValue)
-        .map(|v| (v * 1000) as u32)
-        .and_then(NonZeroU32::new)
+        (time.timeScale as i64)
+            .checked_div(time.timeValue)
+            .map(|v| (v * 1000) as u32)
+            .and_then(NonZeroU32::new)
+    }
 }

 #[cfg(test)]
@@ -352,10 +357,8 @@ mod tests {

    #[test]
    fn uuid_stable() {
-        let primary_id = CGMainDisplayID();
-
-        let handle_a = MonitorHandle::new(primary_id).unwrap();
-        let handle_b = MonitorHandle::new(primary_id).unwrap();
+        let handle_a = MonitorHandle::new(1).unwrap();
+        let handle_b = MonitorHandle::new(1).unwrap();
        assert_eq!(handle_a, handle_b);
        assert_eq!(handle_a.display_id(), handle_b.display_id());
        assert_eq!(handle_a.uuid(), handle_b.uuid());
@@ -370,10 +373,8 @@ mod tests {
    /// Test the MonitorHandle::new fallback.
    #[test]
    fn monitorhandle_from_zero() {
-        let primary_id = CGMainDisplayID();
-
        let handle0 = MonitorHandle::new(0).unwrap();
-        let handle1 = MonitorHandle::new(primary_id).unwrap();
+        let handle1 = MonitorHandle::new(1).unwrap();
        assert_eq!(handle0, handle1);
        assert_eq!(handle0.display_id(), handle1.display_id());
        assert_eq!(handle0.uuid(), handle1.uuid());
@@ -394,7 +395,7 @@ mod tests {
        // Assertion failed: (did_initialize), function CGS_REQUIRE_INIT, file CGInitialization.c, line 44.
        // ```
        // See https://github.com/JXA-Cookbook/JXA-Cookbook/issues/27#issuecomment-277517668
-        let _ = CGMainDisplayID();
+        let _ = unsafe { CGMainDisplayID() };

        let handle = MonitorHandle(CFUUID::new(None).unwrap());
        assert_eq!(handle.display_id(), 0);
--- a/winit-appkit/src/observer.rs
+++ b/winit-appkit/src/observer.rs
@@ -9,9 +9,9 @@ use std::time::Instant;

 use objc2::MainThreadMarker;
 use objc2_core_foundation::{
-    CFAbsoluteTimeGetCurrent, CFIndex, CFRetained, CFRunLoop, CFRunLoopActivity, CFRunLoopObserver,
-    CFRunLoopObserverCallBack, CFRunLoopObserverContext, CFRunLoopTimer, kCFRunLoopCommonModes,
-    kCFRunLoopDefaultMode,
+    kCFRunLoopCommonModes, kCFRunLoopDefaultMode, CFAbsoluteTimeGetCurrent, CFIndex, CFRetained,
+    CFRunLoop, CFRunLoopActivity, CFRunLoopObserver, CFRunLoopObserverCallBack,
+    CFRunLoopObserverContext, CFRunLoopTimer,
 };
 use tracing::error;

--- a/winit-appkit/src/util.rs
+++ b/winit-appkit/src/util.rs
@@ -3,7 +3,9 @@ use tracing::trace;
 use winit_core::error::OsError;

 macro_rules! os_error {
-    ($error:expr) => {{ winit_core::error::OsError::new(line!(), file!(), $error) }};
+    ($error:expr) => {{
+        winit_core::error::OsError::new(line!(), file!(), $error)
+    }};
 }

 macro_rules! trace_scope {
@@ -34,5 +36,9 @@ impl Drop for TraceGuard {

 #[track_caller]
 pub(crate) fn cgerr(err: CGError) -> Result<(), OsError> {
-    if err == CGError::Success { Ok(()) } else { Err(os_error!(format!("CGError {err:?}"))) }
+    if err == CGError::Success {
+        Ok(())
+    } else {
+        Err(os_error!(format!("CGError {err:?}")))
+    }
 }
--- a/winit-appkit/src/view.rs
+++ b/winit-appkit/src/view.rs
@@ -7,7 +7,7 @@ use std::rc::Rc;
 use dpi::{LogicalPosition, LogicalSize};
 use objc2::rc::Retained;
 use objc2::runtime::{AnyObject, Sel};
-use objc2::{DefinedClass, MainThreadMarker, define_class, msg_send};
+use objc2::{define_class, msg_send, DefinedClass, MainThreadMarker};
 use objc2_app_kit::{
    NSApplication, NSCursor, NSEvent, NSEventPhase, NSResponder, NSTextInputClient,
    NSTrackingRectTag, NSView, NSWindow,
@@ -292,7 +292,7 @@ define_class!(
                self.queue_event(WindowEvent::Ime(Ime::Enabled));
            }

-            if self.hasMarkedText() {
+            if unsafe { self.hasMarkedText() } {
                self.ivars().ime_state.set(ImeState::Preedit);
            } else {
                // In case the preedit was cleared, set IME into the Ground state.
@@ -305,8 +305,8 @@ define_class!(
                None
            } else {
                // Convert the selected range from UTF-16 indices to UTF-8 indices.
-                let sub_string_a = string.substringToIndex(selected_range.location);
-                let sub_string_b = string.substringToIndex(selected_range.end());
+                let sub_string_a = unsafe { string.substringToIndex(selected_range.location) };
+                let sub_string_b = unsafe { string.substringToIndex(selected_range.end()) };
                let lowerbound_utf8 = sub_string_a.len();
                let upperbound_utf8 = sub_string_b.len();
                Some((lowerbound_utf8, upperbound_utf8))
@@ -391,7 +391,7 @@ define_class!(
            let is_control = string.chars().next().is_some_and(|c| c.is_control());

            // Commit only if we have marked text.
-            if self.hasMarkedText() && self.is_ime_enabled() && !is_control {
+            if unsafe { self.hasMarkedText() } && self.is_ime_enabled() && !is_control {
                self.queue_event(WindowEvent::Ime(Ime::Preedit(String::new(), None)));
                self.queue_event(WindowEvent::Ime(Ime::Commit(string)));
                self.ivars().ime_state.set(ImeState::Committed);
@@ -414,7 +414,8 @@ define_class!(

            self.ivars().forward_key_to_app.set(true);

-            if self.hasMarkedText() && self.ivars().ime_state.get() == ImeState::Preedit {
+            if unsafe { self.hasMarkedText() } && self.ivars().ime_state.get() == ImeState::Preedit
+            {
                // Leave preedit so that we also report the key-up for this key.
                self.ivars().ime_state.set(ImeState::Ground);
            }
@@ -466,7 +467,7 @@ define_class!(
            // is not handled by IME and should be handled by the application)
            if self.ivars().ime_capabilities.get().is_some() {
                let events_for_nsview = NSArray::from_slice(&[&*event]);
-                self.interpretKeyEvents(&events_for_nsview);
+                unsafe { self.interpretKeyEvents(&events_for_nsview) };

                // If the text was committed we must treat the next keyboard event as IME related.
                if self.ivars().ime_state.get() == ImeState::Committed {
@@ -489,7 +490,7 @@ define_class!(
            };

            if !had_ime_input || self.ivars().forward_key_to_app.get() {
-                let key_event = create_key_event(&event, true, event.isARepeat());
+                let key_event = create_key_event(&event, true, unsafe { event.isARepeat() });
                self.queue_event(WindowEvent::KeyboardInput {
                    device_id: None,
                    event: key_event,
@@ -556,7 +557,7 @@ define_class!(
                .expect("could not find current event");

            self.update_modifiers(&event, false);
-            let event = create_key_event(&event, true, event.isARepeat());
+            let event = create_key_event(&event, true, unsafe { event.isARepeat() });

            self.queue_event(WindowEvent::KeyboardInput {
                device_id: None,
@@ -675,8 +676,8 @@ define_class!(
            self.mouse_motion(event);

            let delta = {
-                let (x, y) = (event.scrollingDeltaX(), event.scrollingDeltaY());
-                if event.hasPreciseScrollingDeltas() {
+                let (x, y) = unsafe { (event.scrollingDeltaX(), event.scrollingDeltaY()) };
+                if unsafe { event.hasPreciseScrollingDeltas() } {
                    let delta = LogicalPosition::new(x, y).to_physical(self.scale_factor());
                    MouseScrollDelta::PixelDelta(delta)
                } else {
@@ -689,10 +690,10 @@ define_class!(
            // momentum phase is recorded (or rather, the started/ended cases of the
            // momentum phase) then we report the touch phase.
            #[allow(non_upper_case_globals)]
-            let phase = match event.momentumPhase() {
+            let phase = match unsafe { event.momentumPhase() } {
                NSEventPhase::MayBegin | NSEventPhase::Began => TouchPhase::Started,
                NSEventPhase::Ended | NSEventPhase::Cancelled => TouchPhase::Ended,
-                _ => match event.phase() {
+                _ => match unsafe { event.phase() } {
                    NSEventPhase::MayBegin | NSEventPhase::Began => TouchPhase::Started,
                    NSEventPhase::Ended | NSEventPhase::Cancelled => TouchPhase::Ended,
                    _ => TouchPhase::Moved,
@@ -714,7 +715,7 @@ define_class!(
            self.mouse_motion(event);

            #[allow(non_upper_case_globals)]
-            let phase = match event.phase() {
+            let phase = match unsafe { event.phase() } {
                NSEventPhase::Began => TouchPhase::Started,
                NSEventPhase::Changed => TouchPhase::Moved,
                NSEventPhase::Cancelled => TouchPhase::Cancelled,
@@ -724,7 +725,7 @@ define_class!(

            self.queue_event(WindowEvent::PinchGesture {
                device_id: None,
-                delta: event.magnification(),
+                delta: unsafe { event.magnification() },
                phase,
            });
        }
@@ -745,7 +746,7 @@ define_class!(
            self.mouse_motion(event);

            #[allow(non_upper_case_globals)]
-            let phase = match event.phase() {
+            let phase = match unsafe { event.phase() } {
                NSEventPhase::Began => TouchPhase::Started,
                NSEventPhase::Changed => TouchPhase::Moved,
                NSEventPhase::Cancelled => TouchPhase::Cancelled,
@@ -755,7 +756,7 @@ define_class!(

            self.queue_event(WindowEvent::RotationGesture {
                device_id: None,
-                delta: event.rotation(),
+                delta: unsafe { event.rotation() },
                phase,
            });
        }
@@ -766,8 +767,8 @@ define_class!(

            self.queue_event(WindowEvent::TouchpadPressure {
                device_id: None,
-                pressure: event.pressure(),
-                stage: event.stage() as i64,
+                pressure: unsafe { event.pressure() },
+                stage: unsafe { event.stage() } as i64,
            });
        }

@@ -930,8 +931,8 @@ impl WinitView {
        // later will work though, since the flags are attached to the event and contain valid
        // information.
        'send_event: {
-            if is_flags_changed_event && ns_event.keyCode() != 0 {
-                let scancode = ns_event.keyCode();
+            if is_flags_changed_event && unsafe { ns_event.keyCode() } != 0 {
+                let scancode = unsafe { ns_event.keyCode() };
                let physical_key = scancode_to_physicalkey(scancode as u32);

                let logical_key = code_to_key(physical_key, scancode);
@@ -1063,7 +1064,7 @@ impl WinitView {
            || view_point.x > frame.size.width
            || view_point.y > frame.size.height
        {
-            let mouse_buttons_down = NSEvent::pressedMouseButtons();
+            let mouse_buttons_down = unsafe { NSEvent::pressedMouseButtons() };
            if mouse_buttons_down == 0 {
                // Point is outside of the client area (view) and no buttons are pressed
                return;
@@ -1081,7 +1082,7 @@ impl WinitView {
    }

    fn mouse_view_point(&self, event: &NSEvent) -> LogicalPosition<f64> {
-        let window_point = event.locationInWindow();
+        let window_point = unsafe { event.locationInWindow() };
        let view_point = self.convertPoint_fromView(window_point, None);

        LogicalPosition::new(view_point.x, view_point.y)
@@ -1095,11 +1096,14 @@ fn mouse_button(event: &NSEvent) -> MouseButton {
    // For the other events, it's always set to 0.
    // MacOS only defines the left, right and middle buttons, 3..=31 are left as generic buttons,
    // but 3 and 4 are very commonly used as Back and Forward by hardware vendors and applications.
-    let b: isize = event.buttonNumber();
-    b.try_into()
-        .ok()
-        .and_then(MouseButton::try_from_u8)
-        .expect("expected MacOS button number in the range 0..=31")
+    match unsafe { event.buttonNumber() } {
+        0 => MouseButton::Left,
+        1 => MouseButton::Right,
+        2 => MouseButton::Middle,
+        3 => MouseButton::Back,
+        4 => MouseButton::Forward,
+        n => MouseButton::Other(n as u16),
+    }
 }

 // NOTE: to get option as alt working we need to rewrite events
@@ -1116,10 +1120,12 @@ fn replace_event(event: &NSEvent, option_as_alt: OptionAsAlt) -> Retained<NSEven
        && !ev_mods.meta_key();

    if ignore_alt_characters {
-        let ns_chars =
-            event.charactersIgnoringModifiers().expect("expected characters to be non-null");
+        let ns_chars = unsafe {
+            event.charactersIgnoringModifiers().expect("expected characters to be non-null")
+        };

-        NSEvent::keyEventWithType_location_modifierFlags_timestamp_windowNumber_context_characters_charactersIgnoringModifiers_isARepeat_keyCode(
+        unsafe {
+            NSEvent::keyEventWithType_location_modifierFlags_timestamp_windowNumber_context_characters_charactersIgnoringModifiers_isARepeat_keyCode(
                event.r#type(),
                event.locationInWindow(),
                event.modifierFlags(),
@@ -1132,6 +1138,7 @@ fn replace_event(event: &NSEvent, option_as_alt: OptionAsAlt) -> Retained<NSEven
                event.keyCode(),
            )
            .unwrap()
+        }
    } else {
        event.copy()
    }
--- a/winit-appkit/src/window.rs
+++ b/winit-appkit/src/window.rs
@@ -4,8 +4,8 @@ use std::sync::Arc;

 use dispatch2::MainThreadBound;
 use dpi::{Position, Size};
-use objc2::rc::{Retained, autoreleasepool};
-use objc2::{MainThreadMarker, Message, define_class};
+use objc2::rc::{autoreleasepool, Retained};
+use objc2::{define_class, MainThreadMarker, Message};
 use objc2_app_kit::{NSPanel, NSResponder, NSWindow};
 use objc2_foundation::NSObject;
 use winit_core::cursor::Cursor;
--- a/winit-appkit/src/window_delegate.rs
+++ b/winit-appkit/src/window_delegate.rs
@@ -10,36 +10,34 @@ use dpi::{
    LogicalInsets, LogicalPosition, LogicalSize, PhysicalInsets, PhysicalPosition, PhysicalSize,
    Position, Size,
 };
-use objc2::rc::{Retained, autoreleasepool};
+use objc2::rc::{autoreleasepool, Retained};
 use objc2::runtime::{AnyObject, ProtocolObject};
 use objc2::{
-    ClassType, DefinedClass, MainThreadMarker, MainThreadOnly, Message, available, define_class,
-    msg_send, sel,
+    available, define_class, msg_send, sel, ClassType, DefinedClass, MainThreadMarker,
+    MainThreadOnly, Message,
 };
 use objc2_app_kit::{
    NSAppKitVersionNumber, NSAppKitVersionNumber10_12, NSAppearance, NSAppearanceCustomization,
    NSAppearanceNameAqua, NSApplication, NSApplicationPresentationOptions, NSBackingStoreType,
-    NSColor, NSDraggingDestination, NSDraggingInfo, NSRequestUserAttentionType, NSScreen,
-    NSToolbar, NSView, NSViewFrameDidChangeNotification, NSWindow, NSWindowButton,
-    NSWindowDelegate, NSWindowLevel, NSWindowOcclusionState, NSWindowOrderingMode,
-    NSWindowSharingType, NSWindowStyleMask, NSWindowTabbingMode, NSWindowTitleVisibility,
-    NSWindowToolbarStyle,
+    NSColor, NSDraggingDestination, NSDraggingInfo, NSFilenamesPboardType,
+    NSRequestUserAttentionType, NSScreen, NSToolbar, NSView, NSViewFrameDidChangeNotification,
+    NSWindow, NSWindowButton, NSWindowDelegate, NSWindowFullScreenButton, NSWindowLevel,
+    NSWindowOcclusionState, NSWindowOrderingMode, NSWindowSharingType, NSWindowStyleMask,
+    NSWindowTabbingMode, NSWindowTitleVisibility, NSWindowToolbarStyle,
 };
-#[allow(deprecated)]
-use objc2_app_kit::{NSFilenamesPboardType, NSWindowFullScreenButton};
 use objc2_core_foundation::{CGFloat, CGPoint};
 use objc2_core_graphics::{
-    CGAcquireDisplayFadeReservation, CGAssociateMouseAndMouseCursorPosition, CGDisplayCapture,
-    CGDisplayFade, CGDisplayRelease, CGDisplaySetDisplayMode, CGReleaseDisplayFadeReservation,
-    CGRestorePermanentDisplayConfiguration, CGShieldingWindowLevel, CGWarpMouseCursorPosition,
    kCGDisplayBlendNormal, kCGDisplayBlendSolidColor, kCGDisplayFadeReservationInvalidToken,
-    kCGFloatingWindowLevel, kCGNormalWindowLevel,
+    kCGFloatingWindowLevel, kCGNormalWindowLevel, CGAcquireDisplayFadeReservation,
+    CGAssociateMouseAndMouseCursorPosition, CGDisplayCapture, CGDisplayFade, CGDisplayRelease,
+    CGDisplaySetDisplayMode, CGReleaseDisplayFadeReservation,
+    CGRestorePermanentDisplayConfiguration, CGShieldingWindowLevel, CGWarpMouseCursorPosition,
 };
 use objc2_foundation::{
-    NSArray, NSDictionary, NSEdgeInsets, NSKeyValueChangeKey, NSKeyValueChangeNewKey,
+    ns_string, NSArray, NSDictionary, NSEdgeInsets, NSKeyValueChangeKey, NSKeyValueChangeNewKey,
    NSKeyValueChangeOldKey, NSKeyValueObservingOptions, NSNotificationCenter, NSObject,
    NSObjectNSDelayedPerforming, NSObjectNSKeyValueObserverRegistration, NSObjectProtocol, NSPoint,
-    NSRect, NSSize, NSString, ns_string,
+    NSRect, NSSize, NSString,
 };
 use tracing::{trace, warn};
 use winit_core::cursor::Cursor;
@@ -53,13 +51,13 @@ use winit_core::window::{
 };

 use super::app_state::AppState;
-use super::cursor::{CustomCursor, cursor_from_icon};
+use super::cursor::{cursor_from_icon, CustomCursor};
 use super::ffi;
-use super::monitor::{self, MonitorHandle, flip_window_screen_coordinates, get_display_id};
+use super::monitor::{self, flip_window_screen_coordinates, get_display_id, MonitorHandle};
 use super::observer::RunLoop;
 use super::util::cgerr;
 use super::view::WinitView;
-use super::window::{WinitPanel, WinitWindow, window_id};
+use super::window::{window_id, WinitPanel, WinitWindow};
 use crate::{OptionAsAlt, WindowAttributesMacOS, WindowExtMacOS};

 #[derive(Debug)]
@@ -352,22 +350,18 @@ define_class!(

            use std::path::PathBuf;

-            let pb = sender.draggingPasteboard();
-
-            #[allow(deprecated)]
-            let property_list = match pb.propertyListForType(unsafe { NSFilenamesPboardType }) {
-                Some(property_list) => property_list,
-                None => return false.into(),
-            };
-
-            let paths = property_list
-                .downcast::<NSArray>()
+            let pb = unsafe { sender.draggingPasteboard() };
+            let filenames = pb
+                .propertyListForType(unsafe { NSFilenamesPboardType })
                .unwrap()
+                .downcast::<NSArray>()
+                .unwrap();
+            let paths = filenames
                .into_iter()
                .map(|file| PathBuf::from(file.downcast::<NSString>().unwrap().to_string()))
                .collect();

-            let dl = sender.draggingLocation();
+            let dl = unsafe { sender.draggingLocation() };
            let dl = self.view().convertPoint_fromView(dl, None);
            let position =
                LogicalPosition::<f64>::from((dl.x, dl.y)).to_physical(self.scale_factor());
@@ -389,7 +383,7 @@ define_class!(
        fn dragging_updated(&self, sender: &ProtocolObject<dyn NSDraggingInfo>) -> bool {
            trace_scope!("draggingUpdated:");

-            let dl = sender.draggingLocation();
+            let dl = unsafe { sender.draggingLocation() };
            let dl = self.view().convertPoint_fromView(dl, None);
            let position =
                LogicalPosition::<f64>::from((dl.x, dl.y)).to_physical(self.scale_factor());
@@ -413,22 +407,18 @@ define_class!(

            use std::path::PathBuf;

-            let pb = sender.draggingPasteboard();
-
-            #[allow(deprecated)]
-            let property_list = match pb.propertyListForType(unsafe { NSFilenamesPboardType }) {
-                Some(property_list) => property_list,
-                None => return false.into(),
-            };
-
-            let paths = property_list
-                .downcast::<NSArray>()
+            let pb = unsafe { sender.draggingPasteboard() };
+            let filenames = pb
+                .propertyListForType(unsafe { NSFilenamesPboardType })
                .unwrap()
+                .downcast::<NSArray>()
+                .unwrap();
+            let paths = filenames
                .into_iter()
                .map(|file| PathBuf::from(file.downcast::<NSString>().unwrap().to_string()))
                .collect();

-            let dl = sender.draggingLocation();
+            let dl = unsafe { sender.draggingLocation() };
            let dl = self.view().convertPoint_fromView(dl, None);
            let position =
                LogicalPosition::<f64>::from((dl.x, dl.y)).to_physical(self.scale_factor());
@@ -450,7 +440,7 @@ define_class!(
            trace_scope!("draggingExited:");

            let position = sender.map(|sender| {
-                let dl = sender.draggingLocation();
+                let dl = unsafe { sender.draggingLocation() };
                let dl = self.view().convertPoint_fromView(dl, None);
                LogicalPosition::<f64>::from((dl.x, dl.y)).to_physical(self.scale_factor())
            });
@@ -487,12 +477,12 @@ define_class!(
                let old = old.downcast::<NSAppearance>().unwrap();
                let new = new.downcast::<NSAppearance>().unwrap();

-                trace!(old = %old.name(), new = %new.name(), "effectiveAppearance changed");
+                trace!(old = %unsafe { old.name() }, new = %unsafe { new.name() }, "effectiveAppearance changed");

                // Ignore the change if the window's theme is customized by the user (since in that
                // case the `effectiveAppearance` is only emitted upon said customization, and then
                // it's triggered directly by a user action, and we don't want to emit the event).
-                if self.window().appearance().is_some() {
+                if unsafe { self.window().appearance() }.is_some() {
                    return;
                }

@@ -515,7 +505,9 @@ define_class!(

 impl Drop for WindowDelegate {
    fn drop(&mut self) {
-        unsafe { self.window().removeObserver_forKeyPath(self, ns_string!("effectiveAppearance")) };
+        unsafe {
+            self.window().removeObserver_forKeyPath(self, ns_string!("effectiveAppearance"));
+        }
    }
 }

@@ -674,10 +666,12 @@ fn new_window(
            window.setMovableByWindowBackground(true);
        }
        if macos_attrs.unified_titlebar {
-            // The toolbar style is ignored if there is no toolbar, so it is
-            // necessary to add one.
-            window.setToolbar(Some(&NSToolbar::new(mtm)));
-            window.setToolbarStyle(NSWindowToolbarStyle::Unified);
+            unsafe {
+                // The toolbar style is ignored if there is no toolbar, so it is
+                // necessary to add one.
+                window.setToolbar(Some(&NSToolbar::new(mtm)));
+                window.setToolbarStyle(NSWindowToolbarStyle::Unified);
+            }
        }

        if !attrs.enabled_buttons.contains(WindowButtons::MAXIMIZE) {
@@ -726,7 +720,7 @@ fn new_window(
        view.setPostsFrameChangedNotifications(true);
        // `setPostsFrameChangedNotifications` posts the notification immediately, so register the
        // observer _after_, again so that the event isn't triggered initially.
-        let notification_center = NSNotificationCenter::defaultCenter();
+        let notification_center = unsafe { NSNotificationCenter::defaultCenter() };
        unsafe {
            notification_center.addObserver_selector_name_object(
                &view,
@@ -739,11 +733,10 @@ fn new_window(
        if attrs.transparent {
            window.setOpaque(false);
            // See `set_transparent` for details on why we do this.
-            window.setBackgroundColor(Some(&NSColor::clearColor()));
+            window.setBackgroundColor(unsafe { Some(&NSColor::clearColor()) });
        }

        // register for drag and drop operations.
-        #[allow(deprecated)]
        window.registerForDraggedTypes(&NSArray::from_slice(&[unsafe { NSFilenamesPboardType }]));

        Some(window)
@@ -797,7 +790,7 @@ impl WindowDelegate {
        let scale_factor = window.backingScaleFactor() as _;

        if let Some(appearance) = theme_to_appearance(attrs.preferred_theme) {
-            window.setAppearance(Some(&appearance));
+            unsafe { window.setAppearance(Some(&appearance)) };
        }

        let delegate = mtm.alloc().set_ivars(State {
@@ -952,8 +945,11 @@ impl WindowDelegate {
        // transparent, as in that case, the transparent contents will just be drawn on top of
        // the background color. As such, to allow the window to be transparent, we must also set
        // the background color to one with an empty alpha channel.
-        let color =
-            if transparent { NSColor::clearColor() } else { NSColor::windowBackgroundColor() };
+        let color = if transparent {
+            unsafe { NSColor::clearColor() }
+        } else {
+            unsafe { NSColor::windowBackgroundColor() }
+        };

        self.window().setBackgroundColor(Some(&color));
    }
@@ -962,7 +958,7 @@ impl WindowDelegate {
        // NOTE: in general we want to specify the blur radius, but the choice of 80
        // should be a reasonable default.
        let radius = if blur { 80 } else { 0 };
-        let window_number = self.window().windowNumber();
+        let window_number = unsafe { self.window().windowNumber() };
        unsafe {
            ffi::CGSSetWindowBackgroundBlurRadius(
                ffi::CGSMainConnectionID(),
@@ -1021,7 +1017,7 @@ impl WindowDelegate {
            NSPoint::new(position.x, position.y),
            self.window().frame().size,
        ));
-        self.window().setFrameOrigin(point);
+        unsafe { self.window().setFrameOrigin(point) };
    }

    #[inline]
@@ -1043,15 +1039,17 @@ impl WindowDelegate {
        let insets = if self.view().respondsToSelector(sel!(safeAreaInsets)) {
            // Includes NSWindowStyleMask::FullSizeContentView by default, and the notch because
            // we've set it up with `additionalSafeAreaInsets`.
-            self.view().safeAreaInsets()
+            unsafe { self.view().safeAreaInsets() }
        } else {
            // If `safeAreaInsets` is not available, we'll have to do the calculation ourselves.

-            let window_rect = self.window().convertRectFromScreen(
-                self.window().contentRectForFrameRect(self.window().frame()),
-            );
+            let window_rect = unsafe {
+                self.window().convertRectFromScreen(
+                    self.window().contentRectForFrameRect(self.window().frame()),
+                )
+            };
            // This includes NSWindowStyleMask::FullSizeContentView.
-            let layout_rect = self.window().contentLayoutRect();
+            let layout_rect = unsafe { self.window().contentLayoutRect() };

            // Calculate the insets from window coordinates in AppKit's coordinate system.
            NSEdgeInsets {
@@ -1081,7 +1079,7 @@ impl WindowDelegate {
        let min_size = dimensions.to_logical::<CGFloat>(self.scale_factor());

        let min_size = NSSize::new(min_size.width, min_size.height);
-        self.window().setContentMinSize(min_size);
+        unsafe { self.window().setContentMinSize(min_size) };

        // If necessary, resize the window to match constraint
        let mut current_size = self.window().contentRectForFrameRect(self.window().frame()).size;
@@ -1103,7 +1101,7 @@ impl WindowDelegate {
        let max_size = dimensions.to_logical::<CGFloat>(scale_factor);

        let max_size = NSSize::new(max_size.width, max_size.height);
-        self.window().setContentMaxSize(max_size);
+        unsafe { self.window().setContentMaxSize(max_size) };

        // If necessary, resize the window to match constraint
        let mut current_size = self.window().contentRectForFrameRect(self.window().frame()).size;
@@ -1243,12 +1241,12 @@ impl WindowDelegate {
            CursorGrabMode::Locked => false,
            CursorGrabMode::None => true,
            CursorGrabMode::Confined => {
-                return Err(NotSupportedError::new("confined cursor is not supported").into());
+                return Err(NotSupportedError::new("confined cursor is not supported").into())
            },
        };

        // TODO: Do this for real https://stackoverflow.com/a/40922095/5435443
-        cgerr(CGAssociateMouseAndMouseCursorPosition(associate_mouse_cursor))?;
+        cgerr(unsafe { CGAssociateMouseAndMouseCursorPosition(associate_mouse_cursor) })?;

        Ok(())
    }
@@ -1276,8 +1274,8 @@ impl WindowDelegate {
            x: window_position.x + cursor_position.x,
            y: window_position.y + cursor_position.y,
        };
-        cgerr(CGWarpMouseCursorPosition(point))?;
-        cgerr(CGAssociateMouseAndMouseCursorPosition(true))?;
+        cgerr(unsafe { CGWarpMouseCursorPosition(point) })?;
+        cgerr(unsafe { CGAssociateMouseAndMouseCursorPosition(true) })?;

        Ok(())
    }
@@ -1358,7 +1356,7 @@ impl WindowDelegate {
        if minimized {
            self.window().miniaturize(Some(self));
        } else {
-            self.window().deminiaturize(Some(self));
+            unsafe { self.window().deminiaturize(Some(self)) };
        }
    }

@@ -1452,7 +1450,7 @@ impl WindowDelegate {

            let old_screen = self.window().screen().unwrap();
            if old_screen != new_screen {
-                self.window().setFrameOrigin(new_screen.frame().origin);
+                unsafe { self.window().setFrameOrigin(new_screen.frame().origin) };
            }
        }

@@ -1477,22 +1475,24 @@ impl WindowDelegate {
                self.ivars().save_presentation_opts.replace(Some(app.presentationOptions()));
            }

-            // Fade to black (and wait for the fade to complete) to hide the
-            // flicker from capturing the display and switching display mode
-            if cgerr(unsafe { CGAcquireDisplayFadeReservation(5.0, &mut fade_token) }).is_ok() {
-                CGDisplayFade(
-                    fade_token,
-                    0.3,
-                    kCGDisplayBlendNormal,
-                    kCGDisplayBlendSolidColor,
-                    0.0,
-                    0.0,
-                    0.0,
-                    true,
-                );
-            }
+            unsafe {
+                // Fade to black (and wait for the fade to complete) to hide the
+                // flicker from capturing the display and switching display mode
+                if cgerr(CGAcquireDisplayFadeReservation(5.0, &mut fade_token)).is_ok() {
+                    CGDisplayFade(
+                        fade_token,
+                        0.3,
+                        kCGDisplayBlendNormal,
+                        kCGDisplayBlendSolidColor,
+                        0.0,
+                        0.0,
+                        0.0,
+                        true,
+                    );
+                }

-            cgerr(CGDisplayCapture(display_id)).unwrap();
+                cgerr(CGDisplayCapture(display_id)).unwrap();
+            }

            let monitor = monitor.cast_ref::<MonitorHandle>().unwrap();
            let video_mode =
@@ -1501,25 +1501,25 @@ impl WindowDelegate {
                    None => return,
                };

-            cgerr(unsafe {
-                CGDisplaySetDisplayMode(display_id, Some(&video_mode.native_mode.0), None)
-            })
-            .expect("failed to set video mode");
+            unsafe {
+                cgerr(CGDisplaySetDisplayMode(display_id, Some(&video_mode.native_mode.0), None))
+                    .expect("failed to set video mode");

-            // After the display has been configured, fade back in
-            // asynchronously
-            if fade_token != kCGDisplayFadeReservationInvalidToken {
-                CGDisplayFade(
-                    fade_token,
-                    0.6,
-                    kCGDisplayBlendSolidColor,
-                    kCGDisplayBlendNormal,
-                    0.0,
-                    0.0,
-                    0.0,
-                    false,
-                );
-                CGReleaseDisplayFadeReservation(fade_token);
+                // After the display has been configured, fade back in
+                // asynchronously
+                if fade_token != kCGDisplayFadeReservationInvalidToken {
+                    CGDisplayFade(
+                        fade_token,
+                        0.6,
+                        kCGDisplayBlendSolidColor,
+                        kCGDisplayBlendNormal,
+                        0.0,
+                        0.0,
+                        0.0,
+                        false,
+                    );
+                    CGReleaseDisplayFadeReservation(fade_token);
+                }
            }
        }

@@ -1582,7 +1582,7 @@ impl WindowDelegate {
                    | NSApplicationPresentationOptions::HideMenuBar;
                app.setPresentationOptions(presentation_options);

-                let window_level = CGShieldingWindowLevel() as NSWindowLevel + 1;
+                let window_level = unsafe { CGShieldingWindowLevel() } as NSWindowLevel + 1;
                self.window().setLevel(window_level);
            },
            (Some(Fullscreen::Exclusive(monitor, _)), Some(Fullscreen::Borderless(_))) => {
@@ -1797,8 +1797,9 @@ impl WindowDelegate {
    }

    pub fn theme(&self) -> Option<Theme> {
-        self.window().appearance().map(|appearance| appearance_to_theme(&appearance)).or_else(
-            || {
+        unsafe { self.window().appearance() }
+            .map(|appearance| appearance_to_theme(&appearance))
+            .or_else(|| {
                let mtm = MainThreadMarker::from(self);
                let app = NSApplication::sharedApplication(mtm);

@@ -1807,12 +1808,11 @@ impl WindowDelegate {
                } else {
                    Some(Theme::Light)
                }
-            },
-        )
+            })
    }

    pub fn set_theme(&self, theme: Option<Theme>) {
-        self.window().setAppearance(theme_to_appearance(theme).as_deref());
+        unsafe { self.window().setAppearance(theme_to_appearance(theme).as_deref()) };
    }

    #[inline]
@@ -1836,8 +1836,10 @@ impl WindowDelegate {
 fn restore_and_release_display(monitor: &MonitorHandle) {
    let available_monitors = monitor::available_monitors();
    if available_monitors.contains(monitor) {
-        CGRestorePermanentDisplayConfiguration();
-        cgerr(CGDisplayRelease(monitor.native_id() as _)).unwrap();
+        unsafe {
+            CGRestorePermanentDisplayConfiguration();
+            cgerr(CGDisplayRelease(monitor.native_id() as _)).unwrap();
+        };
    } else {
        warn!(
            monitor = monitor.name().map(|name| name.to_string()),
@@ -1899,7 +1901,7 @@ impl WindowExtMacOS for WindowDelegate {

            // Configure the safe area rectangle, to ensure that we don't obscure the notch.
            if NSScreen::class().responds_to(sel!(safeAreaInsets)) {
-                self.view().setAdditionalSafeAreaInsets(screen.safeAreaInsets());
+                unsafe { self.view().setAdditionalSafeAreaInsets(screen.safeAreaInsets()) };
            }

            // Fullscreen windows can't be resized, minimized, or moved
@@ -1918,12 +1920,14 @@ impl WindowExtMacOS for WindowDelegate {
            }

            if NSScreen::class().responds_to(sel!(safeAreaInsets)) {
-                self.view().setAdditionalSafeAreaInsets(NSEdgeInsets {
-                    top: 0.0,
-                    left: 0.0,
-                    bottom: 0.0,
-                    right: 0.0,
-                });
+                unsafe {
+                    self.view().setAdditionalSafeAreaInsets(NSEdgeInsets {
+                        top: 0.0,
+                        left: 0.0,
+                        bottom: 0.0,
+                        right: 0.0,
+                    });
+                }
            }

            self.window().setFrame_display(frame, true);
@@ -1961,7 +1965,7 @@ impl WindowExtMacOS for WindowDelegate {

    #[inline]
    fn select_previous_tab(&self) {
-        self.window().selectPreviousTab(None)
+        unsafe { self.window().selectPreviousTab(None) }
    }

    #[inline]
@@ -1971,7 +1975,7 @@ impl WindowExtMacOS for WindowDelegate {
            return;
        }
        if let Some(group) = self.window().tabGroup() {
-            if let Some(windows) = self.window().tabbedWindows() {
+            if let Some(windows) = unsafe { self.window().tabbedWindows() } {
                if index < windows.len() {
                    group.setSelectedWindow(Some(&windows.objectAtIndex(index)));
                }
@@ -1981,7 +1985,7 @@ impl WindowExtMacOS for WindowDelegate {

    #[inline]
    fn num_tabs(&self) -> usize {
-        self.window().tabbedWindows().map(|windows| windows.len()).unwrap_or(1)
+        unsafe { self.window().tabbedWindows() }.map(|windows| windows.len()).unwrap_or(1)
    }

    fn is_document_edited(&self) -> bool {
@@ -2014,20 +2018,26 @@ impl WindowExtMacOS for WindowDelegate {
        if unified_titlebar {
            let mtm = MainThreadMarker::from(self);

-            // The toolbar style is ignored if there is no toolbar, so it is
-            // necessary to add one.
-            window.setToolbar(Some(&NSToolbar::new(mtm)));
-            window.setToolbarStyle(NSWindowToolbarStyle::Unified);
+            unsafe {
+                // The toolbar style is ignored if there is no toolbar, so it is
+                // necessary to add one.
+                window.setToolbar(Some(&NSToolbar::new(mtm)));
+                window.setToolbarStyle(NSWindowToolbarStyle::Unified);
+            }
        } else {
-            window.setToolbar(None);
-            window.setToolbarStyle(NSWindowToolbarStyle::Automatic);
+            unsafe {
+                window.setToolbar(None);
+                window.setToolbarStyle(NSWindowToolbarStyle::Automatic);
+            }
        }
    }

    fn unified_titlebar(&self) -> bool {
        let window = self.window();

-        window.toolbar().is_some() && window.toolbarStyle() == NSWindowToolbarStyle::Unified
+        unsafe {
+            window.toolbar().is_some() && window.toolbarStyle() == NSWindowToolbarStyle::Unified
+        }
    }
 }

@@ -2045,7 +2055,11 @@ pub fn appearance_to_theme(appearance: &NSAppearance) -> Theme {
        dark_appearance_name(),
    ]));
    if let Some(best_match) = best_match {
-        if *best_match == *dark_appearance_name() { Theme::Dark } else { Theme::Light }
+        if *best_match == *dark_appearance_name() {
+            Theme::Dark
+        } else {
+            Theme::Light
+        }
    } else {
        warn!(?appearance, "failed to determine the theme of the appearance");
        // Default to light in this case
--- a/winit-common/src/core_foundation/event_loop_proxy.rs
+++ b/winit-common/src/core_foundation/event_loop_proxy.rs
@@ -1,9 +1,12 @@
 use std::os::raw::c_void;
+use std::ptr::NonNull;
 use std::sync::Arc;
+use std::task::{RawWaker, RawWakerVTable, Waker};

 use objc2::MainThreadMarker;
 use objc2_core_foundation::{
-    CFIndex, CFRetained, CFRunLoop, CFRunLoopSource, CFRunLoopSourceContext, kCFRunLoopCommonModes,
+    kCFRunLoopCommonModes, CFIndex, CFRetained, CFRunLoop, CFRunLoopSource, CFRunLoopSourceContext,
+    Type,
 };
 use winit_core::event_loop::EventLoopProxyProvider;

@@ -119,4 +122,54 @@ impl EventLoopProxyProvider for EventLoopProxy {
        // main loop may be sleeping (and `CFRunLoopSourceSignal` won't wake it).
        self.main_loop.wake_up();
    }
+
+    fn waker(&self) -> Waker {
+        const VTABLE: RawWakerVTable =
+            RawWakerVTable::new(clone_waker, wake, wake_by_ref, drop_waker);
+
+        unsafe fn clone_waker(data: *const ()) -> RawWaker {
+            // SAFETY: The poiner came from `CFRunLoopSource` and is valid and non-null.
+            let source = unsafe { &*data.cast::<CFRunLoopSource>() };
+
+            // Increment reference count.
+            let source = source.retain();
+
+            // Pass ownership to the raw waker.
+            let data: *const CFRunLoopSource = CFRetained::into_raw(source).as_ptr();
+            RawWaker::new(data.cast(), &VTABLE)
+        }
+
+        unsafe fn wake(data: *const ()) {
+            unsafe { wake_by_ref(data) };
+            unsafe { drop_waker(data) };
+        }
+
+        unsafe fn wake_by_ref(data: *const ()) {
+            // SAFETY: The poiner came from `CFRunLoopSource` and is valid and non-null.
+            let source = unsafe { &*data.cast::<CFRunLoopSource>() };
+
+            // Signal the source, which ends up later invoking `perform` on the main thread.
+            //
+            // Multiple signals in quick succession are automatically coalesced into a single
+            // signal.
+            source.signal();
+
+            let main_loop = CFRunLoop::main().unwrap();
+            // Let the main thread know there's a new event.
+            //
+            // This is required since we may be (probably are) running on a different thread, and
+            // the main loop may be sleeping (and `CFRunLoopSourceSignal` won't wake it).
+            main_loop.wake_up();
+        }
+
+        unsafe fn drop_waker(data: *const ()) {
+            let source = data.cast::<CFRunLoopSource>().cast_mut();
+            // SAFETY: The poiner came from `CFRunLoopSource` and is valid and non-null.
+            // We take ownership of a retain count here.
+            let _source = unsafe { CFRetained::from_raw(NonNull::new_unchecked(source)) };
+        }
+
+        let data: *const CFRunLoopSource = CFRetained::into_raw(self.source.clone()).as_ptr();
+        unsafe { Waker::from_raw(RawWaker::new(data.cast(), &VTABLE)) }
+    }
 }
--- a/winit-common/src/event_handler.rs
+++ b/winit-common/src/event_handler.rs
@@ -114,7 +114,7 @@ impl EventHandler {

    pub fn handle(&self, callback: impl FnOnce(&mut (dyn ApplicationHandler + '_))) {
        match self.inner.try_borrow_mut().as_deref_mut() {
-            Ok(Some(user_app)) => {
+            Ok(Some(ref mut user_app)) => {
                // It is important that we keep the reference borrowed here,
                // so that `in_use` can properly detect that the handler is
                // still in use.
--- a/winit-common/src/xkb/compose.rs
+++ b/winit-common/src/xkb/compose.rs
@@ -12,7 +12,7 @@ use xkbcommon_dl::{
    xkb_compose_status, xkb_compose_table, xkb_keysym_t,
 };

-use super::{XKBCH, XkbContext};
+use super::{XkbContext, XKBCH};

 #[derive(Debug)]
 pub struct XkbComposeTable {
--- a/winit-common/src/xkb/keymap.rs
+++ b/winit-common/src/xkb/keymap.rs
@@ -19,7 +19,7 @@ use {memmap2::MmapOptions, std::os::unix::io::OwnedFd};

 #[cfg(feature = "x11")]
 use super::XKBXH;
-use super::{XKBH, XkbContext};
+use super::{XkbContext, XKBH};

 /// Map the raw X11-style keycode to the `KeyCode` enum.
 ///
@@ -37,9 +37,8 @@ pub fn scancode_to_physicalkey(scancode: u32) -> PhysicalKey {
    // are defined by the Linux kernel. If Winit programs end up being run on other Unix-likes,
    // I can only hope they agree on what the keycodes mean.
    //
-    // The mapping here is heavily influenced by Firefox' and Chromium's sources:
-    // - https://searchfox.org/mozilla-central/rev/c597e9c789ad36af84a0370d395be066b7dc94f4/widget/NativeKeyToDOMCodeName.h
-    // - https://chromium.googlesource.com/chromium/src.git/+/3e1a26c44c024d97dc9a4c09bbc6a2365398ca2c/ui/events/keycodes/dom/dom_code_data.inc
+    // The mapping here is heavily influenced by Firefox' source:
+    // https://searchfox.org/mozilla-central/rev/c597e9c789ad36af84a0370d395be066b7dc94f4/widget/NativeKeyToDOMCodeName.h
    //
    // Some of the keycodes are likely superfluous for our purposes, and some are ones which are
    // difficult to test the correctness of, or discover the purpose of. Because of this, they've
@@ -160,11 +159,11 @@ pub fn scancode_to_physicalkey(scancode: u32) -> PhysicalKey {
        113 => KeyCode::AudioVolumeMute,
        114 => KeyCode::AudioVolumeDown,
        115 => KeyCode::AudioVolumeUp,
-        116 => KeyCode::Power,
+        // 116 => KeyCode::POWER,
        117 => KeyCode::NumpadEqual,
        // 118 => KeyCode::KPPLUSMINUS,
        119 => KeyCode::Pause,
-        120 => KeyCode::ShowAllWindows,
+        // 120 => KeyCode::SCALE,
        121 => KeyCode::NumpadComma,
        122 => KeyCode::Lang1,
        123 => KeyCode::Lang2,
@@ -186,7 +185,7 @@ pub fn scancode_to_physicalkey(scancode: u32) -> PhysicalKey {
        // 139 => KeyCode::MENU,
        140 => KeyCode::LaunchApp2, // CALC
        // 141 => KeyCode::SETUP,
-        142 => KeyCode::Sleep,
+        // 142 => KeyCode::SLEEP,
        143 => KeyCode::WakeUp,
        144 => KeyCode::LaunchApp1, // FILE
        // 145 => KeyCode::SENDFILE,
@@ -211,8 +210,8 @@ pub fn scancode_to_physicalkey(scancode: u32) -> PhysicalKey {
        164 => KeyCode::MediaPlayPause,
        165 => KeyCode::MediaTrackPrevious,
        166 => KeyCode::MediaStop,
-        167 => KeyCode::MediaRecord,
-        168 => KeyCode::MediaRewind,
+        // 167 => KeyCode::RECORD,
+        // 168 => KeyCode::REWIND,
        // 169 => KeyCode::PHONE,
        // 170 => KeyCode::ISO,
        171 => KeyCode::MediaSelect, // CONFIG
@@ -223,8 +222,8 @@ pub fn scancode_to_physicalkey(scancode: u32) -> PhysicalKey {
        // 176 => KeyCode::EDIT,
        // 177 => KeyCode::SCROLLUP,
        // 178 => KeyCode::SCROLLDOWN,
-        179 => KeyCode::NumpadParenLeft,
-        180 => KeyCode::NumpadParenRight,
+        // 179 => KeyCode::KPLEFTPAREN,
+        // 180 => KeyCode::KPRIGHTPAREN,
        // 181 => KeyCode::NEW,
        // 182 => KeyCode::REDO,
        183 => KeyCode::F13,
@@ -240,14 +239,14 @@ pub fn scancode_to_physicalkey(scancode: u32) -> PhysicalKey {
        193 => KeyCode::F23,
        194 => KeyCode::F24,
        // 200 => KeyCode::PLAYCD,
-        201 => KeyCode::MediaPause,
+        // 201 => KeyCode::PAUSECD,
        // 202 => KeyCode::PROG3,
        // 203 => KeyCode::PROG4,
        // 204 => KeyCode::DASHBOARD,
        // 205 => KeyCode::SUSPEND,
        // 206 => KeyCode::CLOSE,
-        207 => KeyCode::MediaPlay,
-        208 => KeyCode::MediaFastForward,
+        // 207 => KeyCode::PLAY,
+        // 208 => KeyCode::FASTFORWARD,
        // 209 => KeyCode::BASSBOOST,
        // 210 => KeyCode::PRINT,
        // 211 => KeyCode::HP,
@@ -263,16 +262,16 @@ pub fn scancode_to_physicalkey(scancode: u32) -> PhysicalKey {
        // 221 => KeyCode::SHOP,
        // 222 => KeyCode::ALTERASE,
        // 223 => KeyCode::CANCEL,
-        224 => KeyCode::BrightnessDown,
-        225 => KeyCode::BrightnessUp,
+        // 224 => KeyCode::BRIGHTNESSDOW,
+        // 225 => KeyCode::BRIGHTNESSU,
        // 226 => KeyCode::MEDIA,
-        227 => KeyCode::DisplayToggleIntExt,
-        228 => KeyCode::KeyboardBacklightToggle,
+        // 227 => KeyCode::SWITCHVIDEOMODE,
+        // 228 => KeyCode::KBDILLUMTOGGLE,
        // 229 => KeyCode::KBDILLUMDOWN,
        // 230 => KeyCode::KBDILLUMUP,
-        231 => KeyCode::MailSend,
-        232 => KeyCode::MailReply,
-        233 => KeyCode::MailForward,
+        // 231 => KeyCode::SEND,
+        // 232 => KeyCode::REPLY,
+        // 233 => KeyCode::FORWARDMAIL,
        // 234 => KeyCode::SAVE,
        // 235 => KeyCode::DOCUMENTS,
        // 236 => KeyCode::BATTERY,
@@ -287,14 +286,7 @@ pub fn scancode_to_physicalkey(scancode: u32) -> PhysicalKey {
        // 245 => KeyCode::DISPLAY_OFF,
        // 246 => KeyCode::WWAN,
        // 247 => KeyCode::RFKILL,
-        248 => KeyCode::MicrophoneMuteToggle,
-        372 => KeyCode::ZoomToggle,
-        579 => KeyCode::LaunchControlPanel,
-        580 => KeyCode::SelectTask,
-        581 => KeyCode::LaunchScreenSaver,
-        583 => KeyCode::LaunchAssistant,
-        584 => KeyCode::KeyboardLayoutSelect,
-        633 => KeyCode::PrivacyScreenToggle,
+        // 248 => KeyCode::KEY_MICMUTE,
        _ => return PhysicalKey::Unidentified(NativeKeyCode::Xkb(scancode)),
    })
 }
@@ -423,10 +415,8 @@ pub fn physicalkey_to_scancode(key: PhysicalKey) -> Option<u32> {
        KeyCode::AudioVolumeMute => Some(113),
        KeyCode::AudioVolumeDown => Some(114),
        KeyCode::AudioVolumeUp => Some(115),
-        KeyCode::Power => Some(116),
        KeyCode::NumpadEqual => Some(117),
        KeyCode::Pause => Some(119),
-        KeyCode::ShowAllWindows => Some(120),
        KeyCode::NumpadComma => Some(121),
        KeyCode::Lang1 => Some(122),
        KeyCode::Lang2 => Some(123),
@@ -446,7 +436,6 @@ pub fn physicalkey_to_scancode(key: PhysicalKey) -> Option<u32> {
        KeyCode::Cut => Some(137),
        KeyCode::Help => Some(138),
        KeyCode::LaunchApp2 => Some(140),
-        KeyCode::Sleep => Some(142),
        KeyCode::WakeUp => Some(143),
        KeyCode::LaunchApp1 => Some(144),
        KeyCode::LaunchMail => Some(155),
@@ -458,13 +447,9 @@ pub fn physicalkey_to_scancode(key: PhysicalKey) -> Option<u32> {
        KeyCode::MediaPlayPause => Some(164),
        KeyCode::MediaTrackPrevious => Some(165),
        KeyCode::MediaStop => Some(166),
-        KeyCode::MediaRecord => Some(167),
-        KeyCode::MediaRewind => Some(168),
        KeyCode::MediaSelect => Some(171),
        KeyCode::BrowserHome => Some(172),
        KeyCode::BrowserRefresh => Some(173),
-        KeyCode::NumpadParenLeft => Some(179),
-        KeyCode::NumpadParenRight => Some(180),
        KeyCode::F13 => Some(183),
        KeyCode::F14 => Some(184),
        KeyCode::F15 => Some(185),
@@ -477,26 +462,7 @@ pub fn physicalkey_to_scancode(key: PhysicalKey) -> Option<u32> {
        KeyCode::F22 => Some(192),
        KeyCode::F23 => Some(193),
        KeyCode::F24 => Some(194),
-        KeyCode::MediaPause => Some(201),
-        KeyCode::MediaPlay => Some(207),
-        KeyCode::MediaFastForward => Some(208),
        KeyCode::BrowserSearch => Some(217),
-        KeyCode::BrightnessDown => Some(224),
-        KeyCode::BrightnessUp => Some(225),
-        KeyCode::DisplayToggleIntExt => Some(227),
-        KeyCode::KeyboardBacklightToggle => Some(228),
-        KeyCode::MailSend => Some(231),
-        KeyCode::MailReply => Some(232),
-        KeyCode::MailForward => Some(233),
-        // PhysicalKey::Unidentified(NativeKeyCode::Unidentified) => Some(240),
-        KeyCode::MicrophoneMuteToggle => Some(248),
-        KeyCode::ZoomToggle => Some(372),
-        KeyCode::LaunchControlPanel => Some(579),
-        KeyCode::SelectTask => Some(580),
-        KeyCode::LaunchScreenSaver => Some(581),
-        KeyCode::LaunchAssistant => Some(583),
-        KeyCode::KeyboardLayoutSelect => Some(584),
-        KeyCode::PrivacyScreenToggle => Some(633),
        _ => None,
    }
 }
@@ -1052,7 +1018,11 @@ impl XkbKeymap {
                &mut keysyms,
            );

-            if count == 1 { *keysyms } else { 0 }
+            if count == 1 {
+                *keysyms
+            } else {
+                0
+            }
        }
    }

@@ -1096,6 +1066,10 @@ fn mod_index_for_name(keymap: NonNull<xkb_keymap>, name: &[u8]) -> Option<xkb_mo
    unsafe {
        let mod_index =
            (XKBH.xkb_keymap_mod_get_index)(keymap.as_ptr(), name.as_ptr() as *const c_char);
-        if mod_index == XKB_MOD_INVALID { None } else { Some(mod_index) }
+        if mod_index == XKB_MOD_INVALID {
+            None
+        } else {
+            Some(mod_index)
+        }
    }
 }
--- a/winit-common/src/xkb/mod.rs
+++ b/winit-common/src/xkb/mod.rs
@@ -3,15 +3,15 @@ use std::os::raw::c_char;
 #[cfg(feature = "wayland")]
 use std::os::unix::io::OwnedFd;
 use std::ptr::{self, NonNull};
-use std::sync::LazyLock;
 use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::LazyLock;

 use smol_str::SmolStr;
 use winit_core::event::{ElementState, KeyEvent};
 use winit_core::keyboard::{Key, KeyLocation};
 use xkbcommon_dl::{
-    self as xkb, XkbCommon, XkbCommonCompose, xkb_compose_status, xkb_context, xkb_context_flags,
-    xkbcommon_compose_handle, xkbcommon_handle,
+    self as xkb, xkb_compose_status, xkb_context, xkb_context_flags, xkbcommon_compose_handle,
+    xkbcommon_handle, XkbCommon, XkbCommonCompose,
 };
 #[cfg(feature = "x11")]
 use {x11_dl::xlib_xcb::xcb_connection_t, xkbcommon_dl::x11::xkbcommon_x11_handle};
@@ -21,9 +21,9 @@ mod keymap;
 mod state;

 use compose::{ComposeStatus, XkbComposeState, XkbComposeTable};
-use keymap::XkbKeymap;
 #[cfg(feature = "x11")]
 pub use keymap::raw_keycode_to_physicalkey;
+use keymap::XkbKeymap;
 pub use keymap::{physicalkey_to_scancode, scancode_to_physicalkey};
 pub use state::XkbState;

@@ -310,7 +310,11 @@ impl<'a, 'b> KeyEventResults<'a, 'b> {
    fn keysym_to_key(&self, keysym: u32) -> Result<(Key, KeyLocation), (Key, KeyLocation)> {
        let location = keymap::keysym_location(keysym);
        let key = keymap::keysym_to_key(keysym);
-        if matches!(key, Key::Unidentified(_)) { Err((key, location)) } else { Ok((key, location)) }
+        if matches!(key, Key::Unidentified(_)) {
+            Err((key, location))
+        } else {
+            Ok((key, location))
+        }
    }

    pub fn text(&mut self) -> Option<SmolStr> {
--- a/winit-common/src/xkb/state.rs
+++ b/winit-common/src/xkb/state.rs
@@ -10,10 +10,10 @@ use xkbcommon_dl::{
    self as xkb, xkb_keycode_t, xkb_keysym_t, xkb_layout_index_t, xkb_state, xkb_state_component,
 };

+use super::keymap::XkbKeymap;
 #[cfg(feature = "x11")]
 use super::XKBXH;
-use super::keymap::XkbKeymap;
-use super::{XKBH, make_string_with};
+use super::{make_string_with, XKBH};

 #[derive(Debug)]
 pub struct XkbState {
--- a/winit-core/src/cursor.rs
+++ b/winit-core/src/cursor.rs
@@ -8,7 +8,7 @@ use std::time::Duration;
 #[doc(inline)]
 pub use cursor_icon::CursorIcon;

-use crate::as_any::AsAny;
+use crate::as_any::{impl_dyn_casting, AsAny};

 /// The maximum width and height for a cursor when using [`CustomCursorSource::from_rgba`].
 pub const MAX_CURSOR_SIZE: u16 = 2048;
--- a/winit-core/src/error.rs
+++ b/winit-core/src/error.rs
@@ -35,7 +35,11 @@ impl fmt::Display for EventLoopError {

 impl Error for EventLoopError {
    fn source(&self) -> Option<&(dyn Error + 'static)> {
-        if let Self::Os(err) = self { err.source() } else { None }
+        if let Self::Os(err) = self {
+            err.source()
+        } else {
+            None
+        }
    }
 }

@@ -74,7 +78,11 @@ impl Display for RequestError {
 }
 impl Error for RequestError {
    fn source(&self) -> Option<&(dyn Error + 'static)> {
-        if let Self::Os(err) = self { err.source() } else { None }
+        if let Self::Os(err) = self {
+            err.source()
+        } else {
+            None
+        }
    }
 }

@@ -141,5 +149,7 @@ impl Error for OsError {

 #[allow(unused_macros)]
 macro_rules! os_error {
-    ($error:expr) => {{ crate::error::OsError::new(line!(), file!(), $error) }};
+    ($error:expr) => {{
+        crate::error::OsError::new(line!(), file!(), $error)
+    }};
 }
--- a/winit-core/src/event.rs
+++ b/winit-core/src/event.rs
@@ -1,7 +1,4 @@
 //! The event enums and assorted supporting types.
-use std::cell::LazyCell;
-use std::cmp::Ordering;
-use std::f64;
 use std::path::PathBuf;
 use std::sync::{Mutex, Weak};

@@ -10,13 +7,13 @@ use dpi::{PhysicalPosition, PhysicalSize};
 use serde::{Deserialize, Serialize};
 use smol_str::SmolStr;

-use crate::Instant;
 use crate::error::RequestError;
 use crate::event_loop::AsyncRequestSerial;
 use crate::keyboard::{self, ModifiersKeyState, ModifiersKeys, ModifiersState};
 #[cfg(doc)]
 use crate::window::Window;
 use crate::window::{ActivationToken, Theme};
+use crate::Instant;

 /// Describes the reason the event loop is resuming.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -267,7 +264,7 @@ pub enum WindowEvent {
    ///
    /// ## Platform-specific
    ///
-    /// - Only available on **macOS**, **iOS**, and **Wayland**.
+    /// - Only available on **macOS** and **iOS**.
    /// - On iOS, not recognized by default. It must be enabled when needed.
    PinchGesture {
        device_id: Option<DeviceId>,
@@ -283,7 +280,7 @@ pub enum WindowEvent {
    ///
    /// ## Platform-specific
    ///
-    /// - Only available on **iOS** and **Wayland**.
+    /// - Only available on **iOS**.
    /// - On iOS, not recognized by default. It must be enabled when needed.
    PanGesture {
        device_id: Option<DeviceId>,
@@ -319,7 +316,7 @@ pub enum WindowEvent {
    ///
    /// ## Platform-specific
    ///
-    /// - Only available on **macOS**, **iOS**, and **Wayland**.
+    /// - Only available on **macOS** and **iOS**.
    /// - On iOS, not recognized by default. It must be enabled when needed.
    RotationGesture {
        device_id: Option<DeviceId>,
@@ -438,7 +435,6 @@ pub enum PointerKind {
    ///
    /// **macOS:** Unsupported.
    Touch(FingerId),
-    TabletTool(TabletToolKind),
    Unknown,
 }

@@ -489,13 +485,6 @@ pub enum PointerSource {
        ///   force will be 0.5 when a button is pressed or 0.0 otherwise.
        force: Option<Force>,
    },
-    TabletTool {
-        /// Describes as which tool kind the interaction happened.
-        kind: TabletToolKind,
-
-        /// Describes how the tool was held and used.
-        data: TabletToolData,
-    },
    Unknown,
 }

@@ -504,7 +493,6 @@ impl From<PointerSource> for PointerKind {
        match source {
            PointerSource::Mouse => Self::Mouse,
            PointerSource::Touch { finger_id, .. } => Self::Touch(finger_id),
-            PointerSource::TabletTool { kind, .. } => Self::TabletTool(kind),
            PointerSource::Unknown => Self::Unknown,
        }
    }
@@ -514,7 +502,7 @@ impl From<PointerSource> for PointerKind {
 ///
 /// **Wayland/X11:** [`Unknown`](Self::Unknown) device types are converted to known variants by the
 /// system.
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, Copy, Debug, PartialEq)]
 pub enum ButtonSource {
    Mouse(MouseButton),
    /// See [`PointerSource::Touch`] for more details.
@@ -526,27 +514,25 @@ pub enum ButtonSource {
        finger_id: FingerId,
        force: Option<Force>,
    },
-    TabletTool {
-        kind: TabletToolKind,
-        button: TabletToolButton,
-        data: TabletToolData,
-    },
-    /// A pointer button of unknown source.
-    ///
-    /// Codes are undefined and may not be reproducible across platforms or winit versions.
    Unknown(u16),
 }

 impl ButtonSource {
-    /// Try to convert a [`ButtonSource`] to an equivalent [`MouseButton`]. If a pointer type has no
+    /// Convert any [`ButtonSource`] to an equivalent [`MouseButton`]. If a pointer type has no
    /// special handling in an application, this method can be used to handle it like any generic
    /// mouse input.
-    pub fn mouse_button(self) -> Option<MouseButton> {
+    pub fn mouse_button(self) -> MouseButton {
        match self {
-            ButtonSource::Mouse(mouse) => Some(mouse),
-            ButtonSource::Touch { .. } => Some(MouseButton::Left),
-            ButtonSource::TabletTool { button, .. } => button.into(),
-            ButtonSource::Unknown(_) => None,
+            ButtonSource::Mouse(mouse) => mouse,
+            ButtonSource::Touch { .. } => MouseButton::Left,
+            ButtonSource::Unknown(button) => match button {
+                0 => MouseButton::Left,
+                1 => MouseButton::Middle,
+                2 => MouseButton::Right,
+                3 => MouseButton::Back,
+                4 => MouseButton::Forward,
+                _ => MouseButton::Other(button),
+            },
        }
    }
 }
@@ -759,7 +745,7 @@ pub struct KeyEvent {
    ///
    /// # Example
    ///
-    /// In games, you often want to ignore repeated key events - this can be
+    /// In games, you often want to ignore repated key events - this can be
    /// done by ignoring events where this property is set.
    ///
    /// ```no_run
@@ -784,10 +770,9 @@ pub struct KeyEvent {
    /// ```
    pub repeat: bool,

-    /// Similar to [`text`][Self::text], except that this is affected by <kbd>Ctrl</kbd> and may
-    /// produce ASCII control characters.
+    /// Similar to [`text`][Self::text], except that this is affected by <kbd>Ctrl</kbd>.
    ///
-    /// For example, pressing <kbd>Ctrl</kbd>+<kbd>space</kbd> produces `Some("\x00")`.
+    /// For example, pressing <kbd>Ctrl</kbd>+<kbd>a</kbd> produces `Some("\x01")`.
    ///
    /// ## Platform-specific
    ///
@@ -996,7 +981,6 @@ pub enum TouchPhase {
 /// Describes the force of a touch event
 #[derive(Debug, Clone, Copy, PartialEq)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[doc(alias = "Pressure")]
 pub enum Force {
    /// On iOS, the force is calibrated so that the same number corresponds to
    /// roughly the same amount of pressure on the screen regardless of the
@@ -1007,7 +991,7 @@ pub enum Force {
        ///
        /// The force reported by Apple Pencil is measured along the axis of the
        /// pencil. If you want a force perpendicular to the device, you need to
-        /// calculate this value using the [`TabletToolAngle::altitude`] value.
+        /// calculate this value using the `altitude_angle` value.
        force: f64,
        /// The maximum possible force for a touch.
        ///
@@ -1028,17 +1012,9 @@ impl Force {
    /// Instead of normalizing the force, you should prefer to handle
    /// [`Force::Calibrated`] so that the amount of force the user has to apply is
    /// consistent across devices.
-    ///
-    /// Passing in a [`TabletToolAngle`], returns the perpendicular force.
-    pub fn normalized(&self, angle: Option<TabletToolAngle>) -> f64 {
+    pub fn normalized(&self) -> f64 {
        match self {
-            Force::Calibrated { force, max_possible_force } => {
-                let force = match angle {
-                    Some(TabletToolAngle { altitude, .. }) => force / altitude.sin(),
-                    None => *force,
-                };
-                force / max_possible_force
-            },
+            Force::Calibrated { force, max_possible_force } => force / max_possible_force,
            Force::Normalized(force) => *force,
        }
    }
@@ -1050,260 +1026,6 @@ pub type AxisId = u32;
 /// Identifier for a specific button on some device.
 pub type ButtonId = u32;

-/// Tablet of the tablet tool.
-#[derive(Default, Clone, Copy, Debug, PartialEq, Eq, Hash)]
-#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
-#[non_exhaustive]
-pub enum TabletToolKind {
-    #[default]
-    Pen,
-    Eraser,
-    Brush,
-    Pencil,
-    Airbrush,
-    Finger,
-    Mouse,
-    Lens,
-}
-
-#[derive(Default, Clone, Debug, PartialEq)]
-#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
-pub struct TabletToolData {
-    /// The force applied to the tool against the surface.
-    ///
-    /// When the force information is not available, [`None`] is returned.
-    ///
-    /// ## Platform-specific
-    ///
-    /// **Web:** Has no mechanism to detect support, so this will always be [`Some`].
-    pub force: Option<Force>,
-    /// Represents normalized tangential pressure, also known as barrel pressure. In the range of
-    /// -1 to 1. 0 means no tangential pressure is applied. [`None`] means backend or device has no
-    /// support.
-    ///
-    /// ## Platform-specific
-    ///
-    /// **Web:** Has no mechanism to detect support, so this will always be [`Some`] with a value
-    /// of 0.
-    pub tangential_force: Option<f32>,
-    /// The clockwise rotation in degrees of a tool around its own major axis. E.g. twisting a pen
-    /// around its length. In the range of 0 to 359. [`None`] means backend or device has no
-    /// support.
-    ///
-    /// ## Platform-specific
-    ///
-    /// **Web:** Has no mechanism to detect support, so this will always be [`Some`] with a value
-    /// of 0.
-    pub twist: Option<u16>,
-    /// The plane angle in degrees. [`None`] means backend or device has no support.
-    ///
-    /// ## Platform-specific
-    ///
-    /// **Web:** Has no mechanism to detect support, so this will always be [`Some`] with default
-    /// values.
-    pub tilt: Option<TabletToolTilt>,
-    /// The angular position in radians. [`None`] means backend or device has no support.
-    ///
-    /// ## Platform-specific
-    ///
-    /// **Web:** Has no mechanism to detect device support, so this will always be [`Some`] with
-    /// default values unless browser support is lacking.
-    pub angle: Option<TabletToolAngle>,
-}
-
-impl TabletToolData {
-    /// Returns [`TabletToolTilt`] if present or calculates it from [`TabletToolAngle`].
-    pub fn tilt(self) -> Option<TabletToolTilt> {
-        if let Some(tilt) = self.tilt { Some(tilt) } else { self.angle.map(TabletToolAngle::tilt) }
-    }
-
-    /// Returns [`TabletToolAngle`] if present or calculates it from [`TabletToolTilt`].
-    pub fn angle(self) -> Option<TabletToolAngle> {
-        if let Some(angle) = self.angle {
-            Some(angle)
-        } else {
-            self.tilt.map(TabletToolTilt::angle)
-        }
-    }
-}
-
-/// The plane angle in degrees of a tool.
-#[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
-pub struct TabletToolTilt {
-    /// The plane angle in degrees between the surface Y-Z plane and the plane containing the tool
-    /// and the surface Y axis. Positive values are to the right. In the range of -90 to 90. 0
-    /// means the tool is perpendicular to the surface and is the default.
-    ///
-    /// ![Tilt X](https://raw.githubusercontent.com/rust-windowing/winit/master/winit/docs/res/tool_tilt_x.webp)
-    ///
-    /// <sub>
-    ///   For image attribution, see the
-    ///   <a href="https://github.com/rust-windowing/winit/blob/master/winit/docs/ATTRIBUTION.md">
-    ///     ATTRIBUTION.md
-    ///   </a>
-    ///   file.
-    /// </sub>
-    pub x: i8,
-    /// The plane angle in degrees between the surface X-Z plane and the plane containing the tool
-    /// and the surface X axis. Positive values are towards the user. In the range of -90 to
-    /// 90. 0 means the tool is perpendicular to the surface and is the default.
-    ///
-    /// ![Tilt Y](https://raw.githubusercontent.com/rust-windowing/winit/master/winit/docs/res/tool_tilt_y.webp)
-    ///
-    /// <sub>
-    ///   For image attribution, see the
-    ///   <a href="https://github.com/rust-windowing/winit/blob/master/winit/docs/ATTRIBUTION.md">
-    ///     ATTRIBUTION.md
-    ///   </a>
-    ///   file.
-    /// </sub>
-    pub y: i8,
-}
-
-impl TabletToolTilt {
-    pub fn angle(self) -> TabletToolAngle {
-        // See <https://www.w3.org/TR/2024/WD-pointerevents3-20240326/#converting-between-tiltx-tilty-and-altitudeangle-azimuthangle>.
-
-        use std::f64::consts::*;
-
-        const PI_0_5: f64 = FRAC_PI_2;
-        const PI_1_5: f64 = 3. * FRAC_PI_2;
-        const PI_2: f64 = 2. * PI;
-
-        let x = LazyCell::new(|| f64::from(self.x).to_radians());
-        let y = LazyCell::new(|| f64::from(self.y).to_radians());
-
-        let mut azimuth = 0.;
-
-        if self.x == 0 {
-            match self.y.cmp(&0) {
-                Ordering::Greater => azimuth = PI_0_5,
-                Ordering::Less => azimuth = PI_1_5,
-                Ordering::Equal => (),
-            }
-        } else if self.y == 0 {
-            if self.x < 0 {
-                azimuth = PI;
-            }
-        } else if self.x.abs() == 90 || self.y.abs() == 90 {
-            // not enough information to calculate azimuth
-            azimuth = 0.;
-        } else {
-            // Non-boundary case: neither tiltX nor tiltY is equal to 0 or +-90
-            azimuth = f64::atan2(y.tan(), x.tan());
-
-            if azimuth < 0. {
-                azimuth += PI_2;
-            }
-        }
-
-        let altitude;
-
-        if self.x.abs() == 90 || self.y.abs() == 90 {
-            altitude = 0.;
-        } else if self.x == 0 {
-            altitude = PI_0_5 - y.abs();
-        } else if self.y == 0 {
-            altitude = PI_0_5 - x.abs();
-        } else {
-            // Non-boundary case: neither tiltX nor tiltY is equal to 0 or +-90
-            altitude = f64::atan(1. / f64::sqrt(x.tan().powi(2) + y.tan().powi(2)));
-        }
-
-        TabletToolAngle { altitude, azimuth }
-    }
-}
-
-/// The angular position in radians of a tool.
-#[derive(Clone, Copy, Debug, PartialEq)]
-#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
-pub struct TabletToolAngle {
-    /// The altitude angle in radians between the tools perpendicular position to the surface and
-    /// the surface X-Y plane. In the range of 0, parallel to the surface, to π/2, perpendicular to
-    /// the surface. π/2 means the tool is perpendicular to the surface and is the default.
-    ///
-    /// ![Altitude angle](https://raw.githubusercontent.com/rust-windowing/winit/master/docs/res/tool_altitude.webp)
-    ///
-    /// <sub>
-    ///   For image attribution, see the
-    ///   <a href="https://github.com/rust-windowing/winit/blob/master/docs/res/ATTRIBUTION.md">
-    ///     ATTRIBUTION.md
-    ///   </a>
-    ///   file.
-    /// </sub>
-    pub altitude: f64,
-    /// The azimuth angle in radiants representing the rotation between the major axis of the tool
-    /// and the surface X-Y plane. In the range of 0, 3 o'clock, progressively increasing clockwise
-    /// to 2π. 0 means the tool is at 3 o'clock or is perpendicular to the surface (`altitude` of
-    /// π/2) and is the default.
-    ///
-    /// ![Azimuth angle](https://raw.githubusercontent.com/rust-windowing/winit/master/docs/res/tool_azimuth.webp)
-    ///
-    /// <sub>
-    ///   For image attribution, see the
-    ///   <a href="https://github.com/rust-windowing/winit/blob/master/docs/res/ATTRIBUTION.md">
-    ///     ATTRIBUTION.md
-    ///   </a>
-    ///   file.
-    /// </sub>
-    pub azimuth: f64,
-}
-
-impl Default for TabletToolAngle {
-    fn default() -> Self {
-        Self { altitude: f64::consts::FRAC_2_PI, azimuth: 0. }
-    }
-}
-
-impl TabletToolAngle {
-    pub fn tilt(self) -> TabletToolTilt {
-        // See <https://www.w3.org/TR/2024/WD-pointerevents3-20240326/#converting-between-tiltx-tilty-and-altitudeangle-azimuthangle>.
-
-        use std::f64::consts::*;
-
-        const PI_0_5: f64 = FRAC_PI_2;
-        const PI_1_5: f64 = 3. * FRAC_PI_2;
-        const PI_2: f64 = 2. * PI;
-
-        let mut x = 0.;
-        let mut y = 0.;
-
-        if self.altitude == 0. {
-            if self.azimuth == 0. || self.azimuth == PI_2 {
-                x = FRAC_PI_2;
-            } else if self.azimuth == PI_0_5 {
-                y = FRAC_PI_2;
-            } else if self.azimuth == PI {
-                x = -FRAC_PI_2;
-            } else if self.azimuth == PI_1_5 {
-                y = -FRAC_PI_2;
-            } else if self.azimuth > 0. && self.azimuth < PI_0_5 {
-                x = FRAC_PI_2;
-                y = FRAC_PI_2;
-            } else if self.azimuth > PI_0_5 && self.azimuth < PI {
-                x = -FRAC_PI_2;
-                y = FRAC_PI_2;
-            } else if self.azimuth > PI && self.azimuth < PI_1_5 {
-                x = -FRAC_PI_2;
-                y = -FRAC_PI_2;
-            } else if self.azimuth > PI_1_5 && self.azimuth < PI_2 {
-                x = FRAC_PI_2;
-                y = -FRAC_PI_2;
-            }
-        }
-
-        if self.altitude != 0. {
-            let altitude = self.altitude.tan();
-
-            x = f64::atan(f64::cos(self.azimuth) / altitude);
-            y = f64::atan(f64::sin(self.azimuth) / altitude);
-        }
-
-        TabletToolTilt { x: x.to_degrees().round() as i8, y: y.to_degrees().round() as i8 }
-    }
-}
-
 /// Describes the input state of a key.
 #[derive(Debug, Hash, PartialEq, Eq, Clone, Copy)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
@@ -1319,138 +1041,23 @@ impl ElementState {
    }
 }

-/// Identifies a button of a mouse controller.
+/// Describes a button of a mouse controller.
 ///
 /// ## Platform-specific
 ///
-/// The first three buttons should be supported on all platforms.
-/// [`Self::Back`] and [`Self::Forward`] are supported on most platforms
-/// (when using a compatible mouse).
-///
-/// - **Android, iOS:** Currently not supported.
-/// - **Orbital:** Only left/right/middle buttons are supported at this time.
-/// - **Web, Windows:** Supports left/right/middle/back/forward buttons.
-/// - **Wayland:** Supports buttons 0..=15.
-/// - **macOS:** Supports all button variants.
-/// - **X11:** Technically supports further buttons than this (0..=250), these are emitted in
-///   `ButtonSource::Unknown`.
+/// **macOS:** `Back` and `Forward` might not work with all hardware.
+/// **Orbital:** `Back` and `Forward` are unsupported due to orbital not supporting them.
 #[derive(Debug, Hash, PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[repr(u8)]
 pub enum MouseButton {
-    /// The primary (usually left) button
-    Left = 0,
-    /// The secondary (usually right) button
-    Right = 1,
-    /// The tertiary (usually middle) button
-    Middle = 2,
-    /// The first side button, frequently assigned a back function
-    Back = 3,
-    /// The second side button, frequently assigned a forward function
-    Forward = 4,
-    /// The sixth button
-    Button6 = 5,
-    /// The seventh button
-    Button7 = 6,
-    /// The eighth button
-    Button8 = 7,
-    /// The ninth button
-    Button9 = 8,
-    /// The tenth button
-    Button10 = 9,
-    /// The eleventh button
-    Button11 = 10,
-    /// The twelfth button
-    Button12 = 11,
-    /// The thirteenth button
-    Button13 = 12,
-    /// The fourteenth button
-    Button14 = 13,
-    /// The fifteenth button
-    Button15 = 14,
-    /// The sixteenth button
-    Button16 = 15,
-    Button17 = 16,
-    Button18 = 17,
-    Button19 = 18,
-    Button20 = 19,
-    Button21 = 20,
-    Button22 = 21,
-    Button23 = 22,
-    Button24 = 23,
-    Button25 = 24,
-    Button26 = 25,
-    Button27 = 26,
-    Button28 = 27,
-    Button29 = 28,
-    Button30 = 29,
-    Button31 = 30,
-    Button32 = 31,
-}
-
-impl MouseButton {
-    /// Construct from a `u8` if within the range `0..=31`
-    pub fn try_from_u8(b: u8) -> Option<MouseButton> {
-        Some(match b {
-            0 => MouseButton::Left,
-            1 => MouseButton::Right,
-            2 => MouseButton::Middle,
-            3 => MouseButton::Back,
-            4 => MouseButton::Forward,
-            5 => MouseButton::Button6,
-            6 => MouseButton::Button7,
-            7 => MouseButton::Button8,
-            8 => MouseButton::Button9,
-            9 => MouseButton::Button10,
-            10 => MouseButton::Button11,
-            11 => MouseButton::Button12,
-            12 => MouseButton::Button13,
-            13 => MouseButton::Button14,
-            14 => MouseButton::Button15,
-            15 => MouseButton::Button16,
-            16 => MouseButton::Button17,
-            17 => MouseButton::Button18,
-            18 => MouseButton::Button19,
-            19 => MouseButton::Button20,
-            20 => MouseButton::Button21,
-            21 => MouseButton::Button22,
-            22 => MouseButton::Button23,
-            23 => MouseButton::Button24,
-            24 => MouseButton::Button25,
-            25 => MouseButton::Button26,
-            26 => MouseButton::Button27,
-            27 => MouseButton::Button28,
-            28 => MouseButton::Button29,
-            29 => MouseButton::Button30,
-            30 => MouseButton::Button31,
-            31 => MouseButton::Button32,
-            _ => return None,
-        })
-    }
-}
-
-/// Describes a button of a tool, e.g. a pen.
-#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
-pub enum TabletToolButton {
-    Contact,
-    Barrel,
+    Left,
+    Right,
+    Middle,
+    Back,
+    Forward,
    Other(u16),
 }

-impl From<TabletToolButton> for Option<MouseButton> {
-    fn from(tool: TabletToolButton) -> Self {
-        Some(match tool {
-            TabletToolButton::Contact => MouseButton::Left,
-            TabletToolButton::Barrel => MouseButton::Right,
-            TabletToolButton::Other(1) => MouseButton::Middle,
-            TabletToolButton::Other(3) => MouseButton::Back,
-            TabletToolButton::Other(4) => MouseButton::Forward,
-            TabletToolButton::Other(_) => return None,
-        })
-    }
-}
-
 /// Describes a difference in the mouse scroll wheel state.
 #[derive(Debug, Clone, Copy, PartialEq)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
@@ -1581,7 +1188,7 @@ mod tests {
                primary: true,
                state: event::ElementState::Pressed,
                position: (0, 0).into(),
-                button: event::ButtonSource::Unknown(0),
+                button: event::MouseButton::Other(0).into(),
            });
            with_window_event(PointerButton {
                device_id: None,
@@ -1634,85 +1241,16 @@ mod tests {
        });
    }

-    #[test]
-    fn test_tilt_angle_conversions() {
-        use std::f64::consts::*;
-
-        use event::{TabletToolAngle, TabletToolTilt};
-
-        // See <https://github.com/web-platform-tests/wpt/blob/5af3e9c2a2aba76ade00f0dbc3486e50a74a4506/pointerevents/pointerevent_tiltX_tiltY_to_azimuth_altitude.html#L11-L23>.
-        const TILT_TO_ANGLE: &[(TabletToolTilt, TabletToolAngle)] = &[
-            (TabletToolTilt { x: 0, y: 0 }, TabletToolAngle { altitude: FRAC_PI_2, azimuth: 0. }),
-            (TabletToolTilt { x: 0, y: 90 }, TabletToolAngle { altitude: 0., azimuth: FRAC_PI_2 }),
-            (TabletToolTilt { x: 0, y: -90 }, TabletToolAngle {
-                altitude: 0.,
-                azimuth: 3. * FRAC_PI_2,
-            }),
-            (TabletToolTilt { x: 90, y: 0 }, TabletToolAngle { altitude: 0., azimuth: 0. }),
-            (TabletToolTilt { x: 90, y: 90 }, TabletToolAngle { altitude: 0., azimuth: 0. }),
-            (TabletToolTilt { x: 90, y: -90 }, TabletToolAngle { altitude: 0., azimuth: 0. }),
-            (TabletToolTilt { x: -90, y: 0 }, TabletToolAngle { altitude: 0., azimuth: PI }),
-            (TabletToolTilt { x: -90, y: 90 }, TabletToolAngle { altitude: 0., azimuth: 0. }),
-            (TabletToolTilt { x: -90, y: -90 }, TabletToolAngle { altitude: 0., azimuth: 0. }),
-            (TabletToolTilt { x: 0, y: 45 }, TabletToolAngle {
-                altitude: FRAC_PI_4,
-                azimuth: FRAC_PI_2,
-            }),
-            (TabletToolTilt { x: 0, y: -45 }, TabletToolAngle {
-                altitude: FRAC_PI_4,
-                azimuth: 3. * FRAC_PI_2,
-            }),
-            (TabletToolTilt { x: 45, y: 0 }, TabletToolAngle { altitude: FRAC_PI_4, azimuth: 0. }),
-            (TabletToolTilt { x: -45, y: 0 }, TabletToolAngle { altitude: FRAC_PI_4, azimuth: PI }),
-        ];
-
-        for (tilt, angle) in TILT_TO_ANGLE {
-            assert_eq!(tilt.angle(), *angle, "{tilt:?}");
-        }
-
-        // See <https://github.com/web-platform-tests/wpt/blob/5af3e9c2a2aba76ade00f0dbc3486e50a74a4506/pointerevents/pointerevent_tiltX_tiltY_to_azimuth_altitude.html#L38-L46>.
-        const ANGLE_TO_TILT: &[(TabletToolAngle, TabletToolTilt)] = &[
-            (TabletToolAngle { altitude: 0., azimuth: 0. }, TabletToolTilt { x: 90, y: 0 }),
-            (TabletToolAngle { altitude: FRAC_PI_4, azimuth: 0. }, TabletToolTilt { x: 45, y: 0 }),
-            (TabletToolAngle { altitude: FRAC_PI_2, azimuth: 0. }, TabletToolTilt { x: 0, y: 0 }),
-            (TabletToolAngle { altitude: 0., azimuth: FRAC_PI_2 }, TabletToolTilt { x: 0, y: 90 }),
-            (TabletToolAngle { altitude: FRAC_PI_4, azimuth: FRAC_PI_2 }, TabletToolTilt {
-                x: 0,
-                y: 45,
-            }),
-            (TabletToolAngle { altitude: 0., azimuth: PI }, TabletToolTilt { x: -90, y: 0 }),
-            (TabletToolAngle { altitude: FRAC_PI_4, azimuth: PI }, TabletToolTilt { x: -45, y: 0 }),
-            (TabletToolAngle { altitude: 0., azimuth: 3. * FRAC_PI_2 }, TabletToolTilt {
-                x: 0,
-                y: -90,
-            }),
-            (TabletToolAngle { altitude: FRAC_PI_4, azimuth: 3. * FRAC_PI_2 }, TabletToolTilt {
-                x: 0,
-                y: -45,
-            }),
-        ];
-
-        for (angle, tilt) in ANGLE_TO_TILT {
-            assert_eq!(angle.tilt(), *tilt, "{angle:?}");
-        }
-    }
-
    #[test]
    fn test_force_normalize() {
        let force = event::Force::Normalized(0.0);
-        assert_eq!(force.normalized(None), 0.0);
+        assert_eq!(force.normalized(), 0.0);

        let force2 = event::Force::Calibrated { force: 5.0, max_possible_force: 2.5 };
-        assert_eq!(force2.normalized(None), 2.0);
+        assert_eq!(force2.normalized(), 2.0);

        let force3 = event::Force::Calibrated { force: 5.0, max_possible_force: 2.5 };
-        assert_eq!(
-            force3.normalized(Some(event::TabletToolAngle {
-                altitude: std::f64::consts::PI / 2.0,
-                azimuth: 0.
-            })),
-            2.0
-        );
+        assert_eq!(force3.normalized(), 2.0);
    }

    #[allow(clippy::clone_on_copy)]
--- a/winit-core/src/event_loop/mod.rs
+++ b/winit-core/src/event_loop/mod.rs
@@ -1,21 +1,20 @@
-pub mod never_return;
 pub mod pump_events;
-pub mod register;
 pub mod run_on_demand;

 use std::fmt::{self, Debug};
-use std::sync::Arc;
 use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::Arc;
+use std::task::Waker;
 use std::time::Duration;

 use rwh_06::{DisplayHandle, HandleError, HasDisplayHandle};

-use crate::Instant;
 use crate::as_any::AsAny;
 use crate::cursor::{CustomCursor, CustomCursorSource};
 use crate::error::RequestError;
 use crate::monitor::MonitorHandle;
 use crate::window::{Theme, Window, WindowAttributes};
+use crate::Instant;

 pub trait ActiveEventLoop: AsAny + fmt::Debug {
    /// Creates an [`EventLoopProxy`] that can be used to dispatch user events
@@ -152,6 +151,13 @@ impl EventLoopProxy {
        self.proxy.wake_up();
    }

+    /// Get a [`Waker`] that calls [`wake_up`] on the proxy when awoken.
+    ///
+    /// This may be useful to `async` code or otherwise interoperating with `std`.
+    pub fn waker(&self) -> Waker {
+        self.proxy.waker()
+    }
+
    pub fn new(proxy: Arc<dyn EventLoopProxyProvider>) -> Self {
        Self { proxy }
    }
@@ -160,6 +166,9 @@ impl EventLoopProxy {
 pub trait EventLoopProxyProvider: Send + Sync + Debug {
    /// See [`EventLoopProxy::wake_up`] for details.
    fn wake_up(&self);
+
+    /// See [`EventLoopProxy::waker`] for details.
+    fn waker(&self) -> Waker;
 }

 /// A proxy for the underlying display handle.
--- a/winit-core/src/event_loop/never_return.rs
+++ b/winit-core/src/event_loop/never_return.rs
@@ -1,14 +0,0 @@
-use crate::application::ApplicationHandler;
-
-/// Additional methods on `EventLoop` for platforms whose run method never return.
-pub trait EventLoopExtNeverReturn {
-    /// Run the event loop and call `process::exit` once finished.
-    ///
-    /// ## Platform-specific
-    ///
-    /// - **iOS**: This registers the callbacks with the system and calls `UIApplicationMain`.
-    /// - **macOS**: Unimplemented (TODO: Should call `NSApplicationMain`).
-    /// - **Android/Orbital/Wayland/Windows/X11**: Unsupported.
-    /// - **Web**: Impossible to support properly.
-    fn run_app_never_return<A: ApplicationHandler + 'static>(self, app: A) -> !;
-}
--- a/winit-core/src/event_loop/register.rs
+++ b/winit-core/src/event_loop/register.rs
@@ -1,17 +0,0 @@
-use crate::application::ApplicationHandler;
-
-/// Additional methods on `EventLoop` that registers it with the system event loop.
-pub trait EventLoopExtRegister {
-    /// Initialize and register the application with the system's event loop, such that the
-    /// callbacks will be run later.
-    ///
-    /// ## Platform-specific
-    ///
-    /// - **Web**: Once the event loop has been destroyed, it's possible to reinitialize another
-    ///   event loop by calling this function again. This can be useful if you want to recreate the
-    ///   event loop while the WebAssembly module is still loaded. For example, this can be used to
-    ///   recreate the event loop when switching between tabs on a single page application.
-    /// - **iOS/macOS**: Unimplemented.
-    /// - **Android/Orbital/Wayland/Windows/X11**: Unsupported.
-    fn register_app<A: ApplicationHandler + 'static>(self, app: A);
-}
--- a/winit-core/src/event_loop/run_on_demand.rs
+++ b/winit-core/src/event_loop/run_on_demand.rs
@@ -2,17 +2,19 @@ use crate::application::ApplicationHandler;
 use crate::error::EventLoopError;
 #[cfg(doc)]
 use crate::{
-    event_loop::{ActiveEventLoop, pump_events::EventLoopExtPumpEvents},
+    event_loop::{pump_events::EventLoopExtPumpEvents, ActiveEventLoop},
    window::Window,
 };

+#[allow(rustdoc::broken_intra_doc_links)] // FIXME(madsmtm): Fix these.
 /// Additional methods on [`EventLoop`] to return control flow to the caller.
 pub trait EventLoopExtRunOnDemand {
    /// Run the application with the event loop on the calling thread.
    ///
    /// Unlike [`EventLoop::run_app`], this function accepts non-`'static` (i.e. non-`move`)
-    /// state and it is possible to return control back to the caller without consuming the
-    /// `EventLoop` (by using [`exit()`]) and so the event loop can be re-run after it has exit.
+    /// closures and it is possible to return control back to the caller without
+    /// consuming the `EventLoop` (by using [`exit()`]) and
+    /// so the event loop can be re-run after it has exit.
    ///
    /// It's expected that each run of the loop will be for orthogonal instantiations of your
    /// Winit application, but internally each instantiation may re-use some common window
@@ -29,7 +31,8 @@ pub trait EventLoopExtRunOnDemand {
    ///
    /// # Caveats
    /// - This extension isn't available on all platforms, since it's not always possible to return
-    ///   to the caller (specifically this is impossible on iOS and Web).
+    ///   to the caller (specifically this is impossible on iOS and Web - though with the Web
+    ///   backend it is possible to use `EventLoopExtWeb::spawn_app()`[^1] more than once instead).
    /// - No [`Window`] state can be carried between separate runs of the event loop.
    ///
    /// You are strongly encouraged to use [`EventLoop::run_app()`] for portability, unless you
@@ -48,6 +51,8 @@ pub trait EventLoopExtRunOnDemand {
    ///   are delivered via callbacks based on an event loop that is internal to the browser itself.
    /// - **iOS:** It's not possible to stop and start an `UIApplication` repeatedly on iOS.
    ///
+    /// [^1]: `spawn_app()` is only available on the Web platforms.
+    ///
    /// [`exit()`]: ActiveEventLoop::exit()
    /// [`set_control_flow()`]: ActiveEventLoop::set_control_flow()
    fn run_app_on_demand<A: ApplicationHandler>(&mut self, app: A) -> Result<(), EventLoopError>;
--- a/winit-core/src/icon.rs
+++ b/winit-core/src/icon.rs
@@ -3,7 +3,7 @@ use std::ops::Deref;
 use std::sync::Arc;
 use std::{fmt, io, mem};

-use crate::as_any::AsAny;
+use crate::as_any::{impl_dyn_casting, AsAny};

 pub(crate) const PIXEL_SIZE: usize = mem::size_of::<u32>();

--- a/winit-core/src/keyboard.rs
+++ b/winit-core/src/keyboard.rs
@@ -193,7 +193,7 @@ impl PartialEq<KeyCode> for PhysicalKey {
    #[inline]
    fn eq(&self, rhs: &KeyCode) -> bool {
        match self {
-            PhysicalKey::Code(code) => code == rhs,
+            PhysicalKey::Code(ref code) => code == rhs,
            _ => false,
        }
    }
@@ -210,7 +210,7 @@ impl PartialEq<NativeKeyCode> for PhysicalKey {
    #[inline]
    fn eq(&self, rhs: &NativeKeyCode) -> bool {
        match self {
-            PhysicalKey::Unidentified(code) => code == rhs,
+            PhysicalKey::Unidentified(ref code) => code == rhs,
            _ => false,
        }
    }
@@ -275,7 +275,7 @@ impl<Str> PartialEq<NamedKey> for Key<Str> {
    #[inline]
    fn eq(&self, rhs: &NamedKey) -> bool {
        match self {
-            Key::Named(a) => a == rhs,
+            Key::Named(ref a) => a == rhs,
            _ => false,
        }
    }
@@ -285,7 +285,7 @@ impl<Str: PartialEq<str>> PartialEq<str> for Key<Str> {
    #[inline]
    fn eq(&self, rhs: &str) -> bool {
        match self {
-            Key::Character(s) => s == rhs,
+            Key::Character(ref s) => s == rhs,
            _ => false,
        }
    }
@@ -302,7 +302,7 @@ impl<Str> PartialEq<NativeKey> for Key<Str> {
    #[inline]
    fn eq(&self, rhs: &NativeKey) -> bool {
        match self {
-            Key::Unidentified(code) => code == rhs,
+            Key::Unidentified(ref code) => code == rhs,
            _ => false,
        }
    }
--- a/winit-core/src/monitor.rs
+++ b/winit-core/src/monitor.rs
@@ -13,7 +13,7 @@ use std::sync::Arc;

 use dpi::{PhysicalPosition, PhysicalSize};

-use crate::as_any::AsAny;
+use crate::as_any::{impl_dyn_casting, AsAny};

 /// Handle to a monitor.
 ///
--- a/winit-core/src/window.rs
+++ b/winit-core/src/window.rs
@@ -328,7 +328,7 @@ impl WindowAttributes {
    ///
    /// **Android / iOS / X11 / Wayland / Orbital:** Unsupported.
    ///
-    /// [`WindowEvent::Focused`]: crate::event::WindowEvent::Focused
+    /// [`WindowEvent::Focused`]: crate::event::WindowEvent::Focused.
    #[inline]
    pub fn with_active(mut self, active: bool) -> Self {
        self.active = active;
@@ -996,8 +996,7 @@ pub trait Window: AsAny + Send + Sync + fmt::Debug {
    ///   separate spaces are not preferred.
    ///
    ///   The dock and the menu bar are disabled in exclusive fullscreen mode.
-    /// - **Orbital / Wayland:** Does not support exclusive fullscreen mode and will no-op a
-    ///   request.
+    /// - **Wayland:** Does not support exclusive fullscreen mode and will no-op a request.
    /// - **Windows:** Screen saver is disabled in fullscreen mode.
    /// - **Web:** Passing a [`MonitorHandle`] or [`VideoMode`] that was not created with detailed
    ///   monitor permissions or calling without a [transient activation] does nothing.
@@ -1010,9 +1009,9 @@ pub trait Window: AsAny + Send + Sync + fmt::Debug {
    ///
    /// ## Platform-specific
    ///
-    /// - **Android:** Will always return `None`.
-    /// - **Orbital / Web:** Can only return `None` or `Borderless(None)`.
+    /// - **Android / Orbital:** Will always return `None`.
    /// - **Wayland:** Can return `Borderless(None)` when there are no monitors.
+    /// - **Web:** Can only return `None` or `Borderless(None)`.
    fn fullscreen(&self) -> Option<Fullscreen>;

    /// Turn window decorations on or off.
@@ -1136,9 +1135,9 @@ pub trait Window: AsAny + Send + Sync + fmt::Debug {
        let action = if allowed {
            let position = LogicalPosition::new(0, 0);
            let size = LogicalSize::new(0, 0);
-            let ime_caps = ImeCapabilities::new().with_hint_and_purpose().with_cursor_area();
+            let ime_caps = ImeCapabilities::new().with_purpose().with_cursor_area();
            let request_data = ImeRequestData {
-                hint_and_purpose: Some((ImeHint::NONE, ImePurpose::Normal)),
+                purpose: Some(ImePurpose::Normal),
                // WARNING: there's nothing sensible to use here by default.
                cursor_area: Some((position.into(), size.into())),
                ..ImeRequestData::default()
@@ -1160,9 +1159,9 @@ pub trait Window: AsAny + Send + Sync + fmt::Debug {
    /// - **iOS / Android / Web / Windows / X11 / macOS / Orbital:** Unsupported.
    #[deprecated = "use Window::request_ime_update instead"]
    fn set_ime_purpose(&self, purpose: ImePurpose) {
-        if self.ime_capabilities().map(|caps| caps.hint_and_purpose()).unwrap_or(false) {
+        if self.ime_capabilities().map(|caps| caps.purpose()).unwrap_or(false) {
            let _ = self.request_ime_update(ImeRequest::Update(ImeRequestData {
-                hint_and_purpose: Some((ImeHint::NONE, purpose)),
+                purpose: Some(purpose),
                ..ImeRequestData::default()
            }));
        }
@@ -1186,14 +1185,14 @@ pub trait Window: AsAny + Send + Sync + fmt::Debug {
    ///
    /// ```no_run
    /// # use dpi::{Position, Size};
-    /// # use winit_core::window::{Window, ImeHint, ImePurpose, ImeRequest, ImeCapabilities, ImeRequestData, ImeEnableRequest};
+    /// # use winit_core::window::{Window, ImePurpose, ImeRequest, ImeCapabilities, ImeRequestData, ImeEnableRequest};
    /// # fn scope(window: &dyn Window, cursor_pos: Position, cursor_size: Size) {
    /// // Clear previous state by switching off IME
    /// window.request_ime_update(ImeRequest::Disable).expect("Disable cannot fail");
    ///
-    /// let ime_caps = ImeCapabilities::new().with_cursor_area().with_hint_and_purpose();
+    /// let ime_caps = ImeCapabilities::new().with_cursor_area().with_purpose();
    /// let request_data = ImeRequestData::default()
-    ///                          .with_hint_and_purpose(ImeHint::NONE, ImePurpose::Normal)
+    ///                          .with_purpose(ImePurpose::Normal)
    ///                          .with_cursor_area(cursor_pos, cursor_size);
    /// let enable_ime = ImeEnableRequest::new(ime_caps, request_data.clone()).unwrap();
    /// window.request_ime_update(ImeRequest::Enable(enable_ime)).expect("Enabling may fail if IME is not supported");
@@ -1598,86 +1597,29 @@ pub enum WindowLevel {

 /// Generic IME purposes for use in [`Window::set_ime_purpose`].
 ///
-/// The purpose should reflect the kind of data to be entered.
 /// The purpose may improve UX by optimizing the IME for the specific use case,
-/// for example showing relevant characters and hiding unneeded ones,
-/// or changing the icon of the confirmation button,
 /// if winit can express the purpose to the platform and the platform reacts accordingly.
 ///
 /// ## Platform-specific
 ///
 /// - **iOS / Android / Web / Windows / X11 / macOS / Orbital:** Unsupported.
 #[non_exhaustive]
-#[derive(Debug, PartialEq, Eq, Clone, Copy, Hash, Default)]
+#[derive(Debug, PartialEq, Eq, Clone, Copy, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub enum ImePurpose {
-    /// No special purpose for the IME (default).
-    #[default]
+    /// No special hints for the IME (default).
    Normal,
    /// The IME is used for password input.
-    /// The IME will treat the contents as sensitive.
    Password,
    /// The IME is used to input into a terminal.
    ///
    /// For example, that could alter OSK on Wayland to show extra buttons.
    Terminal,
-    /// Number (including decimal separator and sign)
-    Number,
-    /// Phone number
-    Phone,
-    /// URL
-    Url,
-    /// Email address
-    Email,
-    /// Password composed only of digits (treated as sensitive data)
-    Pin,
-    /// Date
-    Date,
-    /// Time
-    Time,
-    /// Date and time
-    DateTime,
 }

-bitflags! {
-    /// IME hints
-    ///
-    /// The hint should reflect the desired behaviour of the IME
-    /// while entering text.
-    /// The purpose may improve UX by optimizing the IME for the specific use case,
-    /// beyond just the general data type specified in `ImePurpose`.
-    ///
-    /// ## Platform-specific
-    ///
-    /// - **iOS / Android / Web / Windows / X11 / macOS / Orbital:** Unsupported.
-    #[non_exhaustive]
-    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-    #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
-    pub struct ImeHint: u32 {
-        /// No special behaviour.
-        const NONE = 0;
-        /// Suggest word completions.
-        const COMPLETION = 0x1;
-        /// Suggest word corrections.
-        const SPELLCHECK = 0x2;
-        /// Switch to uppercase letters at the start of a sentence.
-        const AUTO_CAPITALIZATION = 0x4;
-        /// Prefer lowercase letters.
-        const LOWERCASE = 0x8;
-        /// Prefer uppercase letters.
-        const UPPERCASE = 0x10;
-        /// Prefer casing for titles and headings (can be language dependent).
-        const TITLECASE = 0x20;
-        /// Characters should be hidden.
-        ///
-        /// This may prevent e.g. layout switching with some IMEs, unless hint is disabled.
-        const HIDDEN_TEXT = 0x40;
-        /// Typed text should not be stored.
-        const SENSITIVE_DATA = 0x80;
-        /// Just Latin characters should be entered.
-        const LATIN = 0x100;
-        /// The text input is multiline.
-        const MULTILINE = 0x200;
+impl Default for ImePurpose {
+    fn default() -> Self {
+        Self::Normal
    }
 }

@@ -1785,7 +1727,7 @@ pub enum ImeRequest {
    ///
    /// **Requesting to update data matching not enabled capabilities will result in update
    /// being ignored.** The winit backend in such cases is recommended to log a warning. This
-    /// applies to both [`ImeRequest::Enable`] and [`ImeRequest::Update`]. For details on
+    /// appiles to both [`ImeRequest::Enable`] and [`ImeRequest::Update`]. For details on
    /// capabilities refer to [`ImeCapabilities`].
    ///
    /// To update the [`ImeCapabilities`], the IME must be disabled and then re-enabled.
@@ -1816,7 +1758,7 @@ impl ImeEnableRequest {
            return None;
        }

-        if capabilities.hint_and_purpose() ^ request_data.hint_and_purpose.is_some() {
+        if capabilities.purpose() ^ request_data.purpose.is_some() {
            return None;
        }

@@ -1861,23 +1803,23 @@ impl ImeCapabilities {
        Self::default()
    }

-    /// Marks `hint and purpose` as supported.
+    /// Marks `purpose` as supported.
    ///
-    /// For more details see [`ImeRequestData::with_hint_and_purpose`].
-    pub const fn with_hint_and_purpose(self) -> Self {
-        Self(self.0.union(ImeCapabilitiesFlags::HINT_AND_PURPOSE))
+    /// For more details see [`ImeRequestData::with_purpose`].
+    pub const fn with_purpose(self) -> Self {
+        Self(self.0.union(ImeCapabilitiesFlags::PURPOSE))
    }

-    /// Marks `hint and purpose` as unsupported.
+    /// Marks `purpose` as unsupported.
    ///
-    /// For more details see [`ImeRequestData::with_hint_and_purpose`].
-    pub const fn without_hint_and_purpose(self) -> Self {
-        Self(self.0.difference(ImeCapabilitiesFlags::HINT_AND_PURPOSE))
+    /// For more details see [`ImeRequestData::with_purpose`].
+    pub const fn without_purpose(self) -> Self {
+        Self(self.0.difference(ImeCapabilitiesFlags::PURPOSE))
    }

-    /// Returns `true` if `hint and purpose` is supported.
-    pub const fn hint_and_purpose(&self) -> bool {
-        self.0.contains(ImeCapabilitiesFlags::HINT_AND_PURPOSE)
+    /// Returns `true` if `purpose` is supported.
+    pub const fn purpose(&self) -> bool {
+        self.0.contains(ImeCapabilitiesFlags::PURPOSE)
    }

    /// Marks `cursor_area` as supported.
@@ -1922,8 +1864,8 @@ impl ImeCapabilities {
 bitflags! {
    #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
    pub(crate) struct ImeCapabilitiesFlags : u8 {
-        /// Client supports setting IME hint and purpose.
-        const HINT_AND_PURPOSE = 1 << 0;
+        /// Client supports setting IME purpose.
+        const PURPOSE = 1 << 0;
        /// Client supports reporting cursor area for IME popup to
        /// appear.
        const CURSOR_AREA = 1 << 1;
@@ -1941,24 +1883,24 @@ bitflags! {
 #[derive(Debug, PartialEq, Clone, Default)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct ImeRequestData {
-    /// Text input hint and purpose.
+    /// Text input purpose.
    ///
-    /// To support updating it, enable [`ImeCapabilities::hint_and_purpose()`].
-    pub hint_and_purpose: Option<(ImeHint, ImePurpose)>,
+    /// To support updating it, enable [`ImeCapabilities::PURPOSE`].
+    pub purpose: Option<ImePurpose>,
    /// The IME cursor area which should not be covered by the input method popup.
    ///
-    /// To support updating it, enable [`ImeCapabilities::cursor_area()`].
+    /// To support updating it, enable [`ImeCapabilities::CURSOR_AREA`].
    pub cursor_area: Option<(Position, Size)>,
    /// The text surrounding the caret
    ///
-    /// To support updating it, enable [`ImeCapabilities::surrounding_text()`].
+    /// To support updating it, enable [`ImeCapabilities::SURROUNDING_TEXT`].
    pub surrounding_text: Option<ImeSurroundingText>,
 }

 impl ImeRequestData {
-    /// Sets the hint and purpose of the current text input content.
-    pub fn with_hint_and_purpose(self, hint: ImeHint, purpose: ImePurpose) -> Self {
-        Self { hint_and_purpose: Some((hint, purpose)), ..self }
+    /// Sets the purpose hint of the current text input.
+    pub fn with_purpose(self, purpose: ImePurpose) -> Self {
+        Self { purpose: Some(purpose), ..self }
    }

    /// Sets the IME cursor editing area.
@@ -2084,73 +2026,59 @@ mod tests {
        ImeCapabilities, ImeEnableRequest, ImeRequestData, ImeSurroundingText,
        ImeSurroundingTextError,
    };
-    use crate::window::{ImeHint, ImePurpose};
+    use crate::window::ImePurpose;

    #[test]
    fn ime_initial_request_caps_match() {
        let position: Position = LogicalPosition::new(0, 0).into();
        let size: Size = LogicalSize::new(0, 0).into();

-        assert!(
-            ImeEnableRequest::new(
-                ImeCapabilities::new().with_cursor_area(),
-                ImeRequestData::default()
-            )
-            .is_none()
-        );
-        assert!(
-            ImeEnableRequest::new(
-                ImeCapabilities::new().with_hint_and_purpose(),
-                ImeRequestData::default()
-            )
-            .is_none()
-        );
+        assert!(ImeEnableRequest::new(
+            ImeCapabilities::new().with_cursor_area(),
+            ImeRequestData::default()
+        )
+        .is_none());
+        assert!(ImeEnableRequest::new(
+            ImeCapabilities::new().with_purpose(),
+            ImeRequestData::default()
+        )
+        .is_none());

-        assert!(
-            ImeEnableRequest::new(
-                ImeCapabilities::new().with_cursor_area(),
-                ImeRequestData::default().with_hint_and_purpose(ImeHint::NONE, ImePurpose::Normal)
-            )
-            .is_none()
-        );
+        assert!(ImeEnableRequest::new(
+            ImeCapabilities::new().with_cursor_area(),
+            ImeRequestData::default().with_purpose(ImePurpose::Normal)
+        )
+        .is_none());

-        assert!(
-            ImeEnableRequest::new(
-                ImeCapabilities::new(),
-                ImeRequestData::default()
-                    .with_hint_and_purpose(ImeHint::NONE, ImePurpose::Normal)
-                    .with_cursor_area(position, size)
-            )
-            .is_none()
-        );
+        assert!(ImeEnableRequest::new(
+            ImeCapabilities::new(),
+            ImeRequestData::default()
+                .with_purpose(ImePurpose::Normal)
+                .with_cursor_area(position, size)
+        )
+        .is_none());

-        assert!(
-            ImeEnableRequest::new(
-                ImeCapabilities::new().with_cursor_area(),
-                ImeRequestData::default()
-                    .with_hint_and_purpose(ImeHint::NONE, ImePurpose::Normal)
-                    .with_cursor_area(position, size)
-            )
-            .is_none()
-        );
+        assert!(ImeEnableRequest::new(
+            ImeCapabilities::new().with_cursor_area(),
+            ImeRequestData::default()
+                .with_purpose(ImePurpose::Normal)
+                .with_cursor_area(position, size)
+        )
+        .is_none());

-        assert!(
-            ImeEnableRequest::new(
-                ImeCapabilities::new().with_cursor_area(),
-                ImeRequestData::default().with_cursor_area(position, size)
-            )
-            .is_some()
-        );
+        assert!(ImeEnableRequest::new(
+            ImeCapabilities::new().with_cursor_area(),
+            ImeRequestData::default().with_cursor_area(position, size)
+        )
+        .is_some());

-        assert!(
-            ImeEnableRequest::new(
-                ImeCapabilities::new().with_hint_and_purpose().with_cursor_area(),
-                ImeRequestData::default()
-                    .with_hint_and_purpose(ImeHint::NONE, ImePurpose::Normal)
-                    .with_cursor_area(position, size)
-            )
-            .is_some()
-        );
+        assert!(ImeEnableRequest::new(
+            ImeCapabilities::new().with_purpose().with_cursor_area(),
+            ImeRequestData::default()
+                .with_purpose(ImePurpose::Normal)
+                .with_cursor_area(position, size)
+        )
+        .is_some());

        let text: &[u8] = ['a' as u8; 8000].as_slice();
        let text = std::str::from_utf8(text).unwrap();
--- a/winit-orbital/src/event_loop.rs
+++ b/winit-orbital/src/event_loop.rs
@@ -1,7 +1,8 @@
 use std::cell::Cell;
 use std::collections::VecDeque;
 use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::{Arc, Mutex, mpsc};
+use std::sync::{mpsc, Arc, Mutex};
+use std::task::Waker;
 use std::time::Instant;
 use std::{iter, mem, slice};

@@ -133,7 +134,11 @@ fn convert_scancode(scancode: u8) -> (PhysicalKey, Option<NamedKey>) {
 }

 fn element_state(pressed: bool) -> event::ElementState {
-    if pressed { event::ElementState::Pressed } else { event::ElementState::Released }
+    if pressed {
+        event::ElementState::Pressed
+    } else {
+        event::ElementState::Released
+    }
 }

 bitflags! {
@@ -272,7 +277,6 @@ impl EventState {
 pub struct EventLoop {
    windows: Vec<(Arc<RedoxSocket>, EventState)>,
    window_target: ActiveEventLoop,
-    user_events_receiver: mpsc::Receiver<()>,
 }

 impl EventLoop {
@@ -481,10 +485,7 @@ impl EventLoop {
        }
    }

-    pub fn run_app_on_demand<A: ApplicationHandler>(
-        &mut self,
-        mut app: A,
-    ) -> Result<(), EventLoopError> {
+    pub fn run_app<A: ApplicationHandler>(mut self, mut app: A) -> Result<(), EventLoopError> {
        let mut start_cause = StartCause::Init;
        loop {
            app.new_events(&self.window_target, start_cause);
@@ -576,7 +577,7 @@ impl EventLoop {
                i += 1;
            }

-            while self.user_events_receiver.try_recv().is_ok() {
+            if self.wake_up.swap(false, Ordering::Relaxed) {
                app.proxy_wake_up(&self.window_target);
            }

@@ -665,17 +666,26 @@ impl EventLoop {

 #[derive(Debug)]
 pub struct EventLoopProxy {
-    user_events_sender: mpsc::SyncSender<()>,
-    pub(super) wake_socket: TimeSocket,
+    waker: Waker,
 }

 impl EventLoopProxyProvider for EventLoopProxy {
    fn wake_up(&self) {
-        // When we fail to send the event it means that we haven't woken up to read the previous
-        // event.
-        if self.user_events_sender.try_send(()).is_ok() {
-            self.wake_socket.wake().unwrap();
-        }
+        self.waker.wake_by_ref();
+    }
+
+    fn into_waker(self) -> Waker {
+        self.waker
+    }
+}
+
+impl std::task::Wake for TimeSocket {
+    fn wake(self: Arc<TimeSocket>) {
+        TimeSocket::wake(&*self).unwrap();
+    }
+
+    fn wake_by_ref(self: &Arc<TimeSocket>) {
+        TimeSocket::wake(&**self).unwrap();
    }
 }

--- a/winit-orbital/src/lib.rs
+++ b/winit-orbital/src/lib.rs
@@ -8,7 +8,9 @@ use std::{fmt, str};
 pub use self::event_loop::{EventLoop, PlatformSpecificEventLoopAttributes};

 macro_rules! os_error {
-    ($error:expr) => {{ winit_core::error::OsError::new(line!(), file!(), $error) }};
+    ($error:expr) => {{
+        winit_core::error::OsError::new(line!(), file!(), $error)
+    }};
 }

 pub mod event_loop;
@@ -39,12 +41,20 @@ impl RedoxSocket {

    fn read(&self, buf: &mut [u8]) -> syscall::Result<()> {
        let count = syscall::read(self.fd, buf)?;
-        if count == buf.len() { Ok(()) } else { Err(syscall::Error::new(syscall::EINVAL)) }
+        if count == buf.len() {
+            Ok(())
+        } else {
+            Err(syscall::Error::new(syscall::EINVAL))
+        }
    }

    fn write(&self, buf: &[u8]) -> syscall::Result<()> {
        let count = syscall::write(self.fd, buf)?;
-        if count == buf.len() { Ok(()) } else { Err(syscall::Error::new(syscall::EINVAL)) }
+        if count == buf.len() {
+            Ok(())
+        } else {
+            Err(syscall::Error::new(syscall::EINVAL))
+        }
    }

    fn fpath<'a>(&self, buf: &'a mut [u8]) -> syscall::Result<&'a str> {
--- a/winit-orbital/src/window.rs
+++ b/winit-orbital/src/window.rs
@@ -19,7 +19,6 @@ const ORBITAL_FLAG_FRONT: char = 'f';
 const ORBITAL_FLAG_HIDDEN: char = 'h';
 const ORBITAL_FLAG_BORDERLESS: char = 'l';
 const ORBITAL_FLAG_MAXIMIZED: char = 'm';
-const ORBITAL_FLAG_FULLSCREEN: char = 'M';
 const ORBITAL_FLAG_RESIZABLE: char = 'r';
 const ORBITAL_FLAG_TRANSPARENT: char = 't';

@@ -56,10 +55,7 @@ impl Window {
        // Async by default.
        let mut flag_str = ORBITAL_FLAG_ASYNC.to_string();

-        // Fullscreen takes precedence over maximize
-        if let Some(Fullscreen::Borderless(_)) = attrs.fullscreen {
-            flag_str.push(ORBITAL_FLAG_FULLSCREEN);
-        } else if attrs.maximized {
+        if attrs.maximized {
            flag_str.push(ORBITAL_FLAG_MAXIMIZED);
        }

@@ -67,6 +63,8 @@ impl Window {
            flag_str.push(ORBITAL_FLAG_RESIZABLE);
        }

+        // TODO: fullscreen
+
        if attrs.transparent {
            flag_str.push(ORBITAL_FLAG_TRANSPARENT);
        }
@@ -325,28 +323,10 @@ impl CoreWindow for Window {
        self.get_flag(ORBITAL_FLAG_MAXIMIZED).unwrap_or(false)
    }

-    fn set_fullscreen(&self, fullscreen: Option<Fullscreen>) {
-        match fullscreen {
-            Some(Fullscreen::Exclusive(..)) => {
-                // TODO: exclusive fullscreen not supported on orbital
-            },
-            Some(Fullscreen::Borderless(_monitor)) => {
-                // TODO: monitor selection not supported on orbital
-                let _ = self.set_flag(ORBITAL_FLAG_FULLSCREEN, true);
-            },
-            None => {
-                let _ = self.set_flag(ORBITAL_FLAG_FULLSCREEN, false);
-            },
-        }
-    }
+    fn set_fullscreen(&self, _monitor: Option<Fullscreen>) {}

    fn fullscreen(&self) -> Option<Fullscreen> {
-        if self.get_flag(ORBITAL_FLAG_FULLSCREEN).unwrap_or(false) {
-            // TODO: monitor selection not supported on orbital
-            Some(Fullscreen::Borderless(None))
-        } else {
-            None
-        }
+        None
    }

    #[inline]
--- a/winit-uikit/Cargo.toml
+++ b/winit-uikit/Cargo.toml
@@ -18,6 +18,7 @@ rwh_06.workspace = true
 serde = { workspace = true, optional = true }
 smol_str.workspace = true
 tracing.workspace = true
+winit-common = { workspace = true, features = ["core-foundation", "event-handler"] }
 winit-core.workspace = true

 # Platform-specific
@@ -69,7 +70,6 @@ objc2-ui-kit = { workspace = true, features = [
    "UIViewController",
    "UIWindow",
 ] }
-winit-common = { workspace = true, features = ["core-foundation", "event-handler"] }

 [package.metadata.docs.rs]
 all-features = true
--- a/winit-uikit/src/app_state.rs
+++ b/winit-uikit/src/app_state.rs
@@ -9,11 +9,11 @@ use std::{fmt, ptr};

 use dispatch2::MainThreadBound;
 use dpi::PhysicalSize;
-use objc2::MainThreadMarker;
 use objc2::rc::Retained;
+use objc2::MainThreadMarker;
 use objc2_core_foundation::{
-    CFAbsoluteTimeGetCurrent, CFRetained, CFRunLoop, CFRunLoopTimer, CGRect, CGSize,
-    kCFRunLoopCommonModes,
+    kCFRunLoopCommonModes, CFAbsoluteTimeGetCurrent, CFRetained, CFRunLoop, CFRunLoopTimer, CGRect,
+    CGSize,
 };
 use objc2_ui_kit::{UIApplication, UICoordinateSpace, UIView};
 use winit_common::core_foundation::EventLoopProxy;
--- a/winit-uikit/src/event_loop.rs
+++ b/winit-uikit/src/event_loop.rs
@@ -4,9 +4,9 @@ use std::sync::Arc;

 use objc2::rc::Retained;
 use objc2::runtime::ProtocolObject;
-use objc2::{ClassType, MainThreadMarker, msg_send};
+use objc2::{msg_send, ClassType, MainThreadMarker};
 use objc2_core_foundation::{
-    CFIndex, CFRunLoop, CFRunLoopActivity, CFRunLoopObserver, kCFRunLoopDefaultMode,
+    kCFRunLoopDefaultMode, CFIndex, CFRunLoop, CFRunLoopActivity, CFRunLoopObserver,
 };
 use objc2_foundation::{NSNotificationCenter, NSObjectProtocol};
 use objc2_ui_kit::{
@@ -26,7 +26,7 @@ use winit_core::event_loop::{
 use winit_core::monitor::MonitorHandle as CoreMonitorHandle;
 use winit_core::window::{Theme, Window as CoreWindow};

-use super::app_state::{AppState, send_occluded_event_for_all_windows};
+use super::app_state::{send_occluded_event_for_all_windows, AppState};
 use super::notification_center::create_observer;
 use crate::monitor::MonitorHandle;
 use crate::window::Window;
@@ -154,7 +154,7 @@ impl EventLoop {
        // this line sets up the main run loop before `UIApplicationMain`
        setup_control_flow_observers();

-        let center = NSNotificationCenter::defaultCenter();
+        let center = unsafe { NSNotificationCenter::defaultCenter() };

        let _did_finish_launching_observer = create_observer(
            &center,
@@ -181,7 +181,7 @@ impl EventLoop {
            // `applicationWillEnterForeground:`
            unsafe { UIApplicationWillEnterForegroundNotification },
            move |notification| {
-                let app = notification.object().expect(
+                let app = unsafe { notification.object() }.expect(
                    "UIApplicationWillEnterForegroundNotification to have application object",
                );
                // The `object` in `UIApplicationWillEnterForegroundNotification` is documented to
@@ -195,7 +195,7 @@ impl EventLoop {
            // `applicationDidEnterBackground:`
            unsafe { UIApplicationDidEnterBackgroundNotification },
            move |notification| {
-                let app = notification.object().expect(
+                let app = unsafe { notification.object() }.expect(
                    "UIApplicationDidEnterBackgroundNotification to have application object",
                );
                // The `object` in `UIApplicationDidEnterBackgroundNotification` is documented to be
@@ -209,8 +209,7 @@ impl EventLoop {
            // `applicationWillTerminate:`
            unsafe { UIApplicationWillTerminateNotification },
            move |notification| {
-                let app = notification
-                    .object()
+                let app = unsafe { notification.object() }
                    .expect("UIApplicationWillTerminateNotification to have application object");
                // The `object` in `UIApplicationWillTerminateNotification` is (somewhat) documented
                // to be `UIApplication`.
@@ -238,8 +237,7 @@ impl EventLoop {
        })
    }

-    // Require `'static` for correctness, we won't be able to `Drop` the user's state otherwise.
-    pub fn run_app_never_return<A: ApplicationHandler + 'static>(self, app: A) -> ! {
+    pub fn run_app<A: ApplicationHandler>(self, app: A) -> ! {
        let application: Option<Retained<UIApplication>> =
            unsafe { msg_send![UIApplication::class(), sharedApplication] };
        assert!(
@@ -251,10 +249,6 @@ impl EventLoop {

        // We intentionally override neither the application nor the delegate,
        // to allow the user to do so themselves!
-        //
-        // NOTE: `UIApplicationMain` is _the only way_ to start the event loop on iOS/UIKit, there
-        // are no other feasible options. See also:
-        // <https://github.com/rust-windowing/winit/pull/4165#issuecomment-2760514167>
        app_state::launch(self.mtm, app, || UIApplication::main(None, None, self.mtm))
    }

--- a/winit-uikit/src/monitor.rs
+++ b/winit-uikit/src/monitor.rs
@@ -4,10 +4,10 @@ use std::collections::VecDeque;
 use std::num::NonZeroU32;
 use std::{fmt, hash, ptr};

-use dispatch2::{MainThreadBound, run_on_main};
+use dispatch2::{run_on_main, MainThreadBound};
 use dpi::PhysicalPosition;
 use objc2::rc::Retained;
-use objc2::{MainThreadMarker, Message, available};
+use objc2::{available, MainThreadMarker, Message};
 use objc2_foundation::NSInteger;
 use objc2_ui_kit::{UIScreen, UIScreenMode};
 use winit_core::monitor::{MonitorHandleProvider, VideoMode};
@@ -190,7 +190,7 @@ impl MonitorHandle {
        Self { ui_screen: MainThreadBound::new(ui_screen, mtm) }
    }

-    pub fn video_modes_handles(&self) -> impl Iterator<Item = VideoModeHandle> + 'static {
+    pub fn video_modes_handles(&self) -> impl Iterator<Item = VideoModeHandle> {
        run_on_main(|mtm| {
            let ui_screen = self.ui_screen(mtm);

@@ -203,7 +203,7 @@ impl MonitorHandle {
        })
    }

-    pub fn video_modes(&self) -> impl Iterator<Item = VideoMode> + 'static {
+    pub fn video_modes(&self) -> impl Iterator<Item = VideoMode> {
        self.video_modes_handles().map(|handle| handle.mode)
    }

@@ -271,8 +271,8 @@ mod tests {
        let main = UIScreen::mainScreen(mtm);
        assert!(UIScreen::screens(mtm).iter().any(|screen| ptr::eq(&*screen, &*main)));

-        assert!(
+        assert!(unsafe {
            NSSet::setWithArray(&UIScreen::screens(mtm)).containsObject(&UIScreen::mainScreen(mtm))
-        );
+        });
    }
 }
--- a/winit-uikit/src/view.rs
+++ b/winit-uikit/src/view.rs
@@ -4,7 +4,7 @@ use std::cell::{Cell, RefCell};
 use dpi::PhysicalPosition;
 use objc2::rc::Retained;
 use objc2::runtime::{NSObjectProtocol, ProtocolObject};
-use objc2::{DefinedClass, MainThreadMarker, available, define_class, msg_send, sel};
+use objc2::{available, define_class, msg_send, sel, DefinedClass, MainThreadMarker};
 use objc2_core_foundation::{CGFloat, CGPoint, CGRect};
 use objc2_foundation::{NSObject, NSSet, NSString};
 use objc2_ui_kit::{
@@ -461,10 +461,6 @@ impl WinitView {
        let window = self.window().unwrap();
        let mut touch_events = Vec::new();
        for touch in touches {
-            if let UITouchType::Pencil = touch.r#type() {
-                continue;
-            }
-
            let logical_location = touch.locationInView(None);
            let touch_type = touch.r#type();
            let force = if let UITouchType::Pencil = touch_type {
--- a/winit-uikit/src/view_controller.rs
+++ b/winit-uikit/src/view_controller.rs
@@ -1,7 +1,7 @@
 use std::cell::Cell;

 use objc2::rc::Retained;
-use objc2::{DefinedClass, MainThreadMarker, available, define_class, msg_send};
+use objc2::{available, define_class, msg_send, DefinedClass, MainThreadMarker};
 use objc2_foundation::NSObject;
 use objc2_ui_kit::{
    UIDevice, UIInterfaceOrientationMask, UIRectEdge, UIResponder, UIStatusBarStyle,
--- a/winit-uikit/src/window.rs
+++ b/winit-uikit/src/window.rs
@@ -9,7 +9,7 @@ use dpi::{
    Position, Size,
 };
 use objc2::rc::Retained;
-use objc2::{MainThreadMarker, available, class, define_class, msg_send};
+use objc2::{available, class, define_class, msg_send, MainThreadMarker};
 use objc2_core_foundation::{CGFloat, CGPoint, CGRect, CGSize};
 use objc2_foundation::{NSObject, NSObjectProtocol};
 use objc2_ui_kit::{
@@ -161,7 +161,8 @@ impl Inner {

    pub fn surface_position(&self) -> PhysicalPosition<i32> {
        let view_position = self.view.frame().origin;
-        let position = self.window.convertPoint_fromView(view_position, Some(&self.view));
+        let position =
+            unsafe { self.window.convertPoint_fromView(view_position, Some(&self.view)) };
        let position = LogicalPosition::new(position.x, position.y);
        position.to_physical(self.scale_factor())
    }
@@ -392,7 +393,9 @@ impl Inner {
                }
                *current_caps = Some(capabilities);

-                self.view.becomeFirstResponder();
+                unsafe {
+                    self.view.becomeFirstResponder();
+                }
            },
            ImeRequest::Update(_) => {
                if current_caps.is_none() {
@@ -401,7 +404,9 @@ impl Inner {
            },
            ImeRequest::Disable => {
                *current_caps = None;
-                self.view.resignFirstResponder();
+                unsafe {
+                    self.view.resignFirstResponder();
+                }
            },
        }

--- a/winit-wayland/Cargo.toml
+++ b/winit-wayland/Cargo.toml
@@ -14,7 +14,6 @@ default = ["dlopen", "csd-adwaita"]
 csd-adwaita = ["sctk-adwaita", "sctk-adwaita/ab_glyph"]
 csd-adwaita-crossfont = ["sctk-adwaita", "sctk-adwaita/crossfont"]
 csd-adwaita-notitle = ["sctk-adwaita"]
-csd-adwaita-notitlebar = ["csd-adwaita-notitle"]
 dlopen = ["wayland-backend/dlopen"]
 serde = ["dep:serde", "bitflags/serde", "smol_str/serde", "dpi/serde"]

@@ -34,14 +33,12 @@ calloop.workspace = true
 libc.workspace = true
 memmap2.workspace = true
 rustix = { workspace = true, features = ["std", "system", "thread", "process", "event", "pipe"] }
-sctk = { package = "smithay-client-toolkit", version = "0.20.0", default-features = false, features = [
-    "calloop",
-] }
-sctk-adwaita = { version = "0.11.0", default-features = false, optional = true }
-wayland-backend = { version = "0.3.10", default-features = false, features = ["client_system"] }
-wayland-client = "0.31.10"
-wayland-protocols = { version = "0.32.8", features = ["staging"] }
-wayland-protocols-plasma = { version = "0.3.8", features = ["client"] }
+sctk.workspace = true
+sctk-adwaita = { workspace = true, optional = true }
+wayland-backend.workspace = true
+wayland-client.workspace = true
+wayland-protocols.workspace = true
+wayland-protocols-plasma.workspace = true
 winit-common = { workspace = true, features = ["xkb", "wayland"] }

 [package.metadata.docs.rs]
--- a/winit-wayland/src/event_loop/mod.rs
+++ b/winit-wayland/src/event_loop/mod.rs
@@ -15,7 +15,7 @@ use dpi::LogicalSize;
 use rustix::event::{PollFd, PollFlags};
 use rustix::pipe::{self, PipeFlags};
 use sctk::reexports::calloop_wayland_source::WaylandSource;
-use sctk::reexports::client::{Connection, QueueHandle, globals};
+use sctk::reexports::client::{globals, Connection, QueueHandle};
 use tracing::warn;
 use winit_core::application::ApplicationHandler;
 use winit_core::cursor::{CustomCursor as CoreCustomCursor, CustomCursorSource};
@@ -41,7 +41,7 @@ pub use winit_core::event_loop::EventLoopProxy as CoreEventLoopProxy;
 use super::output::MonitorHandle;
 use super::state::{WindowCompositorUpdate, WinitState};
 use super::window::state::FrameCallbackState;
-use super::{WindowId, logical_to_physical_rounded};
+use super::{logical_to_physical_rounded, WindowId};

 type WaylandDispatcher = calloop::Dispatcher<'static, WaylandSource<WinitState>, WinitState>;

@@ -169,6 +169,10 @@ impl EventLoop {
        Ok(event_loop)
    }

+    pub fn run_app<A: ApplicationHandler>(mut self, app: A) -> Result<(), EventLoopError> {
+        self.run_app_on_demand(app)
+    }
+
    pub fn run_app_on_demand<A: ApplicationHandler>(
        &mut self,
        mut app: A,
@@ -635,7 +639,7 @@ impl RootActiveEventLoop for ActiveEventLoop {
        let cursor_image = match cursor {
            CustomCursorSource::Image(cursor_image) => cursor_image,
            CustomCursorSource::Animation { .. } | CustomCursorSource::Url { .. } => {
-                return Err(NotSupportedError::new("unsupported cursor kind").into());
+                return Err(NotSupportedError::new("unsupported cursor kind").into())
            },
        };

--- a/winit-wayland/src/lib.rs
+++ b/winit-wayland/src/lib.rs
@@ -13,13 +13,12 @@
 //! * `wayland-csd-adwaita` (default).
 //! * `wayland-csd-adwaita-crossfont`.
 //! * `wayland-csd-adwaita-notitle`.
-//! * `wayland-csd-adwaita-notitlebar`.
 use std::ffi::c_void;
 use std::ptr::NonNull;

 use dpi::{LogicalSize, PhysicalSize};
-use sctk::reexports::client::Proxy;
 use sctk::reexports::client::protocol::wl_surface::WlSurface;
+use sctk::reexports::client::Proxy;
 use sctk::shm::slot::{Buffer, CreateBufferError, SlotPool};
 use wayland_client::protocol::wl_shm::Format;
 use winit_core::event_loop::ActiveEventLoop as CoreActiveEventLoop;
@@ -28,7 +27,9 @@ use winit_core::window::{
 };

 macro_rules! os_error {
-    ($error:expr) => {{ winit_core::error::OsError::new(line!(), file!(), $error) }};
+    ($error:expr) => {{
+        winit_core::error::OsError::new(line!(), file!(), $error)
+    }};
 }

 mod event_loop;
@@ -60,7 +61,7 @@ pub trait EventLoopExtWayland {
    fn is_wayland(&self) -> bool;
 }

-/// Additional methods when building event loop that are specific to Wayland.
+/// Additional methods on [`EventLoopBuilder`] that are specific to Wayland.
 pub trait EventLoopBuilderExtWayland {
    /// Force using Wayland.
    fn with_wayland(&mut self) -> &mut Self;
@@ -98,7 +99,6 @@ pub(crate) struct ApplicationName {
 pub struct WindowAttributesWayland {
    pub(crate) name: Option<ApplicationName>,
    pub(crate) activation_token: Option<ActivationToken>,
-    pub(crate) prefer_csd: bool,
 }

 impl WindowAttributesWayland {
@@ -120,18 +120,6 @@ impl WindowAttributesWayland {
        self.activation_token = Some(token);
        self
    }
-
-    /// Builds the window with a given preference for client-side decorations.
-    ///
-    /// When set to `true`, the window will tell the compositor that it prefers
-    /// client-side decorations, even if server-side decorations are available.
-    /// When set to `false` (the default), the window will indicate a preference
-    /// for server-side decorations.
-    #[inline]
-    pub fn with_prefer_csd(mut self, prefer_csd: bool) -> Self {
-        self.prefer_csd = prefer_csd;
-        self
-    }
 }

 impl PlatformWindowAttributes for WindowAttributesWayland {
--- a/winit-wayland/src/output.rs
+++ b/winit-wayland/src/output.rs
@@ -3,8 +3,8 @@ use std::num::NonZeroU32;

 use dpi::{LogicalPosition, PhysicalPosition};
 use sctk::output::{Mode, OutputData};
-use sctk::reexports::client::Proxy;
 use sctk::reexports::client::protocol::wl_output::WlOutput;
+use sctk::reexports::client::Proxy;
 use winit_core::monitor::{MonitorHandleProvider as CoreMonitorHandle, VideoMode};

 #[derive(Clone, Debug)]
--- a/winit-wayland/src/seat/keyboard/mod.rs
+++ b/winit-wayland/src/seat/keyboard/mod.rs
@@ -15,9 +15,9 @@ use winit_common::xkb::Context;
 use winit_core::event::{ElementState, WindowEvent};
 use winit_core::keyboard::ModifiersState;

-use crate::WindowId;
 use crate::event_loop::sink::EventSink;
 use crate::state::WinitState;
+use crate::WindowId;

 impl Dispatch<WlKeyboard, KeyboardData, WinitState> for WinitState {
    fn event(
@@ -129,23 +129,20 @@ impl Dispatch<WlKeyboard, KeyboardData, WinitState> for WinitState {
                    state.events_sink.push_window_event(WindowEvent::Focused(false), window_id);
                }
            },
-            WlKeyboardEvent::Key { key, state: WEnum::Value(key_state), .. }
-                if matches!(key_state, WlKeyState::Repeated | WlKeyState::Pressed) =>
-            {
+            WlKeyboardEvent::Key { key, state: WEnum::Value(WlKeyState::Pressed), .. } => {
                let key = key + 8;
+
                key_input(
                    keyboard_state,
                    &mut state.events_sink,
                    data,
                    key,
                    ElementState::Pressed,
-                    key_state == WlKeyState::Repeated,
+                    false,
                );

                let delay = match keyboard_state.repeat_info {
                    RepeatInfo::Repeat { delay, .. } => delay,
-                    // When compositor handles repeat, and thus we have `repeat = true`, we have
-                    // repeat on our side disabled, if it's not true, it's a compositor bug.
                    RepeatInfo::Disable => return,
                };

--- a/winit-wayland/src/seat/mod.rs
+++ b/winit-wayland/src/seat/mod.rs
@@ -12,8 +12,6 @@ use sctk::reexports::protocols::wp::text_input::zv3::client::zwp_text_input_v3::
 use sctk::seat::pointer::{ThemeSpec, ThemedPointer};
 use sctk::seat::{Capability as SeatCapability, SeatHandler, SeatState};
 use tracing::warn;
-use wayland_protocols::wp::pointer_gestures::zv1::client::zwp_pointer_gesture_pinch_v1::ZwpPointerGesturePinchV1;
-use wayland_protocols::wp::tablet::zv2::client::zwp_tablet_seat_v2::ZwpTabletSeatV2;
 use winit_core::event::WindowEvent;
 use winit_core::keyboard::ModifiersState;

@@ -25,7 +23,6 @@ mod text_input;
 mod touch;

 use keyboard::{KeyboardData, KeyboardState};
-pub use pointer::pointer_gesture::{PointerGestureData, PointerGesturesState};
 pub use pointer::relative_pointer::RelativePointerState;
 pub use pointer::{PointerConstraintsState, WinitPointerData, WinitPointerDataExt};
 use text_input::TextInputData;
@@ -51,15 +48,9 @@ pub struct WinitSeatState {
    /// The text input bound on the seat.
    text_input: Option<Arc<ZwpTextInputV3>>,

-    /// The tablet input bound on the seat.
-    tablet: Option<Arc<ZwpTabletSeatV2>>,
-
    /// The relative pointer bound on the seat.
    relative_pointer: Option<ZwpRelativePointerV1>,

-    /// The pinch pointer gesture bound on the seat.
-    pointer_gesture_pinch: Option<ZwpPointerGesturePinchV1>,
-
    /// The keyboard bound on the seat.
    keyboard_state: Option<KeyboardState>,

@@ -133,14 +124,6 @@ impl SeatHandler for WinitState {
                    )
                });

-                seat_state.pointer_gesture_pinch = self.pointer_gestures.as_ref().map(|manager| {
-                    manager.get_pinch_gesture(
-                        themed_pointer.pointer(),
-                        queue_handle,
-                        PointerGestureData::default(),
-                    )
-                });
-
                let themed_pointer = Arc::new(themed_pointer);

                // Register cursor surface.
@@ -160,12 +143,6 @@ impl SeatHandler for WinitState {
                TextInputData::default(),
            )));
        }
-
-        if let Some(tablet_state) =
-            seat_state.tablet.is_none().then_some(self.tablet_state.as_ref()).flatten()
-        {
-            seat_state.tablet = Some(Arc::new(tablet_state.get_tablet_seat(&seat, queue_handle)));
-        }
    }

    fn remove_capability(
@@ -187,11 +164,6 @@ impl SeatHandler for WinitState {
            text_input.destroy();
        }

-        // NOTE: figure out when this should actually be destroyed.
-        if let Some(tablet) = seat_state.tablet.take() {
-            tablet.destroy();
-        }
-
        match capability {
            SeatCapability::Touch => {
                if let Some(touch) = seat_state.touch.take() {
@@ -205,10 +177,6 @@ impl SeatHandler for WinitState {
                    relative_pointer.destroy();
                }

-                if let Some(pointer_gesture_pinch) = seat_state.pointer_gesture_pinch.take() {
-                    pointer_gesture_pinch.destroy();
-                }
-
                if let Some(pointer) = seat_state.pointer.take() {
                    let pointer_data = pointer.pointer().winit_data();

--- a/winit-wayland/src/seat/pointer/mod.rs
+++ b/winit-wayland/src/seat/pointer/mod.rs
@@ -30,13 +30,12 @@ use sctk::seat::SeatState;
 use dpi::{LogicalPosition, PhysicalPosition};
 use winit_core::event::{
    ElementState, MouseButton, MouseScrollDelta, PointerKind, PointerSource, TouchPhase,
-    WindowEvent, ButtonSource,
+    WindowEvent,
 };

 use crate::state::WinitState;
 use crate::WindowId;

-pub mod pointer_gesture;
 pub mod relative_pointer;

 impl PointerHandler for WinitState {
@@ -108,8 +107,8 @@ impl PointerHandler for WinitState {
                    if parent_surface != surface =>
                {
                    let click = match wayland_button_to_winit(button) {
-                        ButtonSource::Mouse(MouseButton::Left) => FrameClick::Normal,
-                        ButtonSource::Mouse(MouseButton::Right) => FrameClick::Alternate,
+                        MouseButton::Left => FrameClick::Normal,
+                        MouseButton::Right => FrameClick::Alternate,
                        _ => continue,
                    };
                    let pressed = matches!(kind, PointerEventKind::Press { .. });
@@ -186,7 +185,7 @@ impl PointerHandler for WinitState {
                            device_id: None,
                            state,
                            position,
-                            button,
+                            button: button.into(),
                        },
                        window_id,
                    );
@@ -195,7 +194,6 @@ impl PointerHandler for WinitState {
                    // Get the current phase.
                    let mut pointer_data = pointer.winit_data().inner.lock().unwrap();

-                    let has_value120_scroll = horizontal.value120 != 0 || vertical.value120 != 0;
                    let has_discrete_scroll = horizontal.discrete != 0 || vertical.discrete != 0;

                    // Figure out what to do about start/ended phases here.
@@ -207,7 +205,7 @@ impl PointerHandler for WinitState {
                    } else {
                        match pointer_data.phase {
                            // Discrete scroll only results in moved events.
-                            _ if has_value120_scroll || has_discrete_scroll => TouchPhase::Moved,
+                            _ if has_discrete_scroll => TouchPhase::Moved,
                            TouchPhase::Started | TouchPhase::Moved => TouchPhase::Moved,
                            _ => TouchPhase::Started,
                        }
@@ -218,13 +216,7 @@ impl PointerHandler for WinitState {

                    // Mice events have both pixel and discrete delta's at the same time. So prefer
                    // the discrete values if they are present.
-                    let delta = if has_value120_scroll {
-                        // NOTE: Wayland sign convention is the inverse of winit.
-                        MouseScrollDelta::LineDelta(
-                            (-horizontal.value120) as f32 / 120.,
-                            (-vertical.value120) as f32 / 120.,
-                        )
-                    } else if has_discrete_scroll {
+                    let delta = if has_discrete_scroll {
                        // NOTE: Wayland sign convention is the inverse of winit.
                        MouseScrollDelta::LineDelta(
                            (-horizontal.discrete) as f32,
@@ -409,16 +401,23 @@ impl Default for WinitPointerDataInner {
 }

 /// Convert the Wayland button into winit.
-fn wayland_button_to_winit(button: u32) -> ButtonSource {
+fn wayland_button_to_winit(button: u32) -> MouseButton {
    // These values are coming from <linux/input-event-codes.h>.
-    const BTN_MOUSE: u32 = 0x110;
-    const BTN_JOYSTICK: u32 = 0x120;
+    const BTN_LEFT: u32 = 0x110;
+    const BTN_RIGHT: u32 = 0x111;
+    const BTN_MIDDLE: u32 = 0x112;
+    const BTN_SIDE: u32 = 0x113;
+    const BTN_EXTRA: u32 = 0x114;
+    const BTN_FORWARD: u32 = 0x115;
+    const BTN_BACK: u32 = 0x116;

-    if (BTN_MOUSE..BTN_JOYSTICK).contains(&button) {
-        // Mapping orders match
-        MouseButton::try_from_u8((button - BTN_MOUSE) as u8).unwrap().into()
-    } else {
-        ButtonSource::Unknown(button as u16)
+    match button {
+        BTN_LEFT => MouseButton::Left,
+        BTN_RIGHT => MouseButton::Right,
+        BTN_MIDDLE => MouseButton::Middle,
+        BTN_BACK | BTN_SIDE => MouseButton::Back,
+        BTN_FORWARD | BTN_EXTRA => MouseButton::Forward,
+        button => MouseButton::Other(button as u16),
    }
 }

--- a/winit-wayland/src/seat/pointer/pointer_gesture.rs
+++ b/winit-wayland/src/seat/pointer/pointer_gesture.rs
@@ -1,157 +0,0 @@
-use std::ops::Deref;
-use std::sync::Mutex;
-
-use dpi::{LogicalPosition, PhysicalPosition};
-use sctk::compositor::SurfaceData;
-use sctk::globals::GlobalData;
-use sctk::reexports::client::globals::{BindError, GlobalList};
-use sctk::reexports::client::{Connection, Dispatch, Proxy, QueueHandle, delegate_dispatch};
-use sctk::reexports::protocols::wp::pointer_gestures::zv1::client::zwp_pointer_gesture_pinch_v1::{
-    Event, ZwpPointerGesturePinchV1,
-};
-use sctk::reexports::protocols::wp::pointer_gestures::zv1::client::zwp_pointer_gestures_v1::ZwpPointerGesturesV1;
-use winit_core::event::{TouchPhase, WindowEvent};
-use winit_core::window::WindowId;
-
-use crate::state::WinitState;
-
-/// Wrapper around the pointer gesture.
-#[derive(Debug)]
-pub struct PointerGesturesState {
-    pointer_gestures: ZwpPointerGesturesV1,
-}
-
-impl PointerGesturesState {
-    /// Create a new pointer gesture
-    pub fn new(
-        globals: &GlobalList,
-        queue_handle: &QueueHandle<WinitState>,
-    ) -> Result<Self, BindError> {
-        let pointer_gestures = globals.bind(queue_handle, 1..=1, GlobalData)?;
-        Ok(Self { pointer_gestures })
-    }
-}
-
-#[derive(Debug, Default)]
-pub struct PointerGestureData {
-    inner: Mutex<PointerGestureDataInner>,
-}
-
-#[derive(Debug)]
-pub struct PointerGestureDataInner {
-    window_id: Option<WindowId>,
-    previous_pinch: f64,
-}
-
-impl Default for PointerGestureDataInner {
-    fn default() -> Self {
-        Self { window_id: Default::default(), previous_pinch: 1.0 }
-    }
-}
-
-impl Deref for PointerGesturesState {
-    type Target = ZwpPointerGesturesV1;
-
-    fn deref(&self) -> &Self::Target {
-        &self.pointer_gestures
-    }
-}
-
-impl Dispatch<ZwpPointerGesturesV1, GlobalData, WinitState> for PointerGesturesState {
-    fn event(
-        _state: &mut WinitState,
-        _proxy: &ZwpPointerGesturesV1,
-        _event: <ZwpPointerGesturesV1 as wayland_client::Proxy>::Event,
-        _data: &GlobalData,
-        _conn: &Connection,
-        _qhandle: &QueueHandle<WinitState>,
-    ) {
-        unreachable!("zwp_pointer_gestures_v1 has no events")
-    }
-}
-
-impl Dispatch<ZwpPointerGesturePinchV1, PointerGestureData, WinitState> for PointerGesturesState {
-    fn event(
-        state: &mut WinitState,
-        _proxy: &ZwpPointerGesturePinchV1,
-        event: <ZwpPointerGesturePinchV1 as Proxy>::Event,
-        data: &PointerGestureData,
-        _conn: &Connection,
-        _qhandle: &QueueHandle<WinitState>,
-    ) {
-        let mut pointer_gesture_data = data.inner.lock().unwrap();
-        let (window_id, phase, pan_delta, pinch_delta, rotation_delta) = match event {
-            Event::Begin { surface, fingers, .. } => {
-                // We only support two fingers for now.
-                if fingers != 2 {
-                    return;
-                }
-
-                // Don't handle events from a subsurface.
-                if surface.data::<SurfaceData>().is_none_or(|data| data.parent_surface().is_some())
-                {
-                    return;
-                }
-
-                let window_id = crate::make_wid(&surface);
-
-                pointer_gesture_data.window_id = Some(window_id);
-                pointer_gesture_data.previous_pinch = 1.;
-
-                (window_id, TouchPhase::Started, PhysicalPosition::new(0., 0.), 0., 0.)
-            },
-            Event::Update { dx, dy, scale: pinch, rotation, .. } => {
-                let window_id = match pointer_gesture_data.window_id {
-                    Some(window_id) => window_id,
-                    _ => return,
-                };
-
-                let scale_factor = match state.windows.get_mut().get_mut(&window_id) {
-                    Some(window) => window.lock().unwrap().scale_factor(),
-                    None => return,
-                };
-
-                let pan_delta =
-                    LogicalPosition::new(dx as f32, dy as f32).to_physical(scale_factor);
-
-                let pinch_delta = pinch - pointer_gesture_data.previous_pinch;
-                pointer_gesture_data.previous_pinch = pinch;
-
-                // Wayland provides rotation in degrees cw, opposite of winit's degrees ccw.
-                let rotation_delta = -rotation as f32;
-                (window_id, TouchPhase::Moved, pan_delta, pinch_delta, rotation_delta)
-            },
-            Event::End { cancelled, .. } => {
-                let window_id = match pointer_gesture_data.window_id {
-                    Some(window_id) => window_id,
-                    _ => return,
-                };
-
-                // Reset the state.
-                *pointer_gesture_data = Default::default();
-
-                let phase = if cancelled == 0 { TouchPhase::Ended } else { TouchPhase::Cancelled };
-                (window_id, phase, PhysicalPosition::new(0., 0.), 0., 0.)
-            },
-            _ => unreachable!("Unknown event {event:?}"),
-        };
-
-        // The chance of only one of these events being necessary is extremely small,
-        // so it is easier to just send all three
-        state.events_sink.push_window_event(
-            WindowEvent::PanGesture { device_id: None, delta: pan_delta, phase },
-            window_id,
-        );
-        state.events_sink.push_window_event(
-            WindowEvent::PinchGesture { device_id: None, delta: pinch_delta, phase },
-            window_id,
-        );
-        state.events_sink.push_window_event(
-            WindowEvent::RotationGesture { device_id: None, delta: rotation_delta, phase },
-            window_id,
-        );
-    }
-}
-
-delegate_dispatch!(WinitState: [ZwpPointerGesturesV1: GlobalData] => PointerGesturesState);
-delegate_dispatch!(WinitState: [ZwpPointerGesturePinchV1: PointerGestureData] => PointerGesturesState);
--- a/winit-wayland/src/seat/text_input/mod.rs
+++ b/winit-wayland/src/seat/text_input/mod.rs
@@ -4,16 +4,14 @@ use dpi::{LogicalPosition, LogicalSize};
 use sctk::globals::GlobalData;
 use sctk::reexports::client::globals::{BindError, GlobalList};
 use sctk::reexports::client::protocol::wl_surface::WlSurface;
-use sctk::reexports::client::{Connection, Dispatch, Proxy, QueueHandle, delegate_dispatch};
+use sctk::reexports::client::{delegate_dispatch, Connection, Dispatch, Proxy, QueueHandle};
 use sctk::reexports::protocols::wp::text_input::zv3::client::zwp_text_input_manager_v3::ZwpTextInputManagerV3;
 use sctk::reexports::protocols::wp::text_input::zv3::client::zwp_text_input_v3::{
    ContentHint, ContentPurpose, Event as TextInputEvent, ZwpTextInputV3,
 };
 use tracing::warn;
 use winit_core::event::{Ime, WindowEvent};
-use winit_core::window::{
-    ImeCapabilities, ImeHint, ImePurpose, ImeRequestData, ImeSurroundingText,
-};
+use winit_core::window::{ImeCapabilities, ImePurpose, ImeRequestData, ImeSurroundingText};

 use crate::state::WinitState;

@@ -84,7 +82,6 @@ impl Dispatch<ZwpTextInputV3, TextInputData, WinitState> for TextInputState {
            },
            TextInputEvent::Leave { surface } => {
                text_input_data.surface = None;
-                text_input_data.last_preedit_empty = true;

                // Always issue a disable.
                text_input.disable();
@@ -130,13 +127,6 @@ impl Dispatch<ZwpTextInputV3, TextInputData, WinitState> for TextInputState {
                    None => return,
                };

-                // Just in case some IME sends an event for the disabled window.
-                if let Some(window) = windows.get(&window_id) {
-                    if window.lock().unwrap().text_input_state().is_none() {
-                        return;
-                    }
-                };
-
                // The events are sent to the user separately, so
                // CAUTION: events must always arrive in the order compatible with the application
                // order specified by the text-input-v3 protocol:
@@ -161,17 +151,14 @@ impl Dispatch<ZwpTextInputV3, TextInputData, WinitState> for TextInputState {
                    );
                }

-                // Clear preedit, unless all we'll be doing next is sending a new preedit and
-                // the last preedit wasn't empty.
+                // Clear preedit, unless all we'll be doing next is sending a new preedit.
                if text_input_data.pending_commit.is_some()
-                    || (text_input_data.pending_preedit.is_none()
-                        && !text_input_data.last_preedit_empty)
+                    || text_input_data.pending_preedit.is_none()
                {
                    state.events_sink.push_window_event(
                        WindowEvent::Ime(Ime::Preedit(String::new(), None)),
                        window_id,
                    );
-                    text_input_data.last_preedit_empty = true;
                }

                // Send `Commit`.
@@ -186,7 +173,6 @@ impl Dispatch<ZwpTextInputV3, TextInputData, WinitState> for TextInputState {
                    let cursor_range =
                        preedit.cursor_begin.map(|b| (b, preedit.cursor_end.unwrap_or(b)));

-                    text_input_data.last_preedit_empty = false;
                    state.events_sink.push_window_event(
                        WindowEvent::Ime(Ime::Preedit(preedit.text, cursor_range)),
                        window_id,
@@ -250,6 +236,7 @@ pub struct TextInputData {
    inner: std::sync::Mutex<TextInputDataInner>,
 }

+#[derive(Default)]
 pub struct TextInputDataInner {
    /// The `WlSurface` we're performing input to.
    surface: Option<WlSurface>,
@@ -262,21 +249,6 @@ pub struct TextInputDataInner {

    /// The text around the cursor to delete on `done`
    pending_delete: Option<DeleteSurroundingText>,
-
-    /// Last preedit empty.
-    last_preedit_empty: bool,
-}
-
-impl Default for TextInputDataInner {
-    fn default() -> Self {
-        Self {
-            surface: None,
-            pending_commit: None,
-            pending_preedit: None,
-            pending_delete: None,
-            last_preedit_empty: true,
-        }
-    }
 }

 /// The state of the preedit.
@@ -306,7 +278,9 @@ struct DeleteSurroundingText {
 #[derive(Debug, PartialEq, Clone)]
 pub struct ClientState {
    capabilities: ImeCapabilities,
+
    content_type: ContentType,
+
    /// The IME cursor area which should not be covered by the input method popup.
    cursor_area: (LogicalPosition<u32>, LogicalSize<u32>),

@@ -328,10 +302,8 @@ impl ClientState {
            surrounding_text: ImeSurroundingText::new(String::new(), 0, 0).unwrap(),
        };

-        let unsupported_flags = capabilities
-            .without_hint_and_purpose()
-            .without_cursor_area()
-            .without_surrounding_text();
+        let unsupported_flags =
+            capabilities.without_purpose().without_cursor_area().without_surrounding_text();

        if unsupported_flags != ImeCapabilities::new() {
            warn!(
@@ -350,10 +322,12 @@ impl ClientState {

    /// Updates the fields of the state which are present in update_fields.
    pub fn update(&mut self, request_data: ImeRequestData, scale_factor: f64) {
-        if let Some((hint, purpose)) =
-            request_data.hint_and_purpose.filter(|_| self.capabilities.hint_and_purpose())
-        {
-            self.content_type = (hint, purpose).into();
+        if let Some(purpose) = request_data.purpose {
+            if self.capabilities.purpose() {
+                self.content_type = purpose.into();
+            } else {
+                warn!("discarding ImePurpose update without capability enabled.");
+            }
        }

        if let Some((position, size)) = request_data.cursor_area {
@@ -376,7 +350,7 @@ impl ClientState {
    }

    pub fn content_type(&self) -> Option<ContentType> {
-        self.capabilities.hint_and_purpose().then_some(self.content_type)
+        self.capabilities.purpose().then_some(self.content_type)
    }

    pub fn cursor_area(&self) -> Option<(LogicalPosition<u32>, LogicalSize<u32>)> {
@@ -391,69 +365,20 @@ impl ClientState {
 /// Arguments to content_type
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct ContentType {
-    /// Text input hint.
-    hint: ContentHint,
-    /// Text input purpose.
+    /// Text input purpose
    purpose: ContentPurpose,
+    hint: ContentHint,
 }

-/// The two options influence each other, so they must be converted together.
-impl From<(ImeHint, ImePurpose)> for ContentType {
-    fn from((hint, purpose): (ImeHint, ImePurpose)) -> Self {
-        let purpose = match purpose {
-            ImePurpose::Password => ContentPurpose::Password,
-            ImePurpose::Terminal => ContentPurpose::Terminal,
-            ImePurpose::Phone => ContentPurpose::Phone,
-            ImePurpose::Number => ContentPurpose::Number,
-            ImePurpose::Url => ContentPurpose::Url,
-            ImePurpose::Email => ContentPurpose::Email,
-            ImePurpose::Pin => ContentPurpose::Pin,
-            ImePurpose::Date => ContentPurpose::Date,
-            ImePurpose::Time => ContentPurpose::Time,
-            ImePurpose::DateTime => ContentPurpose::Datetime,
-            _ => ContentPurpose::Normal,
+impl From<ImePurpose> for ContentType {
+    fn from(purpose: ImePurpose) -> Self {
+        let (hint, purpose) = match purpose {
+            ImePurpose::Password => (ContentHint::SensitiveData, ContentPurpose::Password),
+            ImePurpose::Terminal => (ContentHint::None, ContentPurpose::Terminal),
+            _ => return Default::default(),
        };

-        let base_hint = match purpose {
-            // Before the hint API was introduced, password  purpose guaranteed the
-            // sensitive hint. Keep this behaviour for the sake of backwards compatibility.
-            ContentPurpose::Password | ContentPurpose::Pin => ContentHint::SensitiveData,
-            _ => ContentHint::None,
-        };
-
-        let mut new_hint = base_hint;
-        if hint.contains(ImeHint::COMPLETION) {
-            new_hint |= ContentHint::Completion;
-        }
-        if hint.contains(ImeHint::SPELLCHECK) {
-            new_hint |= ContentHint::Spellcheck;
-        }
-        if hint.contains(ImeHint::AUTO_CAPITALIZATION) {
-            new_hint |= ContentHint::AutoCapitalization;
-        }
-        if hint.contains(ImeHint::LOWERCASE) {
-            new_hint |= ContentHint::Lowercase;
-        }
-        if hint.contains(ImeHint::UPPERCASE) {
-            new_hint |= ContentHint::Uppercase;
-        }
-        if hint.contains(ImeHint::TITLECASE) {
-            new_hint |= ContentHint::Titlecase;
-        }
-        if hint.contains(ImeHint::HIDDEN_TEXT) {
-            new_hint |= ContentHint::HiddenText;
-        }
-        if hint.contains(ImeHint::SENSITIVE_DATA) {
-            new_hint |= ContentHint::SensitiveData;
-        }
-        if hint.contains(ImeHint::LATIN) {
-            new_hint |= ContentHint::Latin;
-        }
-        if hint.contains(ImeHint::MULTILINE) {
-            new_hint |= ContentHint::Multiline;
-        }
-
-        Self { hint: new_hint, purpose }
+        Self { hint, purpose }
    }
 }

--- a/winit-wayland/src/state.rs
+++ b/winit-wayland/src/state.rs
@@ -12,30 +12,29 @@ use sctk::reexports::client::protocol::wl_output::WlOutput;
 use sctk::reexports::client::protocol::wl_surface::WlSurface;
 use sctk::reexports::client::{Connection, Proxy, QueueHandle};
 use sctk::registry::{ProvidesRegistryState, RegistryState};
-use sctk::seat::SeatState;
 use sctk::seat::pointer::ThemedPointer;
-use sctk::shell::WaylandSurface;
-use sctk::shell::xdg::XdgShell;
+use sctk::seat::SeatState;
 use sctk::shell::xdg::window::{Window, WindowConfigure, WindowHandler};
+use sctk::shell::xdg::XdgShell;
+use sctk::shell::WaylandSurface;
 use sctk::shm::slot::SlotPool;
 use sctk::shm::{Shm, ShmHandler};
 use sctk::subcompositor::SubcompositorState;
 use winit_core::error::OsError;

-use crate::WindowId;
 use crate::event_loop::sink::EventSink;
 use crate::output::MonitorHandle;
 use crate::seat::{
-    PointerConstraintsState, PointerGesturesState, RelativePointerState, TextInputState,
-    WinitPointerData, WinitPointerDataExt, WinitSeatState,
+    PointerConstraintsState, RelativePointerState, TextInputState, WinitPointerData,
+    WinitPointerDataExt, WinitSeatState,
 };
 use crate::types::kwin_blur::KWinBlurManager;
 use crate::types::wp_fractional_scaling::FractionalScalingManager;
-use crate::types::wp_tablet_input_v2::TabletManager;
 use crate::types::wp_viewporter::ViewporterState;
 use crate::types::xdg_activation::XdgActivationState;
 use crate::types::xdg_toplevel_icon_manager::XdgToplevelIconManagerState;
 use crate::window::{WindowRequests, WindowState};
+use crate::WindowId;

 /// Winit's Wayland state.
 #[derive(Debug)]
@@ -101,15 +100,9 @@ pub struct WinitState {
    /// Relative pointer.
    pub relative_pointer: Option<RelativePointerState>,

-    /// Tablet manager.
-    pub tablet_state: Option<TabletManager>,
-
    /// Pointer constraints to handle pointer locking and confining.
    pub pointer_constraints: Option<Arc<PointerConstraintsState>>,

-    /// Pointer gestures to handle pinch, rotate, and pan
-    pub pointer_gestures: Option<PointerGesturesState>,
-
    /// Viewporter state on the given window.
    pub viewporter_state: Option<ViewporterState>,

@@ -198,12 +191,10 @@ impl WinitState {
            text_input_state: TextInputState::new(globals, queue_handle).ok(),

            relative_pointer: RelativePointerState::new(globals, queue_handle).ok(),
-            tablet_state: TabletManager::new(globals, queue_handle).ok(),
            pointer_constraints: PointerConstraintsState::new(globals, queue_handle)
                .map(Arc::new)
                .ok(),
            pointer_surfaces: Default::default(),
-            pointer_gestures: PointerGesturesState::new(globals, queue_handle).ok(),

            monitors: Arc::new(Mutex::new(monitors)),
            events_sink: EventSink::new(),
--- a/winit-wayland/src/types/kwin_blur.rs
+++ b/winit-wayland/src/types/kwin_blur.rs
@@ -3,7 +3,7 @@
 use sctk::globals::GlobalData;
 use sctk::reexports::client::globals::{BindError, GlobalList};
 use sctk::reexports::client::protocol::wl_surface::WlSurface;
-use sctk::reexports::client::{Connection, Dispatch, Proxy, QueueHandle, delegate_dispatch};
+use sctk::reexports::client::{delegate_dispatch, Connection, Dispatch, Proxy, QueueHandle};
 use wayland_protocols_plasma::blur::client::org_kde_kwin_blur::OrgKdeKwinBlur;
 use wayland_protocols_plasma::blur::client::org_kde_kwin_blur_manager::OrgKdeKwinBlurManager;

--- a/winit-wayland/src/types/mod.rs
+++ b/winit-wayland/src/types/mod.rs
@@ -3,7 +3,6 @@
 pub mod cursor;
 pub mod kwin_blur;
 pub mod wp_fractional_scaling;
-pub mod wp_tablet_input_v2;
 pub mod wp_viewporter;
 pub mod xdg_activation;
 pub mod xdg_toplevel_icon_manager;
--- a/winit-wayland/src/types/wp_fractional_scaling.rs
+++ b/winit-wayland/src/types/wp_fractional_scaling.rs
@@ -3,7 +3,7 @@
 use sctk::globals::GlobalData;
 use sctk::reexports::client::globals::{BindError, GlobalList};
 use sctk::reexports::client::protocol::wl_surface::WlSurface;
-use sctk::reexports::client::{Connection, Dispatch, Proxy, QueueHandle, delegate_dispatch};
+use sctk::reexports::client::{delegate_dispatch, Connection, Dispatch, Proxy, QueueHandle};
 use sctk::reexports::protocols::wp::fractional_scale::v1::client::wp_fractional_scale_manager_v1::WpFractionalScaleManagerV1;
 use sctk::reexports::protocols::wp::fractional_scale::v1::client::wp_fractional_scale_v1::{
    Event as FractionalScalingEvent, WpFractionalScaleV1,
--- a/winit-wayland/src/types/wp_tablet_input_v2.rs
+++ b/winit-wayland/src/types/wp_tablet_input_v2.rs
@@ -1,343 +0,0 @@
-//! Handling of wp_tablet_input_v2.
-
-use std::sync::Mutex;
-
-use dpi::LogicalPosition;
-use sctk::compositor::SurfaceData;
-use sctk::globals::GlobalData;
-use sctk::reexports::client::backend::smallvec::SmallVec;
-use sctk::reexports::client::globals::{BindError, GlobalList};
-use sctk::reexports::client::protocol::wl_seat::WlSeat;
-use sctk::reexports::client::protocol::wl_surface::WlSurface;
-use sctk::reexports::client::{
-    Connection, Dispatch, Proxy, QueueHandle, WEnum, delegate_dispatch, event_created_child,
-};
-use sctk::reexports::protocols::wp::tablet::zv2::client::zwp_tablet_manager_v2::ZwpTabletManagerV2;
-use sctk::reexports::protocols::wp::tablet::zv2::client::zwp_tablet_pad_v2::ZwpTabletPadV2;
-use sctk::reexports::protocols::wp::tablet::zv2::client::zwp_tablet_seat_v2::{
-    self, ZwpTabletSeatV2,
-};
-use sctk::reexports::protocols::wp::tablet::zv2::client::zwp_tablet_tool_v2::{
-    ButtonState, Event as ToolEvent, Type as ToolType, ZwpTabletToolV2,
-};
-use sctk::reexports::protocols::wp::tablet::zv2::client::zwp_tablet_v2::ZwpTabletV2;
-use winit_core::event::{
-    ButtonSource, ElementState, Force, PointerKind, PointerSource, TabletToolButton,
-    TabletToolData as CoreTabletToolData, TabletToolKind, TabletToolTilt, WindowEvent,
-};
-
-use crate::state::WinitState;
-
-/// KWin blur manager.
-#[derive(Debug, Clone)]
-pub struct TabletManager {
-    manager: ZwpTabletManagerV2,
-}
-
-impl TabletManager {
-    pub fn new(
-        globals: &GlobalList,
-        queue_handle: &QueueHandle<WinitState>,
-    ) -> Result<Self, BindError> {
-        // Ignore v2 since we are not interested in its events.
-        let manager = globals.bind(queue_handle, 1..=1, GlobalData)?;
-        Ok(Self { manager })
-    }
-
-    pub fn get_tablet_seat(
-        &self,
-        seat: &WlSeat,
-        queue_handle: &QueueHandle<WinitState>,
-    ) -> ZwpTabletSeatV2 {
-        self.manager.get_tablet_seat(seat, queue_handle, ())
-    }
-}
-impl Dispatch<ZwpTabletManagerV2, GlobalData, WinitState> for TabletManager {
-    fn event(
-        _: &mut WinitState,
-        _: &ZwpTabletManagerV2,
-        _: <ZwpTabletManagerV2 as Proxy>::Event,
-        _: &GlobalData,
-        _: &Connection,
-        _: &QueueHandle<WinitState>,
-    ) {
-        unreachable!("no events defined for zwp_tablet_manager_v2");
-    }
-}
-
-impl Dispatch<ZwpTabletManagerV2, (), WinitState> for TabletManager {
-    fn event(
-        _: &mut WinitState,
-        _: &ZwpTabletManagerV2,
-        _: <ZwpTabletManagerV2 as Proxy>::Event,
-        _: &(),
-        _: &Connection,
-        _: &QueueHandle<WinitState>,
-    ) {
-        unreachable!("no events defined for zwp_tablet_manager_v2");
-    }
-}
-
-impl Dispatch<ZwpTabletSeatV2, (), WinitState> for TabletManager {
-    event_created_child!(WinitState, ZwpTabletSeatV2, [
-        zwp_tablet_seat_v2::EVT_TABLET_ADDED_OPCODE => (ZwpTabletV2, Default::default()),
-        zwp_tablet_seat_v2::EVT_TOOL_ADDED_OPCODE => (ZwpTabletToolV2, Default::default()),
-        zwp_tablet_seat_v2::EVT_PAD_ADDED_OPCODE => (ZwpTabletPadV2, Default::default())
-    ]);
-
-    fn event(
-        _: &mut WinitState,
-        _: &ZwpTabletSeatV2,
-        _: <ZwpTabletSeatV2 as Proxy>::Event,
-        _: &(),
-        _: &Connection,
-        _: &QueueHandle<WinitState>,
-    ) {
-    }
-}
-
-impl Dispatch<ZwpTabletToolV2, TabletToolData, WinitState> for TabletManager {
-    fn event(
-        state: &mut WinitState,
-        _: &ZwpTabletToolV2,
-        event: <ZwpTabletToolV2 as Proxy>::Event,
-        data: &TabletToolData,
-        _: &Connection,
-        _: &QueueHandle<WinitState>,
-    ) {
-        let mut data = data.inner.lock().unwrap();
-
-        match event {
-            ToolEvent::Type { tool_type: WEnum::Value(tool_type) } => {
-                data.ty = match tool_type {
-                    ToolType::Pen => TabletToolKind::Pen,
-                    ToolType::Eraser => TabletToolKind::Eraser,
-                    ToolType::Brush => TabletToolKind::Brush,
-                    ToolType::Pencil => TabletToolKind::Pencil,
-                    ToolType::Airbrush => TabletToolKind::Airbrush,
-                    ToolType::Finger => TabletToolKind::Finger,
-                    ToolType::Mouse => TabletToolKind::Mouse,
-                    ToolType::Lens => TabletToolKind::Lens,
-                    _ => return,
-                };
-            },
-            ToolEvent::Capability { .. } => {},
-            ToolEvent::Done => (),
-            ToolEvent::ProximityIn { serial, surface, .. } => {
-                data.pending.push(TabletEvent::Enter { serial, surface });
-            },
-            ToolEvent::ProximityOut => data.pending.push(TabletEvent::Left),
-            ToolEvent::Down { serial } => {
-                let event = TabletEvent::Button {
-                    state: ElementState::Pressed,
-                    serial: Some(serial),
-                    button: TabletToolButton::Contact,
-                };
-
-                data.pending.push(event);
-            },
-            ToolEvent::Up => {
-                let event = TabletEvent::Button {
-                    state: ElementState::Released,
-                    serial: None,
-                    button: TabletToolButton::Contact,
-                };
-
-                data.pending.push(event);
-            },
-            ToolEvent::Tilt { tilt_x, tilt_y } => {
-                data.tool_state.tilt = Some(TabletToolTilt { x: tilt_x as i8, y: tilt_y as i8 });
-            },
-            ToolEvent::Motion { x, y } => {
-                data.position = (x, y).into();
-                data.pending.push(TabletEvent::Moved);
-            },
-            ToolEvent::Pressure { pressure } => {
-                data.tool_state.force = Some(Force::Normalized(pressure as f64 / u16::MAX as f64));
-            },
-            ToolEvent::Rotation { degrees } => {
-                data.tool_state.twist = Some(degrees as u16);
-            },
-            ToolEvent::Button { serial, button, state: WEnum::Value(state) } => {
-                let state = match state {
-                    ButtonState::Released => ElementState::Released,
-                    ButtonState::Pressed => ElementState::Pressed,
-                    _ => return,
-                };
-
-                // Map similar to SDL.
-                let button = match button {
-                    // BTN_STYLUS.
-                    0x14b => TabletToolButton::Contact,
-                    0x14c => TabletToolButton::Barrel,
-                    // BTN_STYLUS3.
-                    0x149 => TabletToolButton::Other(1),
-                    // There's no defined conversion for any of that.
-                    button => TabletToolButton::Other(button as u16),
-                };
-
-                let event = TabletEvent::Button { button, state, serial: Some(serial) };
-                data.pending.push(event);
-            },
-            ToolEvent::Frame { .. } => {
-                let kind = data.ty;
-                for event in std::mem::take(&mut data.pending) {
-                    if let TabletEvent::Enter { surface, serial } = &event {
-                        data.latest_enter_serial = Some(*serial);
-                        data.surface = Some(surface.clone());
-                    }
-
-                    // Handle events only for top-level surface.
-                    let surface = match data
-                        .surface
-                        .as_ref()
-                        .map(|surface| (surface, surface.data::<SurfaceData>()))
-                    {
-                        Some((surface, Some(surface_data)))
-                            if surface_data.parent_surface().is_none() =>
-                        {
-                            surface
-                        },
-                        _ => continue,
-                    };
-
-                    let window_id = crate::make_wid(surface);
-
-                    // Ensure that window exists.
-                    let window = match state.windows.get_mut().get_mut(&window_id) {
-                        Some(window) => window.lock().unwrap(),
-                        None => continue,
-                    };
-
-                    let position = data.position.to_physical(window.scale_factor());
-
-                    let window_event = match event {
-                        TabletEvent::Enter { .. } => WindowEvent::PointerEntered {
-                            device_id: None,
-                            position,
-                            primary: true,
-                            kind: PointerKind::TabletTool(kind),
-                        },
-                        TabletEvent::Moved => WindowEvent::PointerMoved {
-                            device_id: None,
-                            position,
-                            primary: true,
-                            source: PointerSource::TabletTool {
-                                kind,
-                                data: data.tool_state.clone(),
-                            },
-                        },
-                        TabletEvent::Button { button, state, serial } => {
-                            // Update serial if we have it.
-                            if let Some(serial) = serial {
-                                data.latest_button_serial = Some(serial);
-                            }
-
-                            WindowEvent::PointerButton {
-                                device_id: None,
-                                state,
-                                position,
-                                primary: true,
-                                button: ButtonSource::TabletTool {
-                                    kind,
-                                    button,
-                                    data: data.tool_state.clone(),
-                                },
-                            }
-                        },
-                        TabletEvent::Left => WindowEvent::PointerLeft {
-                            device_id: None,
-                            position: Some(position),
-                            primary: true,
-                            kind: PointerKind::TabletTool(kind),
-                        },
-                    };
-
-                    state.events_sink.push_window_event(window_event, window_id);
-
-                    // Clear up the surface after we've processed `Left` event.
-                    if matches!(event, TabletEvent::Left) {
-                        data.surface = None;
-                        data.latest_button_serial = None;
-                        data.latest_enter_serial = None;
-                        data.tool_state = Default::default();
-                    }
-                }
-            },
-            _ => (),
-        }
-    }
-}
-
-#[derive(Debug, Default)]
-struct TabletToolData {
-    inner: Mutex<TabletToolDataInner>,
-}
-
-#[derive(Debug, Default)]
-pub(crate) struct TabletToolDataInner {
-    pub(crate) ty: TabletToolKind,
-
-    /// Core tablet tool data.
-    pub(crate) tool_state: CoreTabletToolData,
-
-    /// Pending events until the `frame` is received.
-    pub(crate) pending: SmallVec<[TabletEvent; 4]>,
-
-    /// Surface the tablet most recently entered.
-    pub(crate) surface: Option<WlSurface>,
-
-    /// Position relative to the surface.
-    pub(crate) position: LogicalPosition<f64>,
-
-    // NOTE: even though we don't utilize serials
-    // right now, track them anyway.
-    /// The serial of the latest enter event for the pointer
-    pub(crate) latest_enter_serial: Option<u32>,
-
-    /// The serial of the latest button event for the pointer
-    pub(crate) latest_button_serial: Option<u32>,
-}
-
-// Due to wayland using logical coordinates,
-// delay the conversion to physical until the dispatch actually happens,
-// so the scaling is applied at the time of actual dispatch, since it
-// can technically change before the `frame` event.
-#[derive(Debug, Clone)]
-pub(crate) enum TabletEvent {
-    Enter { serial: u32, surface: WlSurface },
-    Left,
-    Moved,
-    Button { button: TabletToolButton, state: ElementState, serial: Option<u32> },
-}
-
-impl Dispatch<ZwpTabletV2, (), WinitState> for TabletManager {
-    fn event(
-        _: &mut WinitState,
-        _: &ZwpTabletV2,
-        _: <ZwpTabletV2 as Proxy>::Event,
-        _: &(),
-        _: &Connection,
-        _: &QueueHandle<WinitState>,
-    ) {
-    }
-}
-
-impl Dispatch<ZwpTabletPadV2, (), WinitState> for TabletManager {
-    fn event(
-        _: &mut WinitState,
-        _: &ZwpTabletPadV2,
-        _: <ZwpTabletPadV2 as Proxy>::Event,
-        _: &(),
-        _: &Connection,
-        _: &QueueHandle<WinitState>,
-    ) {
-    }
-}
-
-delegate_dispatch!(WinitState: [ZwpTabletManagerV2: GlobalData] => TabletManager);
-delegate_dispatch!(WinitState: [ZwpTabletManagerV2: ()] => TabletManager);
-delegate_dispatch!(WinitState: [ZwpTabletSeatV2: ()] => TabletManager);
-delegate_dispatch!(WinitState: [ZwpTabletV2: ()] => TabletManager);
-delegate_dispatch!(WinitState: [ZwpTabletToolV2: TabletToolData] => TabletManager);
-delegate_dispatch!(WinitState: [ZwpTabletPadV2: ()] => TabletManager);
--- a/winit-wayland/src/types/wp_viewporter.rs
+++ b/winit-wayland/src/types/wp_viewporter.rs
@@ -3,7 +3,7 @@
 use sctk::globals::GlobalData;
 use sctk::reexports::client::globals::{BindError, GlobalList};
 use sctk::reexports::client::protocol::wl_surface::WlSurface;
-use sctk::reexports::client::{Connection, Dispatch, Proxy, QueueHandle, delegate_dispatch};
+use sctk::reexports::client::{delegate_dispatch, Connection, Dispatch, Proxy, QueueHandle};
 use sctk::reexports::protocols::wp::viewporter::client::wp_viewport::WpViewport;
 use sctk::reexports::protocols::wp::viewporter::client::wp_viewporter::WpViewporter;

--- a/winit-wayland/src/types/xdg_activation.rs
+++ b/winit-wayland/src/types/xdg_activation.rs
@@ -1,12 +1,12 @@
 //! Handling of xdg activation, which is used for user attention requests.

-use std::sync::Weak;
 use std::sync::atomic::AtomicBool;
+use std::sync::Weak;

 use sctk::globals::GlobalData;
 use sctk::reexports::client::globals::{BindError, GlobalList};
 use sctk::reexports::client::protocol::wl_surface::WlSurface;
-use sctk::reexports::client::{Connection, Dispatch, Proxy, QueueHandle, delegate_dispatch};
+use sctk::reexports::client::{delegate_dispatch, Connection, Dispatch, Proxy, QueueHandle};
 use sctk::reexports::protocols::xdg::activation::v1::client::xdg_activation_token_v1::{
    Event as ActivationTokenEvent, XdgActivationTokenV1,
 };
--- a/winit-wayland/src/types/xdg_toplevel_icon_manager.rs
+++ b/winit-wayland/src/types/xdg_toplevel_icon_manager.rs
@@ -7,7 +7,7 @@ use sctk::globals::GlobalData;
 use sctk::shm::slot::{Buffer, SlotPool};
 use wayland_client::globals::{BindError, GlobalList};
 use wayland_client::protocol::wl_shm::Format;
-use wayland_client::{Connection, Dispatch, Proxy, QueueHandle, delegate_dispatch};
+use wayland_client::{delegate_dispatch, Connection, Dispatch, Proxy, QueueHandle};
 use wayland_protocols::xdg::toplevel_icon::v1::client::xdg_toplevel_icon_manager_v1::XdgToplevelIconManagerV1;
 use wayland_protocols::xdg::toplevel_icon::v1::client::xdg_toplevel_icon_v1::XdgToplevelIconV1;
 use winit_core::icon::{Icon, RgbaIcon};
--- a/winit-wayland/src/window/mod.rs
+++ b/winit-wayland/src/window/mod.rs
@@ -11,8 +11,8 @@ use sctk::reexports::client::protocol::wl_display::WlDisplay;
 use sctk::reexports::client::protocol::wl_surface::WlSurface;
 use sctk::reexports::client::{Proxy, QueueHandle};
 use sctk::reexports::protocols::xdg::activation::v1::client::xdg_activation_v1::XdgActivationV1;
-use sctk::shell::WaylandSurface;
 use sctk::shell::xdg::window::{Window as SctkWindow, WindowDecorations};
+use sctk::shell::WaylandSurface;
 use tracing::warn;
 use winit_core::cursor::Cursor;
 use winit_core::error::{NotSupportedError, RequestError};
@@ -25,12 +25,12 @@ use winit_core::window::{
    WindowLevel,
 };

-use super::ActiveEventLoop;
 use super::event_loop::sink::EventSink;
 use super::output::MonitorHandle;
 use super::state::WinitState;
 use super::types::xdg_activation::XdgActivationTokenData;
-use crate::{WindowAttributesWayland, output};
+use super::ActiveEventLoop;
+use crate::{output, WindowAttributesWayland};

 pub(crate) mod state;

@@ -106,12 +106,6 @@ impl Window {
        let window =
            state.xdg_shell.create_window(surface.clone(), default_decorations, &queue_handle);

-        let WindowAttributesWayland { name: app_name, activation_token, prefer_csd } = *attributes
-            .platform
-            .take()
-            .and_then(|p| p.cast::<WindowAttributesWayland>().ok())
-            .unwrap_or_default();
-
        let mut window_state = WindowState::new(
            event_loop_window_target.handle.clone(),
            &event_loop_window_target.queue_handle,
@@ -119,7 +113,6 @@ impl Window {
            size,
            window.clone(),
            attributes.preferred_theme,
-            prefer_csd,
        );

        window_state.set_window_icon(attributes.window_icon);
@@ -132,6 +125,13 @@ impl Window {
        // Set the decorations hint.
        window_state.set_decorate(attributes.decorations);

+        let (app_name, activation_token) =
+            match attributes.platform.take().and_then(|p| p.cast::<WindowAttributesWayland>().ok())
+            {
+                Some(attrs) => (attrs.name, attrs.activation_token),
+                None => (None, None),
+            };
+
        // Set the app_id.
        if let Some(name) = app_name.map(|name| name.general) {
            window.set_app_id(name);
@@ -431,7 +431,11 @@ impl CoreWindow for Window {
    }

    fn set_maximized(&self, maximized: bool) {
-        if maximized { self.window.set_maximized() } else { self.window.unset_maximized() }
+        if maximized {
+            self.window.set_maximized()
+        } else {
+            self.window.unset_maximized()
+        }
    }

    fn is_maximized(&self) -> bool {
--- a/winit-wayland/src/window/state.rs
+++ b/winit-wayland/src/window/state.rs
@@ -21,11 +21,11 @@ use sctk::reexports::protocols::wp::text_input::zv3::client::zwp_text_input_v3::
 use sctk::reexports::protocols::wp::viewporter::client::wp_viewport::WpViewport;
 use sctk::reexports::protocols::xdg::shell::client::xdg_toplevel::ResizeEdge as XdgResizeEdge;
 use sctk::seat::pointer::{PointerDataExt, ThemedPointer};
-use sctk::shell::WaylandSurface;
-use sctk::shell::xdg::XdgSurface;
 use sctk::shell::xdg::window::{DecorationMode, Window, WindowConfigure};
-use sctk::shm::Shm;
+use sctk::shell::xdg::XdgSurface;
+use sctk::shell::WaylandSurface;
 use sctk::shm::slot::SlotPool;
+use sctk::shm::Shm;
 use sctk::subcompositor::SubcompositorState;
 use tracing::{info, warn};
 use wayland_protocols::xdg::toplevel_icon::v1::client::xdg_toplevel_icon_manager_v1::XdgToplevelIconManagerV1;
@@ -134,9 +134,6 @@ pub struct WindowState {
    /// Whether we should decorate the frame.
    decorate: bool,

-    /// Whether we should tell the compositor that we prefer drawing decorations ourself.
-    prefer_csd: bool,
-
    /// Min size.
    min_surface_size: LogicalSize<u32>,
    max_surface_size: Option<LogicalSize<u32>>,
@@ -183,7 +180,6 @@ impl WindowState {
        initial_size: Size,
        window: Window,
        theme: Option<Theme>,
-        prefer_csd: bool,
    ) -> Self {
        let compositor = winit_state.compositor_state.clone();
        let pointer_constraints = winit_state.pointer_constraints.clone();
@@ -213,7 +209,6 @@ impl WindowState {
            selected_cursor: Default::default(),
            cursor_visible: true,
            decorate: true,
-            prefer_csd,
            fractional_scale,
            frame: None,
            frame_callback_state: FrameCallbackState::None,
@@ -307,7 +302,7 @@ impl WindowState {
                subcompositor.clone(),
                self.queue_handle.clone(),
                #[cfg(feature = "sctk-adwaita")]
-                create_sctk_adwaita_config(self.theme),
+                into_sctk_adwaita_config(self.theme),
            ) {
                Ok(mut frame) => {
                    frame.set_title(&self.title);
@@ -821,7 +816,7 @@ impl WindowState {
        self.theme = theme;
        #[cfg(feature = "sctk-adwaita")]
        if let Some(frame) = self.frame.as_mut() {
-            frame.set_config(create_sctk_adwaita_config(theme))
+            frame.set_config(into_sctk_adwaita_config(theme))
        }
    }

@@ -857,7 +852,7 @@ impl WindowState {
            None => {
                return Err(
                    NotSupportedError::new("zwp_pointer_constraints is not available").into()
-                );
+                )
            },
        };

@@ -960,7 +955,7 @@ impl WindowState {
    /// Whether show or hide client side decorations.
    #[inline]
    pub fn set_decorate(&mut self, decorate: bool) {
-        if decorate == self.decorate && !self.prefer_csd {
+        if decorate == self.decorate {
            return;
        }

@@ -971,9 +966,6 @@ impl WindowState {
                // To disable decorations we should request client and hide the frame.
                self.window.request_decoration_mode(Some(DecorationMode::Client))
            },
-            _ if self.decorate && self.prefer_csd => {
-                self.window.request_decoration_mode(Some(DecorationMode::Client))
-            },
            _ if self.decorate => self.window.request_decoration_mode(Some(DecorationMode::Server)),
            _ => (),
        }
@@ -1045,7 +1037,11 @@ impl WindowState {
            text_input.set_state(self.text_input_state.as_ref(), state_change);
        }

-        if state_change { Ok(Some(self.text_input_state.is_some())) } else { Ok(None) }
+        if state_change {
+            Ok(Some(self.text_input_state.is_some()))
+        } else {
+            Ok(None)
+        }
    }

    /// Set the scale factor for the given window.
@@ -1232,14 +1228,12 @@ fn resize_direction_to_xdg(direction: ResizeDirection) -> XdgResizeEdge {
    }
 }

+// NOTE: Rust doesn't allow `From<Option<Theme>>`.
 #[cfg(feature = "sctk-adwaita")]
-fn create_sctk_adwaita_config(theme: Option<Theme>) -> sctk_adwaita::FrameConfig {
-    let config = match theme {
+fn into_sctk_adwaita_config(theme: Option<Theme>) -> sctk_adwaita::FrameConfig {
+    match theme {
        Some(Theme::Light) => sctk_adwaita::FrameConfig::light(),
        Some(Theme::Dark) => sctk_adwaita::FrameConfig::dark(),
        None => sctk_adwaita::FrameConfig::auto(),
-    };
-    #[cfg(feature = "csd-adwaita-notitlebar")]
-    let config = config.hide_titlebar(true);
-    config
+    }
 }
--- a/winit-web/src/async/abortable.rs
+++ b/winit-web/src/async/abortable.rs
@@ -2,8 +2,8 @@ use std::error::Error;
 use std::fmt::{self, Display, Formatter};
 use std::future::Future;
 use std::pin::Pin;
-use std::sync::Arc;
 use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::Arc;
 use std::task::{Context, Poll};

 use pin_project::pin_project;
--- a/winit-web/src/async/channel.rs
+++ b/winit-web/src/async/channel.rs
@@ -1,7 +1,7 @@
 use std::future;
-use std::sync::Arc;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::mpsc::{self, RecvError, SendError, TryRecvError};
+use std::sync::Arc;
 use std::task::Poll;

 use super::AtomicWaker;
--- a/winit-web/src/async/concurrent_queue.rs
+++ b/winit-web/src/async/concurrent_queue.rs
@@ -32,10 +32,13 @@ impl<T> ConcurrentQueue<T> {
    }

    pub fn pop(&self) -> Result<T, PopError> {
-        self.queue
-            .borrow_mut()
-            .pop()
-            .ok_or_else(|| if self.closed.get() { PopError::Closed } else { PopError::Empty })
+        self.queue.borrow_mut().pop().ok_or_else(|| {
+            if self.closed.get() {
+                PopError::Closed
+            } else {
+                PopError::Empty
+            }
+        })
    }

    pub fn close(&self) -> bool {
--- a/winit-web/src/async/dispatcher.rs
+++ b/winit-web/src/async/dispatcher.rs
@@ -6,7 +6,7 @@ use std::rc::Rc;
 use std::sync::{Arc, Condvar, Mutex};

 use super::super::main_thread::MainThreadMarker;
-use super::{Receiver, Sender, Wrapper, channel};
+use super::{channel, Receiver, Sender, Wrapper};

 pub struct Dispatcher<T: 'static>(Wrapper<T, Arc<Sender<Closure<T>>>, Closure<T>>);

--- a/winit-web/src/async/mod.rs
+++ b/winit-web/src/async/mod.rs
@@ -12,7 +12,7 @@ pub(crate) use atomic_waker::AtomicWaker;
 use concurrent_queue::{ConcurrentQueue, PushError};

 pub use self::abortable::{AbortHandle, Abortable, DropAbortHandle};
-pub use self::channel::{Receiver, Sender, channel};
+pub use self::channel::{channel, Receiver, Sender};
 pub use self::dispatcher::{DispatchRunner, Dispatcher};
 pub use self::notifier::{Notified, Notifier};
 pub(crate) use self::wrapper::Wrapper;
--- a/winit-web/src/cursor.rs
+++ b/winit-web/src/cursor.rs
@@ -6,14 +6,14 @@ use std::ops::{Deref, DerefMut};
 use std::pin::Pin;
 use std::rc::Rc;
 use std::sync::Arc;
-use std::task::{Context, Poll, Waker, ready};
+use std::task::{ready, Context, Poll, Waker};
 use std::time::Duration;

 use cursor_icon::CursorIcon;
 use js_sys::{Array, Object};
-use wasm_bindgen::JsCast;
 use wasm_bindgen::closure::Closure;
 use wasm_bindgen::prelude::wasm_bindgen;
+use wasm_bindgen::JsCast;
 use wasm_bindgen_futures::JsFuture;
 use web_sys::{
    Blob, Document, DomException, HtmlCanvasElement, HtmlImageElement, ImageBitmap,
@@ -21,11 +21,11 @@ use web_sys::{
 };
 use winit_core::cursor::{Cursor, CursorImage, CustomCursorProvider, CustomCursorSource};

-use crate::CustomCursorError;
-use crate::r#async::{AbortHandle, Abortable, DropAbortHandle, Notified, Notifier};
 use crate::backend::Style;
 use crate::event_loop::ActiveEventLoop;
 use crate::main_thread::{MainThreadMarker, MainThreadSafe};
+use crate::r#async::{AbortHandle, Abortable, DropAbortHandle, Notified, Notifier};
+use crate::CustomCursorError;

 #[derive(Clone, Debug)]
 pub struct CustomCursor {
@@ -216,7 +216,7 @@ impl CursorHandler {
            Cursor::Custom(cursor) => {
                let cursor = match cursor.cast_ref::<CustomCursor>() {
                    Some(cursor) => cursor,
-                    None => return,
+                    None => todo!(),
                };

                if let SelectedCursor::Loading { cursor: old_cursor, .. }
@@ -487,7 +487,7 @@ fn from_rgba(
    window: &Window,
    document: Document,
    image: &CursorImage,
-) -> impl Future<Output = Result<Image, CustomCursorError>> + use<> {
+) -> impl Future<Output = Result<Image, CustomCursorError>> {
    // 1. Create an `ImageData` from the RGBA data.
    // 2. Create an `ImageBitmap` from the `ImageData`.
    // 3. Draw `ImageBitmap` on an `HTMLCanvasElement`.
--- a/winit-web/src/event_loop/mod.rs
+++ b/winit-web/src/event_loop/mod.rs
@@ -5,7 +5,7 @@ use winit_core::error::{EventLoopError, NotSupportedError};
 use winit_core::event_loop::ActiveEventLoop as RootActiveEventLoop;

 use crate::{
-    HasMonitorPermissionFuture, MonitorPermissionFuture, PollStrategy, WaitUntilStrategy, backend,
+    backend, HasMonitorPermissionFuture, MonitorPermissionFuture, PollStrategy, WaitUntilStrategy,
 };

 mod proxy;
@@ -39,8 +39,32 @@ impl EventLoop {
        EVENT_LOOP_CREATED.store(false, Ordering::Relaxed);
    }

-    pub fn register_app<A: ApplicationHandler + 'static>(self, app: A) {
-        self.elw.run(Box::new(app));
+    pub fn run_app<A: ApplicationHandler>(self, app: A) -> ! {
+        let app = Box::new(app);
+
+        // SAFETY: The `transmute` is necessary because `run()` requires `'static`. This is safe
+        // because this function will never return and all resources not cleaned up by the point we
+        // `throw` will leak, making this actually `'static`.
+        let app = unsafe {
+            std::mem::transmute::<
+                Box<dyn ApplicationHandler + '_>,
+                Box<dyn ApplicationHandler + 'static>,
+            >(app)
+        };
+
+        self.elw.run(app, false);
+
+        // Throw an exception to break out of Rust execution and use unreachable to tell the
+        // compiler this function won't return, giving it a return type of '!'
+        backend::throw(
+            "Using exceptions for control flow, don't mind me. This isn't actually an error!",
+        );
+
+        unreachable!();
+    }
+
+    pub fn spawn_app<A: ApplicationHandler + 'static>(self, app: A) {
+        self.elw.run(Box::new(app), true);
    }

    pub fn window_target(&self) -> &dyn RootActiveEventLoop {
--- a/winit-web/src/event_loop/proxy.rs
+++ b/winit-web/src/event_loop/proxy.rs
@@ -1,13 +1,13 @@
 use std::future;
-use std::sync::Arc;
 use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::Arc;
 use std::task::Poll;

 use winit_core::event_loop::EventLoopProxyProvider;

 use super::super::main_thread::MainThreadMarker;
-use crate::r#async::{AtomicWaker, Wrapper};
 use crate::event_loop::runner::WeakShared;
+use crate::r#async::{AtomicWaker, Wrapper};

 #[derive(Debug)]
 pub struct EventLoopProxy(Wrapper<WeakShared, Arc<State>, ()>);
--- a/winit-web/src/event_loop/runner.rs
+++ b/winit-web/src/event_loop/runner.rs
@@ -6,8 +6,8 @@ use std::sync::Arc;
 use std::{fmt, iter};

 use dpi::PhysicalSize;
-use wasm_bindgen::JsCast;
 use wasm_bindgen::prelude::Closure;
+use wasm_bindgen::JsCast;
 use web_sys::{Document, KeyboardEvent, Navigator, PageTransitionEvent, PointerEvent, WheelEvent};
 use web_time::{Duration, Instant};
 use winit_core::application::ApplicationHandler;
@@ -19,14 +19,14 @@ use winit_core::window::WindowId;

 use super::proxy::EventLoopProxy;
 use super::state::State;
-use crate::r#async::DispatchRunner;
 use crate::backend::{EventListenerHandle, SafeAreaHandle};
 use crate::event_loop::ActiveEventLoop;
 use crate::main_thread::MainThreadMarker;
 use crate::monitor::MonitorHandler;
-use crate::web_sys::event::ButtonsState;
+use crate::r#async::DispatchRunner;
+use crate::web_sys::event::mouse_button_to_id;
 use crate::window::Inner;
-use crate::{EventLoop, PollStrategy, WaitUntilStrategy, backend, event};
+use crate::{backend, event, EventLoop, PollStrategy, WaitUntilStrategy};

 #[derive(Debug)]
 pub struct Shared(Rc<Execution>);
@@ -48,6 +48,7 @@ struct Execution {
    exit: Cell<bool>,
    runner: RefCell<RunnerEnum>,
    suspended: Cell<bool>,
+    event_loop_recreation: Cell<bool>,
    events: RefCell<VecDeque<Event>>,
    id: Cell<usize>,
    window: web_sys::Window,
@@ -194,6 +195,7 @@ impl Shared {
                exit: Cell::new(false),
                runner: RefCell::new(RunnerEnum::Pending),
                suspended: Cell::new(false),
+                event_loop_recreation: Cell::new(false),
                events: RefCell::new(VecDeque::new()),
                window,
                navigator,
@@ -316,10 +318,8 @@ impl Shared {
                // chorded button event
                let device_id = event::mkdid(event.pointer_id());

-                if let Some(button) = backend::event::raw_button(&event) {
-                    let state = if backend::event::pointer_buttons(&event)
-                        .contains(ButtonsState::from_bits_retain(button))
-                    {
+                if let Some(button) = backend::event::mouse_button(&event) {
+                    let state = if backend::event::mouse_buttons(&event).contains(button.into()) {
                        ElementState::Pressed
                    } else {
                        ElementState::Released
@@ -327,7 +327,10 @@ impl Shared {

                    runner.send_event(Event::DeviceEvent {
                        device_id,
-                        event: DeviceEvent::Button { button: button.into(), state },
+                        event: DeviceEvent::Button {
+                            button: mouse_button_to_id(button).into(),
+                            state,
+                        },
                    });

                    return;
@@ -335,16 +338,14 @@ impl Shared {

                // pointer move event
                let mut delta = backend::event::MouseDelta::init(&navigator, &event);
-                runner.send_events(backend::event::pointer_move_event(event).map(
-                    |event: web_sys::PointerEvent| {
-                        let delta = delta.delta(&event).to_physical(backend::scale_factor(&window));
+                runner.send_events(backend::event::pointer_move_event(event).map(|event| {
+                    let delta = delta.delta(&event).to_physical(backend::scale_factor(&window));

-                        Event::DeviceEvent {
-                            device_id,
-                            event: DeviceEvent::PointerMotion { delta: (delta.x, delta.y) },
-                        }
-                    },
-                ));
+                    Event::DeviceEvent {
+                        device_id,
+                        event: DeviceEvent::PointerMotion { delta: (delta.x, delta.y) },
+                    }
+                }));
            }),
        ));
        let runner = self.clone();
@@ -374,11 +375,11 @@ impl Shared {
                    return;
                }

-                let button = backend::event::raw_button(&event).expect("no pointer button pressed");
+                let button = backend::event::mouse_button(&event).expect("no mouse button pressed");
                runner.send_event(Event::DeviceEvent {
                    device_id: event::mkdid(event.pointer_id()),
                    event: DeviceEvent::Button {
-                        button: button.into(),
+                        button: mouse_button_to_id(button).into(),
                        state: ElementState::Pressed,
                    },
                });
@@ -393,11 +394,11 @@ impl Shared {
                    return;
                }

-                let button = backend::event::raw_button(&event).expect("no pointer button pressed");
+                let button = backend::event::mouse_button(&event).expect("no mouse button pressed");
                runner.send_event(Event::DeviceEvent {
                    device_id: event::mkdid(event.pointer_id()),
                    event: DeviceEvent::Button {
-                        button: button.into(),
+                        button: mouse_button_to_id(button).into(),
                        state: ElementState::Released,
                    },
                });
@@ -770,7 +771,9 @@ impl Shared {
        // * For each undropped `Window`:
        //     * The `register_redraw_request` closure.
        //     * The `destroy_fn` closure.
-        EventLoop::allow_event_loop_recreation();
+        if self.0.event_loop_recreation.get() {
+            EventLoop::allow_event_loop_recreation();
+        }
    }

    // Check if the event loop is currently closed
@@ -798,13 +801,21 @@ impl Shared {
            DeviceEvents::Always => true,
            DeviceEvents::WhenFocused => {
                self.0.all_canvases.borrow().iter().any(|(_, canvas, _)| {
-                    if let Some(canvas) = canvas.upgrade() { canvas.has_focus.get() } else { false }
+                    if let Some(canvas) = canvas.upgrade() {
+                        canvas.has_focus.get()
+                    } else {
+                        false
+                    }
                })
            },
            DeviceEvents::Never => false,
        }
    }

+    pub fn event_loop_recreation(&self, allow: bool) {
+        self.0.event_loop_recreation.set(allow)
+    }
+
    pub(crate) fn control_flow(&self) -> ControlFlow {
        self.0.control_flow.get()
    }
--- a/winit-web/src/event_loop/window_target.rs
+++ b/winit-web/src/event_loop/window_target.rs
@@ -56,7 +56,8 @@ impl ActiveEventLoop {
        Self { runner: runner::Shared::new(), modifiers: ModifiersShared::default() }
    }

-    pub(crate) fn run(&self, app: Box<dyn ApplicationHandler>) {
+    pub(crate) fn run(&self, app: Box<dyn ApplicationHandler>, event_loop_recreation: bool) {
+        self.runner.event_loop_recreation(event_loop_recreation);
        self.runner.start(app, self.clone());
    }

@@ -521,8 +522,13 @@ impl RootActiveEventLoop for ActiveEventLoop {
    }

    fn system_theme(&self) -> Option<Theme> {
-        backend::is_dark_mode(self.runner.window())
-            .map(|is_dark_mode| if is_dark_mode { Theme::Dark } else { Theme::Light })
+        backend::is_dark_mode(self.runner.window()).map(|is_dark_mode| {
+            if is_dark_mode {
+                Theme::Dark
+            } else {
+                Theme::Light
+            }
+        })
    }

    fn set_control_flow(&self, control_flow: ControlFlow) {
--- a/winit-web/src/lib.rs
+++ b/winit-web/src/lib.rs
@@ -61,7 +61,9 @@
 // compliant way.

 macro_rules! os_error {
-    ($error:expr) => {{ winit_core::error::OsError::new(line!(), file!(), $error) }};
+    ($error:expr) => {{
+        winit_core::error::OsError::new(line!(), file!(), $error)
+    }};
 }

 mod r#async;
@@ -85,6 +87,7 @@ use std::task::{Context, Poll};
 use ::web_sys::HtmlCanvasElement;
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
+use winit_core::application::ApplicationHandler;
 use winit_core::cursor::{CustomCursor, CustomCursorSource};
 use winit_core::error::NotSupportedError;
 use winit_core::event_loop::ActiveEventLoop;
@@ -236,6 +239,30 @@ impl Default for WindowAttributesWeb {

 /// Additional methods on `EventLoop` that are specific to the Web.
 pub trait EventLoopExtWeb {
+    /// Initializes the winit event loop.
+    ///
+    /// Unlike
+    #[cfg_attr(target_feature = "exception-handling", doc = "`run_app()`")]
+    #[cfg_attr(
+        not(target_feature = "exception-handling"),
+        doc = "[`run_app()`]"
+    )]
+    /// [^1], this returns immediately, and doesn't throw an exception in order to
+    /// satisfy its [`!`] return type.
+    ///
+    /// Once the event loop has been destroyed, it's possible to reinitialize another event loop
+    /// by calling this function again. This can be useful if you want to recreate the event loop
+    /// while the WebAssembly module is still loaded. For example, this can be used to recreate the
+    /// event loop when switching between tabs on a single page application.
+    #[rustfmt::skip]
+    ///
+    #[cfg_attr(
+        not(target_feature = "exception-handling"),
+        doc = "[`run_app()`]: EventLoop::run_app()"
+    )]
+    /// [^1]: `run_app()` is _not_ available on Wasm when the target supports `exception-handling`.
+    fn spawn_app<A: ApplicationHandler + 'static>(self, app: A);
+
    /// Sets the strategy for [`ControlFlow::Poll`].
    ///
    /// See [`PollStrategy`].
--- a/winit-web/src/lock.rs
+++ b/winit-web/src/lock.rs
@@ -5,7 +5,7 @@ use tracing::error;
 use wasm_bindgen::closure::Closure;
 use wasm_bindgen::prelude::wasm_bindgen;
 use wasm_bindgen::{JsCast, JsValue};
-use web_sys::{Document, DomException, Element, Navigator, console};
+use web_sys::{console, Document, DomException, Element, Navigator};

 pub(crate) fn is_cursor_lock_raw(navigator: &Navigator, document: &Document) -> bool {
    thread_local! {
--- a/winit-web/src/monitor.rs
+++ b/winit-web/src/monitor.rs
@@ -9,7 +9,7 @@ use std::ops::{Deref, DerefMut};
 use std::pin::Pin;
 use std::rc::{Rc, Weak};
 use std::sync::{Arc, OnceLock};
-use std::task::{Context, Poll, ready};
+use std::task::{ready, Context, Poll};

 use dpi::{LogicalSize, PhysicalPosition, PhysicalSize};
 use js_sys::{Object, Promise};
@@ -19,14 +19,14 @@ use wasm_bindgen::prelude::wasm_bindgen;
 use wasm_bindgen::{JsCast, JsValue};
 use wasm_bindgen_futures::JsFuture;
 use web_sys::{
-    DomException, Navigator, OrientationLockType, OrientationType, PermissionState,
-    PermissionStatus, ScreenOrientation, Window, console,
+    console, DomException, Navigator, OrientationLockType, OrientationType, PermissionState,
+    PermissionStatus, ScreenOrientation, Window,
 };
 use winit_core::monitor::{MonitorHandle as CoreMonitorHandle, MonitorHandleProvider, VideoMode};

-use super::r#async::{Dispatcher, Notified, Notifier};
 use super::event_loop::runner::WeakShared;
 use super::main_thread::MainThreadMarker;
+use super::r#async::{Dispatcher, Notified, Notifier};
 use super::web_sys::{Engine, EventListenerHandle};
 use crate::{
    MonitorPermissionError, Orientation, OrientationData, OrientationLock, OrientationLockError,
@@ -292,7 +292,11 @@ impl Inner {
    }

    fn name(&self) -> Option<String> {
-        if let Screen::Detailed { screen, .. } = &self.screen { Some(screen.label()) } else { None }
+        if let Screen::Detailed { screen, .. } = &self.screen {
+            Some(screen.label())
+        } else {
+            None
+        }
    }

    fn orientation_raw(&self) -> &ScreenOrientationExt {
@@ -434,7 +438,11 @@ impl Detailed {
            let internal_screen =
                internal_screen.upgrade().expect("dropped `MonitorHandle` without cleaning up");

-            if *internal_screen == screen { Some((*id, internal_screen)) } else { None }
+            if *internal_screen == screen {
+                Some((*id, internal_screen))
+            } else {
+                None
+            }
        });
        let (id, screen) = if let Some((id, screen)) = found_screen {
            (id, screen)
@@ -656,7 +664,7 @@ impl MonitorHandler {
            State::Unsupported => {
                return MonitorPermissionFuture::Ready(Some(Err(
                    MonitorPermissionError::Unsupported,
-                )));
+                )))
            },
            // If we are currently initializing, wait for initialization to finish before we do our
            // thing.
@@ -668,7 +676,7 @@ impl MonitorHandler {
                    )
                    .0,
                    notified: notified.clone(),
-                };
+                }
            },
            // If we finished initialization we at least possess `PermissionStatus`.
            State::Permission { permission, .. } => permission,
@@ -680,7 +688,7 @@ impl MonitorHandler {
        match permission.state() {
            PermissionState::Granted | PermissionState::Prompt => (),
            PermissionState::Denied => {
-                return MonitorPermissionFuture::Ready(Some(Err(MonitorPermissionError::Denied)));
+                return MonitorPermissionFuture::Ready(Some(Err(MonitorPermissionError::Denied)))
            },
            _ => {
                error!("encountered unknown permission state: {}", permission.state_string());
--- a/winit-web/src/web_sys/animation_frame.rs
+++ b/winit-web/src/web_sys/animation_frame.rs
@@ -1,8 +1,8 @@
 use std::cell::Cell;
 use std::rc::Rc;

-use wasm_bindgen::JsCast;
 use wasm_bindgen::closure::Closure;
+use wasm_bindgen::JsCast;

 pub struct AnimationFrameHandler {
    window: web_sys::Window,
--- a/winit-web/src/web_sys/canvas.rs
+++ b/winit-web/src/web_sys/canvas.rs
@@ -5,8 +5,8 @@ use std::sync::{Arc, Mutex};

 use dpi::{LogicalPosition, PhysicalPosition, PhysicalSize};
 use smol_str::SmolStr;
-use wasm_bindgen::JsCast;
 use wasm_bindgen::closure::Closure;
+use wasm_bindgen::JsCast;
 use web_sys::{
    CssStyleDeclaration, Document, Event, FocusEvent, HtmlCanvasElement, KeyboardEvent, Navigator,
    PointerEvent, WheelEvent,
@@ -28,7 +28,7 @@ use super::event_handle::EventListenerHandle;
 use super::intersection_handle::IntersectionObserverHandle;
 use super::media_query_handle::MediaQueryListHandle;
 use super::pointer::PointerHandler;
-use super::{ResizeScaleHandle, event, fullscreen};
+use super::{event, fullscreen, ResizeScaleHandle};
 use crate::WindowAttributesWeb;

 #[allow(dead_code)]
@@ -502,7 +502,8 @@ impl Canvas {
                surface_size_writer: SurfaceSizeWriter::new(Arc::downgrade(&new_size)),
            });

-            *new_size.lock().unwrap()
+            let new_size = *new_size.lock().unwrap();
+            new_size
        };

        if current_size != new_size {
--- a/Show More
+++ b/Show More