Only run observers in the default run loop mode

Remove EventLoopExtIOS::idiom and ios::Idiom (#2924 )
Introduced in 3a7350c with unclear motivation. Nowadays, this feature is incomplete and unsound, and the equivalent functionality can be trivially achieved outside of `winit` using `objc2-ui-kit`.
2026-06-26 22:53:15 -04:00 · 2024-06-29 00:27:31 +02:00 · 2024-06-24 22:56:20 +02:00 · 2024-06-24 22:40:49 +02:00 · 2024-06-24 13:26:49 +02:00 · 2024-06-24 13:04:55 +03:00
103 changed files with 2786 additions and 3188 deletions
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -1,10 +1,11 @@
 # Android
-/src/platform/android.rs            @msiglreith @MarijnS95
-/src/platform_impl/android          @msiglreith @MarijnS95
+/src/platform/android.rs            @MarijnS95
+/src/platform_impl/android          @MarijnS95

-# iOS
+# Apple (AppKit + UIKit)
 /src/platform/ios.rs                @madsmtm
-/src/platform_impl/ios              @madsmtm
+/src/platform/macos.rs              @madsmtm
+/src/platform_impl/apple            @madsmtm

 # Unix
 /src/platform_impl/linux/mod.rs     @kchibisov
@@ -17,17 +18,13 @@
 /src/platform/x11.rs                @kchibisov @notgull
 /src/platform_impl/linux/x11        @kchibisov @notgull

-# macOS
-/src/platform/macos.rs              @madsmtm
-/src/platform_impl/macos            @madsmtm
-
 # Web
 /src/platform/web.rs                @daxpedda
 /src/platform_impl/web              @daxpedda

 # Windows
-/src/platform/windows.rs            @msiglreith
-/src/platform_impl/windows          @msiglreith
+/src/platform/windows.rs            @notgull
+/src/platform_impl/windows          @notgull

 # Orbital (Redox OS)
 /src/platform/orbital.rs            @jackpot51
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -10,7 +10,7 @@ jobs:
    name: Check formatting
    runs-on: ubuntu-latest
    steps:
-    - uses: actions/checkout@v4
+    - uses: taiki-e/checkout-action@v1
    - uses: dtolnay/rust-toolchain@nightly
      with:
        components: rustfmt
@@ -22,7 +22,7 @@ jobs:
    runs-on: ubuntu-latest
    timeout-minutes: 30
    steps:
-      - uses: actions/checkout@v4
+      - uses: taiki-e/checkout-action@v1
      - uses: taiki-e/install-action@v2
        with:
          tool: typos-cli
@@ -42,7 +42,7 @@ jobs:
    strategy:
      fail-fast: false
      matrix:
-        toolchain: [stable, nightly, '1.70.0']
+        toolchain: [stable, nightly, '1.73']
        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,  }
@@ -61,10 +61,10 @@ jobs:
          - { name: 'web',                target: wasm32-unknown-unknown,   os: ubuntu-latest,   }
        exclude:
          # Android is tested on stable-3
-          - toolchain: '1.70.0'
+          - toolchain: '1.73'
            platform: { name: 'Android', target: aarch64-linux-android, os: ubuntu-latest, options: '--package=winit --features=android-native-activity', cmd: 'apk --' }
        include:
-          - toolchain: '1.70.0'
+          - toolchain: '1.73'
            platform: { name: 'Android', target: aarch64-linux-android, os: ubuntu-latest, options: '--package=winit --features=android-native-activity', cmd: 'apk --' }
          - toolchain: 'nightly'
            platform: {
@@ -88,7 +88,7 @@ jobs:
      CMD: ${{ matrix.platform.cmd }}

    steps:
-    - uses: actions/checkout@v4
+    - uses: taiki-e/checkout-action@v1

    - name: Restore cache of cargo folder
      # We use `restore` and later `save`, so that we can create the key after
@@ -149,13 +149,13 @@ jobs:
    - name: Test dpi crate
      if: >
        contains(matrix.platform.name, 'Linux 64bit') &&
-        matrix.toolchain != '1.70.0'
+        matrix.toolchain != '1.73'
      run: cargo test -p dpi

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

    - name: Run tests
@@ -164,7 +164,7 @@ jobs:
        !contains(matrix.platform.target, 'ios') &&
        !contains(matrix.platform.target, 'wasm32') &&
        !contains(matrix.platform.target, 'redox') &&
-        matrix.toolchain != '1.70.0'
+        matrix.toolchain != '1.73'
      run: cargo $CMD test $OPTIONS

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

    - name: Run tests with serde enabled
@@ -183,7 +183,7 @@ jobs:
        !contains(matrix.platform.target, 'ios') &&
        !contains(matrix.platform.target, 'wasm32') &&
        !contains(matrix.platform.target, 'redox') &&
-        matrix.toolchain != '1.70.0'
+        matrix.toolchain != '1.73'
      run: cargo $CMD test $OPTIONS --features serde

    - name: Check docs.rs documentation
@@ -220,9 +220,24 @@ jobs:
          - { name: 'Windows', target: x86_64-pc-windows-gnu }

    steps:
-    - uses: actions/checkout@v4
+    - uses: taiki-e/checkout-action@v1
    - uses: EmbarkStudios/cargo-deny-action@v1
      with:
        command: check
        log-level: error
        arguments: --all-features --target ${{ matrix.platform.target }}
+
+  swc:
+    name: Minimize JavaScript
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: taiki-e/checkout-action@v1
+      - name: Install SWC
+        run: sudo npm i -g @swc/cli
+      - name: Run SWC
+        run: |
+          swc src/platform_impl/web/web_sys/worker.js -o src/platform_impl/web/web_sys/worker.min.js
+      - name: Check for diff
+        run: |
+          [[ -z $(git status -s) ]]
--- a/.gitignore
+++ b/.gitignore
@@ -3,8 +3,5 @@ target/
 rls/
 .vscode/
 *~
-*.wasm
-*.ts
-*.js
 #*#
 .DS_Store
--- a/.swcrc
+++ b/.swcrc
@@ -0,0 +1,12 @@
+{
+	"minify": true,
+	"jsc": {
+		"target": "es2022",
+		"minify": {
+			"compress": {
+				"unused": true
+			},
+			"mangle": true
+		}
+	}
+}
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "winit"
-version = "0.30.0"
+version = "0.30.3"
 authors = [
    "The winit contributors",
    "Pierre Krieger <pierre.krieger1708@gmail.com>",
@@ -71,7 +71,7 @@ rwh_05 = ["dep:rwh_05", "ndk/rwh_05"]
 rwh_06 = ["dep:rwh_06", "ndk/rwh_06"]

 [build-dependencies]
-cfg_aliases = "0.2.0"
+cfg_aliases = "0.2.1"

 [dependencies]
 bitflags = "2"
@@ -86,11 +86,11 @@ rwh_06 = { package = "raw-window-handle", version = "0.6", features = [
 ], optional = true }
 serde = { workspace = true, optional = true }
 smol_str = "0.2.0"
-tracing = { version = "0.1.40", default_features = false }
+tracing = { version = "0.1.40", default-features = false }

 [dev-dependencies]
 image = { version = "0.25.0", default-features = false, features = ["png"] }
-tracing = { version = "0.1.40", default_features = false, features = ["log"] }
+tracing = { version = "0.1.40", default-features = false, features = ["log"] }
 tracing-subscriber = { version = "0.3.18", features = ["env-filter"] }
 winit = { path = ".", features = ["rwh_05"] }

@@ -102,41 +102,45 @@ softbuffer = { version = "0.4.0", default-features = false, features = [
    "wayland-dlopen",
 ] }

+# Android
 [target.'cfg(target_os = "android")'.dependencies]
 android-activity = "0.6.0"
 ndk = { version = "0.9.0", default-features = false }

-[target.'cfg(any(target_os = "ios", target_os = "macos"))'.dependencies]
+# AppKit or UIKit
+[target.'cfg(target_vendor = "apple")'.dependencies]
 core-foundation = "0.9.3"
-objc2 = "0.5.1"
+objc2 = "0.5.2"

+# AppKit
 [target.'cfg(target_os = "macos")'.dependencies]
 core-graphics = "0.23.1"
-
-[target.'cfg(target_os = "macos")'.dependencies.objc2-foundation]
-version = "0.2.0"
-features = [
+block2 = "0.5.1"
+objc2-foundation = { version = "0.2.2", features = [
+    "block2",
    "dispatch",
    "NSArray",
    "NSAttributedString",
    "NSData",
    "NSDictionary",
+    "NSDistributedNotificationCenter",
    "NSEnumerator",
+    "NSKeyValueObserving",
+    "NSNotification",
    "NSObjCRuntime",
-    "NSString",
    "NSPathUtilities",
    "NSProcessInfo",
+    "NSRunLoop",
+    "NSString",
    "NSThread",
    "NSValue",
-]
-
-[target.'cfg(target_os = "macos")'.dependencies.objc2-app-kit]
-version = "0.2.0"
-features = [
+] }
+objc2-app-kit = { version = "0.2.2", features = [
    "NSAppearance",
    "NSApplication",
    "NSBitmapImageRep",
    "NSButton",
+    "NSColor",
    "NSControl",
    "NSCursor",
    "NSDragging",
@@ -158,11 +162,11 @@ features = [
    "NSWindow",
    "NSWindowScripting",
    "NSWindowTabGroup",
-]
+] }

-[target.'cfg(target_os = "ios")'.dependencies.objc2-foundation]
-version = "0.2.0"
-features = [
+# UIKit
+[target.'cfg(all(target_vendor = "apple", not(target_os = "macos")))'.dependencies]
+objc2-foundation = { version = "0.2.2", features = [
    "dispatch",
    "NSArray",
    "NSEnumerator",
@@ -172,14 +176,32 @@ features = [
    "NSProcessInfo",
    "NSThread",
    "NSSet",
-]
+] }
+objc2-ui-kit = { version = "0.2.2", features = [
+    "UIApplication",
+    "UIDevice",
+    "UIEvent",
+    "UIGeometry",
+    "UIGestureRecognizer",
+    "UIOrientation",
+    "UIPanGestureRecognizer",
+    "UIPinchGestureRecognizer",
+    "UIResponder",
+    "UIRotationGestureRecognizer",
+    "UIScreen",
+    "UIScreenMode",
+    "UITapGestureRecognizer",
+    "UITouch",
+    "UITraitCollection",
+    "UIView",
+    "UIViewController",
+    "UIWindow",
+] }

+# Windows
 [target.'cfg(target_os = "windows")'.dependencies]
 unicode-segmentation = "1.7.1"
-
-[target.'cfg(target_os = "windows")'.dependencies.windows-sys]
-version = "0.52.0"
-features = [
+windows-sys = { version = "0.52.0", features = [
    "Win32_Devices_HumanInterfaceDevice",
    "Win32_Foundation",
    "Win32_Globalization",
@@ -204,9 +226,10 @@ features = [
    "Win32_UI_Shell",
    "Win32_UI_TextServices",
    "Win32_UI_WindowsAndMessaging",
-]
+] }

-[target.'cfg(all(unix, not(any(target_os = "redox", target_family = "wasm", target_os = "android", target_os = "ios", target_os = "macos"))))'.dependencies]
+# Linux
+[target.'cfg(all(unix, not(any(target_os = "redox", target_family = "wasm", target_os = "android", target_vendor = "apple"))))'.dependencies]
 ahash = { version = "0.8.7", features = ["no-rng"], optional = true }
 bytemuck = { version = "1.13.1", default-features = false, optional = true }
 calloop = "0.12.3"
@@ -222,8 +245,8 @@ rustix = { version = "0.38.4", default-features = false, features = [
 sctk = { package = "smithay-client-toolkit", version = "0.18.0", default-features = false, features = [
    "calloop",
 ], optional = true }
-sctk-adwaita = { version = "0.9.0", default_features = false, optional = true }
-wayland-backend = { version = "0.3.0", default_features = false, features = [
+sctk-adwaita = { version = "0.9.0", default-features = false, optional = true }
+wayland-backend = { version = "0.3.0", default-features = false, features = [
    "client_system",
 ], optional = true }
 wayland-client = { version = "0.31.1", optional = true }
@@ -244,17 +267,18 @@ x11rb = { version = "0.13.0", default-features = false, features = [
 ], optional = true }
 xkbcommon-dl = "0.4.2"

+# Orbital
 [target.'cfg(target_os = "redox")'.dependencies]
 orbclient = { version = "0.3.47", default-features = false }
 redox_syscall = "0.4.1"

-[target.'cfg(target_family = "wasm")'.dependencies.web_sys]
-package = "web-sys"
-version = "0.3.64"
-features = [
+# Web
+[target.'cfg(target_family = "wasm")'.dependencies]
+web_sys = { package = "web-sys", version = "0.3.64", features = [
    'AbortController',
    'AbortSignal',
    'Blob',
+    'BlobPropertyBag',
    'console',
    'CssStyleDeclaration',
    'Document',
@@ -290,10 +314,9 @@ features = [
    'VisibilityState',
    'Window',
    'WheelEvent',
+    'Worker',
    'Url',
-]
-
-[target.'cfg(target_family = "wasm")'.dependencies]
+] }
 js-sys = "0.3.64"
 pin-project = "1"
 wasm-bindgen = "0.2"
@@ -317,7 +340,7 @@ resolver = "2"
 members = ["dpi"]

 [workspace.package]
-rust-version = "1.70.0"
+rust-version = "1.73"
 repository = "https://github.com/rust-windowing/winit"
 license = "Apache-2.0"
 edition = "2021"
--- a/FEATURES.md
+++ b/FEATURES.md
@@ -154,7 +154,6 @@ If your PR makes notable changes to Winit's features, please update this section
 * Home indicator visibility
 * Status bar visibility and style
 * Deferring system gestures
-* Getting the device idiom
 * Getting the preferred video mode

 ### Web
--- a/README.md
+++ b/README.md
@@ -8,7 +8,7 @@

 ```toml
 [dependencies]
-winit = "0.30.0"
+winit = "0.30.3"
 ```

 ## [Documentation](https://docs.rs/winit)
@@ -35,7 +35,7 @@ another library.

 ## MSRV Policy

-This crate's Minimum Supported Rust Version (MSRV) is **1.70**. Changes to
+This crate's Minimum Supported Rust Version (MSRV) is **1.73**. 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/build.rs
+++ b/build.rs
@@ -1,19 +1,18 @@
 use cfg_aliases::cfg_aliases;

 fn main() {
-    // The script doesn't depend on our code
+    // The script doesn't depend on our code.
    println!("cargo:rerun-if-changed=build.rs");

-    // Setup cfg aliases
+    // Setup cfg aliases.
    cfg_aliases! {
        // Systems.
        android_platform: { target_os = "android" },
        web_platform: { all(target_family = "wasm", target_os = "unknown") },
        macos_platform: { target_os = "macos" },
-        ios_platform: { target_os = "ios" },
+        ios_platform: { all(target_vendor = "apple", not(target_os = "macos")) },
        windows_platform: { target_os = "windows" },
-        apple: { any(target_os = "ios", target_os = "macos") },
-        free_unix: { all(unix, not(apple), not(android_platform), not(target_os = "emscripten")) },
+        free_unix: { all(unix, not(target_vendor = "apple"), not(android_platform), not(target_os = "emscripten")) },
        redox: { target_os = "redox" },

        // Native displays.
@@ -21,4 +20,7 @@ fn main() {
        wayland_platform: { all(feature = "wayland", free_unix, not(redox)) },
        orbital_platform: { redox },
    }
+
+    // Winit defined cfgs.
+    println!("cargo:rustc-check-cfg=cfg(unreleased_changelogs)");
 }
--- a/clippy.toml
+++ b/clippy.toml
@@ -12,4 +12,6 @@ disallowed-methods = [
    { path = "web_sys::Document::fullscreen_element", reason = "Doesn't account for compatibility with Safari" },
    { path = "objc2_app_kit::NSView::visibleRect", reason = "We expose a render target to the user, and visibility is not really relevant to that (and can break if you don't use the rectangle position as well). Use `frame` instead." },
    { path = "objc2_app_kit::NSWindow::setFrameTopLeftPoint", reason = "Not sufficient when working with Winit's coordinate system, use `flip_window_screen_coordinates` instead" },
+    { path = "core_foundation::runloop::kCFRunLoopCommonModes", reason = "Using the common modes includes the modal panel mode, which we usually want to avoid" },
+    { path = "objc2_foundation::NSRunLoopCommonModes", reason = "Using the common modes includes the modal panel mode, which we usually want to avoid" }
 ]
--- a/examples/child_window.rs
+++ b/examples/child_window.rs
@@ -3,50 +3,45 @@
 fn main() -> Result<(), impl std::error::Error> {
    use std::collections::HashMap;

+    use winit::application::ApplicationHandler;
    use winit::dpi::{LogicalPosition, LogicalSize, Position};
-    use winit::event::{ElementState, Event, KeyEvent, WindowEvent};
+    use winit::event::{ElementState, KeyEvent, WindowEvent};
    use winit::event_loop::{ActiveEventLoop, EventLoop};
    use winit::raw_window_handle::HasRawWindowHandle;
-    use winit::window::Window;
+    use winit::window::{Window, WindowId};

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

-    fn spawn_child_window(parent: &Window, event_loop: &ActiveEventLoop) -> Window {
-        let parent = parent.raw_window_handle().unwrap();
-        let mut window_attributes = Window::default_attributes()
-            .with_title("child window")
-            .with_inner_size(LogicalSize::new(200.0f32, 200.0f32))
-            .with_position(Position::Logical(LogicalPosition::new(0.0, 0.0)))
-            .with_visible(true);
-        // `with_parent_window` is unsafe. Parent window must be a valid window.
-        window_attributes = unsafe { window_attributes.with_parent_window(Some(parent)) };
-
-        event_loop.create_window(window_attributes).unwrap()
+    #[derive(Default)]
+    struct Application {
+        parent_window_id: Option<WindowId>,
+        windows: HashMap<WindowId, Window>,
    }

-    let mut windows = HashMap::new();
+    impl ApplicationHandler for Application {
+        fn resumed(&mut self, event_loop: &ActiveEventLoop) {
+            let attributes = Window::default_attributes()
+                .with_title("parent window")
+                .with_position(Position::Logical(LogicalPosition::new(0.0, 0.0)))
+                .with_inner_size(LogicalSize::new(640.0f32, 480.0f32));
+            let window = event_loop.create_window(attributes).unwrap();

-    let event_loop: EventLoop<()> = EventLoop::new().unwrap();
-    let mut parent_window_id = None;
+            println!("Parent window id: {:?})", window.id());
+            self.parent_window_id = Some(window.id());

-    event_loop.run(move |event: Event<()>, event_loop| {
-        match event {
-            Event::Resumed => {
-                let attributes = Window::default_attributes()
-                    .with_title("parent window")
-                    .with_position(Position::Logical(LogicalPosition::new(0.0, 0.0)))
-                    .with_inner_size(LogicalSize::new(640.0f32, 480.0f32));
-                let window = event_loop.create_window(attributes).unwrap();
+            self.windows.insert(window.id(), window);
+        }

-                parent_window_id = Some(window.id());
-
-                println!("Parent window id: {parent_window_id:?})");
-                windows.insert(window.id(), window);
-            },
-            Event::WindowEvent { window_id, event } => match event {
+        fn window_event(
+            &mut self,
+            event_loop: &ActiveEventLoop,
+            window_id: winit::window::WindowId,
+            event: WindowEvent,
+        ) {
+            match event {
                WindowEvent::CloseRequested => {
-                    windows.clear();
+                    self.windows.clear();
                    event_loop.exit();
                },
                WindowEvent::CursorEntered { device_id: _ } => {
@@ -61,22 +56,38 @@ fn main() -> Result<(), impl std::error::Error> {
                    event: KeyEvent { state: ElementState::Pressed, .. },
                    ..
                } => {
-                    let parent_window = windows.get(&parent_window_id.unwrap()).unwrap();
+                    let parent_window = self.windows.get(&self.parent_window_id.unwrap()).unwrap();
                    let child_window = spawn_child_window(parent_window, event_loop);
                    let child_id = child_window.id();
                    println!("Child window created with id: {child_id:?}");
-                    windows.insert(child_id, child_window);
+                    self.windows.insert(child_id, child_window);
                },
                WindowEvent::RedrawRequested => {
-                    if let Some(window) = windows.get(&window_id) {
+                    if let Some(window) = self.windows.get(&window_id) {
                        fill::fill_window(window);
                    }
                },
                _ => (),
-            },
-            _ => (),
+            }
        }
-    })
+    }
+
+    fn spawn_child_window(parent: &Window, event_loop: &ActiveEventLoop) -> Window {
+        let parent = parent.raw_window_handle().unwrap();
+        let mut window_attributes = Window::default_attributes()
+            .with_title("child window")
+            .with_inner_size(LogicalSize::new(200.0f32, 200.0f32))
+            .with_position(Position::Logical(LogicalPosition::new(0.0, 0.0)))
+            .with_visible(true);
+        // `with_parent_window` is unsafe. Parent window must be a valid window.
+        window_attributes = unsafe { window_attributes.with_parent_window(Some(parent)) };
+
+        event_loop.create_window(window_attributes).unwrap()
+    }
+
+    let event_loop = EventLoop::new().unwrap();
+    let mut app = Application::default();
+    event_loop.run_app(&mut app)
 }

 #[cfg(all(feature = "rwh_06", not(any(x11_platform, macos_platform, windows_platform))))]
--- a/examples/window.rs
+++ b/examples/window.rs
@@ -44,7 +44,7 @@ fn main() -> Result<(), Box<dyn Error>> {

    tracing::init();

-    let event_loop = EventLoop::<UserEvent>::with_user_event().build()?;
+    let event_loop = EventLoop::new()?;
    let _event_loop_proxy = event_loop.create_proxy();

    // Wire the user event from another thread.
@@ -54,7 +54,7 @@ fn main() -> Result<(), Box<dyn Error>> {
        // from a different thread.
        info!("Starting to send user event every second");
        loop {
-            let _ = _event_loop_proxy.send_event(UserEvent::WakeUp);
+            _event_loop_proxy.wake_up();
            std::thread::sleep(std::time::Duration::from_secs(1));
        }
    });
@@ -64,12 +64,6 @@ fn main() -> Result<(), Box<dyn Error>> {
    event_loop.run_app(&mut state).map_err(Into::into)
 }

-#[allow(dead_code)]
-#[derive(Debug, Clone, Copy)]
-enum UserEvent {
-    WakeUp,
-}
-
 /// Application state and event handling.
 struct Application {
    /// Custom cursors assets.
@@ -85,7 +79,7 @@ struct Application {
 }

 impl Application {
-    fn new<T>(event_loop: &EventLoop<T>) -> Self {
+    fn new(event_loop: &EventLoop) -> Self {
        // SAFETY: we drop the context right before the event loop is stopped, thus making it safe.
        #[cfg(not(any(android_platform, ios_platform)))]
        let context = Some(
@@ -212,6 +206,12 @@ impl Application {
            Action::PrintHelp => self.print_help(),
            #[cfg(macos_platform)]
            Action::CycleOptionAsAlt => window.cycle_option_as_alt(),
+            Action::SetTheme(theme) => {
+                window.window.set_theme(theme);
+                // Get the resulting current theme to draw with
+                let actual_theme = theme.or_else(|| window.window.theme()).unwrap_or(Theme::Dark);
+                window.set_draw_theme(actual_theme);
+            },
            #[cfg(macos_platform)]
            Action::CreateNewTab => {
                let tab_id = window.window.tabbing_identifier();
@@ -302,9 +302,9 @@ impl Application {
    }
 }

-impl ApplicationHandler<UserEvent> for Application {
-    fn user_event(&mut self, _event_loop: &ActiveEventLoop, event: UserEvent) {
-        info!("User event: {event:?}");
+impl ApplicationHandler for Application {
+    fn proxy_wake_up(&mut self, _event_loop: &ActiveEventLoop) {
+        info!("User wake up");
    }

    fn window_event(
@@ -334,7 +334,7 @@ impl ApplicationHandler<UserEvent> for Application {
            },
            WindowEvent::ThemeChanged(theme) => {
                info!("Theme changed to {theme:?}");
-                window.set_theme(theme);
+                window.set_draw_theme(theme);
            },
            WindowEvent::RedrawRequested => {
                if let Err(err) = window.draw() {
@@ -733,8 +733,8 @@ impl WindowState {
        self.window.request_redraw();
    }

-    /// Change the theme.
-    fn set_theme(&mut self, theme: Theme) {
+    /// Change the theme that things are drawn in.
+    fn set_draw_theme(&mut self, theme: Theme) {
        self.theme = theme;
        self.window.request_redraw();
    }
@@ -884,6 +884,7 @@ enum Action {
    ShowWindowMenu,
    #[cfg(macos_platform)]
    CycleOptionAsAlt,
+    SetTheme(Option<Theme>),
    #[cfg(macos_platform)]
    CreateNewTab,
    RequestResize,
@@ -915,6 +916,9 @@ impl Action {
            Action::ShowWindowMenu => "Show window menu",
            #[cfg(macos_platform)]
            Action::CycleOptionAsAlt => "Cycle option as alt mode",
+            Action::SetTheme(None) => "Change to the system theme",
+            Action::SetTheme(Some(Theme::Light)) => "Change to a light theme",
+            Action::SetTheme(Some(Theme::Dark)) => "Change to a dark theme",
            #[cfg(macos_platform)]
            Action::CreateNewTab => "Create new tab",
            Action::RequestResize => "Request a resize",
@@ -1059,6 +1063,10 @@ const KEY_BINDINGS: &[Binding<&'static str>] = &[
        Action::AnimationCustomCursor,
    ),
    Binding::new("Z", ModifiersState::CONTROL, Action::ToggleCursorVisibility),
+    // K.
+    Binding::new("K", ModifiersState::empty(), Action::SetTheme(None)),
+    Binding::new("K", ModifiersState::SUPER, Action::SetTheme(Some(Theme::Light))),
+    Binding::new("K", ModifiersState::CONTROL, Action::SetTheme(Some(Theme::Dark))),
    #[cfg(macos_platform)]
    Binding::new("T", ModifiersState::SUPER, Action::CreateNewTab),
    #[cfg(macos_platform)]
--- a/src/application.rs
+++ b/src/application.rs
@@ -5,7 +5,7 @@ use crate::event_loop::ActiveEventLoop;
 use crate::window::WindowId;

 /// The handler of the application events.
-pub trait ApplicationHandler<T: 'static = ()> {
+pub trait ApplicationHandler {
    /// Emitted when new events arrive from the OS to be processed.
    ///
    /// This is a useful place to put code that should be done before you start processing
@@ -82,11 +82,95 @@ pub trait ApplicationHandler<T: 'static = ()> {
    /// [`Suspended`]: Self::suspended
    fn resumed(&mut self, event_loop: &ActiveEventLoop);

-    /// Emitted when an event is sent from [`EventLoopProxy::send_event`].
+    /// Called after a wake up is requested using [`EventLoopProxy::wake_up()`].
    ///
-    /// [`EventLoopProxy::send_event`]: crate::event_loop::EventLoopProxy::send_event
-    fn user_event(&mut self, event_loop: &ActiveEventLoop, event: T) {
-        let _ = (event_loop, event);
+    /// Multiple calls to the aforementioned method will be merged, and will only wake the event
+    /// loop once; however, due to the nature of multi-threading some wake ups may appear
+    /// spuriously. For these reasons, you should not rely on the number of times that this was
+    /// called.
+    ///
+    /// The order in which this is emitted in relation to other events is not guaranteed. The time
+    /// at which this will be emitted is not guaranteed, only that it will happen "soon". That is,
+    /// there may be several executions of the event loop, including multiple redraws to windows,
+    /// between [`EventLoopProxy::wake_up()`] being called and the event being delivered.
+    ///
+    /// [`EventLoopProxy::wake_up()`]: crate::event_loop::EventLoopProxy::wake_up
+    ///
+    /// # Example
+    ///
+    /// Use a [`std::sync::mpsc`] channel to handle events from a different thread.
+    ///
+    /// ```no_run
+    /// use std::sync::mpsc;
+    /// use std::thread;
+    /// use std::time::Duration;
+    ///
+    /// use winit::application::ApplicationHandler;
+    /// use winit::event_loop::{ActiveEventLoop, EventLoop};
+    ///
+    /// struct MyApp {
+    ///     receiver: mpsc::Receiver<u64>,
+    /// }
+    ///
+    /// impl ApplicationHandler for MyApp {
+    ///     # fn window_event(
+    ///     #     &mut self,
+    ///     #     _event_loop: &ActiveEventLoop,
+    ///     #     _window_id: winit::window::WindowId,
+    ///     #     _event: winit::event::WindowEvent,
+    ///     # ) {
+    ///     # }
+    ///     #
+    ///     # fn resumed(&mut self, _event_loop: &ActiveEventLoop) {}
+    ///     #
+    ///     fn proxy_wake_up(&mut self, _event_loop: &ActiveEventLoop) {
+    ///         // Iterate current events, since wake-ups may have been merged.
+    ///         //
+    ///         // Note: We take care not to use `recv` or `iter` here, as those are blocking,
+    ///         // and that would be bad for performance and might lead to a deadlock.
+    ///         for i in self.receiver.try_iter() {
+    ///             println!("received: {i}");
+    ///         }
+    ///     }
+    ///
+    ///     // Rest of `ApplicationHandler`
+    /// }
+    ///
+    /// fn main() -> Result<(), Box<dyn std::error::Error>> {
+    ///     let event_loop = EventLoop::new()?;
+    ///
+    ///     let (sender, receiver) = mpsc::channel();
+    ///
+    ///     let mut app = MyApp { receiver };
+    ///
+    ///     // Send an event in a loop
+    ///     let proxy = event_loop.create_proxy();
+    ///     let background_thread = thread::spawn(move || {
+    ///         let mut i = 0;
+    ///         loop {
+    ///             println!("sending: {i}");
+    ///             if sender.send(i).is_err() {
+    ///                 // Stop sending once `MyApp` is dropped
+    ///                 break;
+    ///             }
+    ///             // Trigger the wake-up _after_ we placed the event in the channel.
+    ///             // Otherwise, `proxy_wake_up` might be triggered prematurely.
+    ///             proxy.wake_up();
+    ///             i += 1;
+    ///             thread::sleep(Duration::from_secs(1));
+    ///         }
+    ///     });
+    ///
+    ///     event_loop.run_app(&mut app)?;
+    ///
+    ///     drop(app);
+    ///     background_thread.join().unwrap();
+    ///
+    ///     Ok(())
+    /// }
+    /// ```
+    fn proxy_wake_up(&mut self, event_loop: &ActiveEventLoop) {
+        let _ = event_loop;
    }

    /// Emitted when the OS sends an event to a winit window.
@@ -190,7 +274,7 @@ pub trait ApplicationHandler<T: 'static = ()> {
    /// Emitted when the event loop is being shut down.
    ///
    /// This is irreversible - if this method is called, it is guaranteed that the event loop
-    /// will exist right after.
+    /// will exit right after.
    fn exiting(&mut self, event_loop: &ActiveEventLoop) {
        let _ = event_loop;
    }
@@ -223,3 +307,117 @@ pub trait ApplicationHandler<T: 'static = ()> {
        let _ = event_loop;
    }
 }
+
+impl<A: ?Sized + ApplicationHandler> ApplicationHandler for &mut A {
+    #[inline]
+    fn new_events(&mut self, event_loop: &ActiveEventLoop, cause: StartCause) {
+        (**self).new_events(event_loop, cause);
+    }
+
+    #[inline]
+    fn resumed(&mut self, event_loop: &ActiveEventLoop) {
+        (**self).resumed(event_loop);
+    }
+
+    #[inline]
+    fn proxy_wake_up(&mut self, event_loop: &ActiveEventLoop) {
+        (**self).proxy_wake_up(event_loop);
+    }
+
+    #[inline]
+    fn window_event(
+        &mut self,
+        event_loop: &ActiveEventLoop,
+        window_id: WindowId,
+        event: WindowEvent,
+    ) {
+        (**self).window_event(event_loop, window_id, event);
+    }
+
+    #[inline]
+    fn device_event(
+        &mut self,
+        event_loop: &ActiveEventLoop,
+        device_id: DeviceId,
+        event: DeviceEvent,
+    ) {
+        (**self).device_event(event_loop, device_id, event);
+    }
+
+    #[inline]
+    fn about_to_wait(&mut self, event_loop: &ActiveEventLoop) {
+        (**self).about_to_wait(event_loop);
+    }
+
+    #[inline]
+    fn suspended(&mut self, event_loop: &ActiveEventLoop) {
+        (**self).suspended(event_loop);
+    }
+
+    #[inline]
+    fn exiting(&mut self, event_loop: &ActiveEventLoop) {
+        (**self).exiting(event_loop);
+    }
+
+    #[inline]
+    fn memory_warning(&mut self, event_loop: &ActiveEventLoop) {
+        (**self).memory_warning(event_loop);
+    }
+}
+
+impl<A: ?Sized + ApplicationHandler> ApplicationHandler for Box<A> {
+    #[inline]
+    fn new_events(&mut self, event_loop: &ActiveEventLoop, cause: StartCause) {
+        (**self).new_events(event_loop, cause);
+    }
+
+    #[inline]
+    fn resumed(&mut self, event_loop: &ActiveEventLoop) {
+        (**self).resumed(event_loop);
+    }
+
+    #[inline]
+    fn proxy_wake_up(&mut self, event_loop: &ActiveEventLoop) {
+        (**self).proxy_wake_up(event_loop);
+    }
+
+    #[inline]
+    fn window_event(
+        &mut self,
+        event_loop: &ActiveEventLoop,
+        window_id: WindowId,
+        event: WindowEvent,
+    ) {
+        (**self).window_event(event_loop, window_id, event);
+    }
+
+    #[inline]
+    fn device_event(
+        &mut self,
+        event_loop: &ActiveEventLoop,
+        device_id: DeviceId,
+        event: DeviceEvent,
+    ) {
+        (**self).device_event(event_loop, device_id, event);
+    }
+
+    #[inline]
+    fn about_to_wait(&mut self, event_loop: &ActiveEventLoop) {
+        (**self).about_to_wait(event_loop);
+    }
+
+    #[inline]
+    fn suspended(&mut self, event_loop: &ActiveEventLoop) {
+        (**self).suspended(event_loop);
+    }
+
+    #[inline]
+    fn exiting(&mut self, event_loop: &ActiveEventLoop) {
+        (**self).exiting(event_loop);
+    }
+
+    #[inline]
+    fn memory_warning(&mut self, event_loop: &ActiveEventLoop) {
+        (**self).memory_warning(event_loop);
+    }
+}
--- a/src/changelog/unreleased.md
+++ b/src/changelog/unreleased.md
@@ -39,3 +39,27 @@ The migration guide could reference other migration examples in the current
 changelog entry.

 ## Unreleased
+
+### Changed
+
+- On Web, let events wake up event loop immediately when using `ControlFlow::Poll`.
+- Bump MSRV from `1.70` to `1.73`.
+- Changed `ApplicationHandler::user_event` to `user_wake_up`, removing the
+  generic user event.
+
+  Winit will now only indicate that wake up happened, you will have to pair
+  this with an external mechanism like `std::sync::mpsc::channel` if you want
+  to send specific data to be processed on the main thread.
+- Changed `EventLoopProxy::send_event` to `EventLoopProxy::wake_up`, it now
+  only wakes up the loop.
+
+### Removed
+
+- Remove `EventLoop::run`.
+- Remove `EventLoopExtRunOnDemand::run_on_demand`.
+- Remove `EventLoopExtPumpEvents::pump_events`.
+- Remove `Event`.
+- On iOS, remove `platform::ios::EventLoopExtIOS` and related `platform::ios::Idiom` type.
+
+  This feature was incomplete, and the equivalent functionality can be trivially achieved outside
+  of `winit` using `objc2-ui-kit` and calling `UIDevice::currentDevice().userInterfaceIdiom()`.
--- a/src/changelog/v0.30.md
+++ b/src/changelog/v0.30.md
@@ -1,3 +1,50 @@
+## 0.30.3
+
+### Added
+
+- On Web, add `EventLoopExtWebSys::(set_)poll_strategy()` to allow setting
+  control flow strategies before starting the event loop.
+- On Web, add `WaitUntilStrategy`, which allows to set different strategies for
+  `ControlFlow::WaitUntil`. By default the Prioritized Task Scheduling API is
+  used, with a fallback to `setTimeout()` with a trick to circumvent throttling
+  to 4ms. But an option to use a Web worker to schedule the timer is available
+  as well, which commonly prevents any throttling when the window is not focused.
+
+### Changed
+
+- On macOS, set the window theme on the `NSWindow` instead of application-wide.
+
+### Fixed
+
+- On X11, build on arm platforms.
+- On macOS, fixed `WindowBuilder::with_theme` not having any effect on the window.
+
+## 0.30.2
+
+### Fixed
+
+- On Web, fix `EventLoopProxy::send_event()` triggering event loop immediately
+  when not called from inside the event loop. Now queues a microtask instead.
+- On Web, stop overwriting default cursor with `CursorIcon::Default`.
+- On Web, prevent crash when using `InnerSizeWriter::request_inner_size()`.
+- On macOS, fix not working opacity for entire window.
+
+## 0.30.1
+
+### Added
+
+- Reexport `raw-window-handle` versions 0.4 and 0.5 as `raw_window_handle_04` and `raw_window_handle_05`.
+- Implement `ApplicationHandler` for `&mut` references and heap allocations to something that implements `ApplicationHandler`.
+- Add traits `EventLoopExtWayland` and `EventLoopExtX11`, providing methods `is_wayland` and `is_x11` on `EventLoop`.
+
+### Fixed
+
+- On macOS, fix panic on exit when dropping windows outside the event loop.
+- On macOS, fix window dragging glitches when dragging across a monitor boundary with different scale factor.
+- On macOS, fix the range in `Ime::Preedit`.
+- On macOS, use the system's internal mechanisms for queuing events.
+- On macOS, handle events directly instead of queuing when possible.
+
 ## 0.30.0

 ### Added
@@ -65,7 +112,7 @@
  `Fn`. The semantics are mostly the same, given that the capture list of the
  closure is your new `State`. Consider the following code:

-  ```rust,no_run
+  ```rust,no_run,ignore
  use winit::event::Event;
  use winit::event_loop::EventLoop;
  use winit::window::Window;
@@ -101,7 +148,7 @@
  we move particular `match event` arms into methods on `ApplicationHandler`,
  for example:

-  ```rust,no_run
+  ```rust,no_run,ignore
  use winit::application::ApplicationHandler;
  use winit::event::{Event, WindowEvent, DeviceEvent, DeviceId};
  use winit::event_loop::{EventLoop, ActiveEventLoop};
@@ -164,7 +211,7 @@

  Using the migration example from above, you can change your code as follows:

-  ```rust,no_run
+  ```rust,no_run,ignore
  use winit::application::ApplicationHandler;
  use winit::event::{Event, WindowEvent, DeviceEvent, DeviceId};
  use winit::event_loop::{EventLoop, ActiveEventLoop};
--- a/src/event.rs
+++ b/src/event.rs
@@ -1,4 +1,4 @@
-//! The [`Event`] enum and assorted supporting types.
+//! The event enums and assorted supporting types.
 //!
 //! These are sent to the closure given to [`EventLoop::run_app(...)`], where they get
 //! processed and used to modify the program state. For more details, see the root-level
@@ -54,11 +54,15 @@ use crate::platform_impl;
 use crate::window::Window;
 use crate::window::{ActivationToken, Theme, WindowId};

+// TODO: Remove once the backends can call `ApplicationHandler` methods directly. For now backends
+// like Windows and Web require `Event` to wire user events, otherwise each backend will have to
+// wrap `Event` in some other structure.
 /// Describes a generic event.
 ///
 /// See the module-level docs for more information on the event loop manages each event.
+#[allow(dead_code)]
 #[derive(Debug, Clone, PartialEq)]
-pub enum Event<T: 'static> {
+pub(crate) enum Event {
    /// See [`ApplicationHandler::new_events`] for details.
    ///
    /// [`ApplicationHandler::new_events`]: crate::application::ApplicationHandler::new_events
@@ -67,18 +71,15 @@ pub enum Event<T: 'static> {
    /// See [`ApplicationHandler::window_event`] for details.
    ///
    /// [`ApplicationHandler::window_event`]: crate::application::ApplicationHandler::window_event
+    #[allow(clippy::enum_variant_names)]
    WindowEvent { window_id: WindowId, event: WindowEvent },

    /// See [`ApplicationHandler::device_event`] for details.
    ///
    /// [`ApplicationHandler::device_event`]: crate::application::ApplicationHandler::device_event
+    #[allow(clippy::enum_variant_names)]
    DeviceEvent { device_id: DeviceId, event: DeviceEvent },

-    /// See [`ApplicationHandler::user_event`] for details.
-    ///
-    /// [`ApplicationHandler::user_event`]: crate::application::ApplicationHandler::user_event
-    UserEvent(T),
-
    /// See [`ApplicationHandler::suspended`] for details.
    ///
    /// [`ApplicationHandler::suspended`]: crate::application::ApplicationHandler::suspended
@@ -103,24 +104,9 @@ pub enum Event<T: 'static> {
    ///
    /// [`ApplicationHandler::memory_warning`]: crate::application::ApplicationHandler::memory_warning
    MemoryWarning,
-}

-impl<T> Event<T> {
-    #[allow(clippy::result_large_err)]
-    pub fn map_nonuser_event<U>(self) -> Result<Event<U>, Event<T>> {
-        use self::Event::*;
-        match self {
-            UserEvent(_) => Err(self),
-            WindowEvent { window_id, event } => Ok(WindowEvent { window_id, event }),
-            DeviceEvent { device_id, event } => Ok(DeviceEvent { device_id, event }),
-            NewEvents(cause) => Ok(NewEvents(cause)),
-            AboutToWait => Ok(AboutToWait),
-            LoopExiting => Ok(LoopExiting),
-            Suspended => Ok(Suspended),
-            Resumed => Ok(Resumed),
-            MemoryWarning => Ok(MemoryWarning),
-        }
-    }
+    /// User requested a wake up.
+    UserWakeUp,
 }

 /// Describes the reason the event loop is resuming.
@@ -389,6 +375,8 @@ pub enum WindowEvent {
    /// Applications might wish to react to this to change the theme of the content of the window
    /// when the system changes the window theme.
    ///
+    /// This only reports a change if the window theme was not overridden by [`Window::set_theme`].
+    ///
    /// ## Platform-specific
    ///
    /// - **iOS / Android / X11 / Wayland / Orbital:** Unsupported.
@@ -1030,7 +1018,6 @@ mod tests {

                // Mainline events.
                let wid = unsafe { WindowId::dummy() };
-                x(UserEvent(()));
                x(NewEvents(event::StartCause::Init));
                x(AboutToWait);
                x(LoopExiting);
@@ -1114,25 +1101,12 @@ mod tests {
    #[allow(clippy::redundant_clone)]
    #[test]
    fn test_event_clone() {
-        foreach_event!(|event: event::Event<()>| {
+        foreach_event!(|event: event::Event| {
            let event2 = event.clone();
            assert_eq!(event, event2);
        })
    }

-    #[test]
-    fn test_map_nonuser_event() {
-        foreach_event!(|event: event::Event<()>| {
-            let is_user = matches!(event, event::Event::UserEvent(()));
-            let event2 = event.map_nonuser_event::<()>();
-            if is_user {
-                assert_eq!(event2, Err(event::Event::UserEvent(())));
-            } else {
-                assert!(event2.is_ok());
-            }
-        })
-    }
-
    #[test]
    fn test_force_normalize() {
        let force = event::Force::Normalized(0.0);
@@ -1153,7 +1127,7 @@ mod tests {
    #[allow(clippy::clone_on_copy)]
    #[test]
    fn ensure_attrs_do_not_panic() {
-        foreach_event!(|event: event::Event<()>| {
+        foreach_event!(|event: event::Event| {
            let _ = format!("{:?}", event);
        });
        let _ = event::StartCause::Init.clone();
--- a/src/event_loop.rs
+++ b/src/event_loop.rs
@@ -3,15 +3,16 @@
 //!
 //! If you want to send custom events to the event loop, use
 //! [`EventLoop::create_proxy`] to acquire an [`EventLoopProxy`] and call its
-//! [`send_event`][EventLoopProxy::send_event] method.
+//! [`wake_up`][EventLoopProxy::wake_up] method. Then during handling the wake up
+//! you can poll your event sources.
 //!
 //! See the root-level documentation for information on how to create and use an event loop to
 //! handle events.
+use std::fmt;
 use std::marker::PhantomData;
 #[cfg(any(x11_platform, wayland_platform))]
 use std::os::unix::io::{AsFd, AsRawFd, BorrowedFd, RawFd};
 use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
-use std::{error, fmt};

 #[cfg(not(web_platform))]
 use std::time::{Duration, Instant};
@@ -20,7 +21,6 @@ use web_time::{Duration, Instant};

 use crate::application::ApplicationHandler;
 use crate::error::{EventLoopError, OsError};
-use crate::event::Event;
 use crate::monitor::MonitorHandle;
 use crate::platform_impl;
 use crate::window::{CustomCursor, CustomCursorSource, Window, WindowAttributes};
@@ -40,8 +40,8 @@ use crate::window::{CustomCursor, CustomCursorSource, Window, WindowAttributes};
 /// [`EventLoopProxy`] allows you to wake up an `EventLoop` from another thread.
 ///
 /// [`Window`]: crate::window::Window
-pub struct EventLoop<T: 'static> {
-    pub(crate) event_loop: platform_impl::EventLoop<T>,
+pub struct EventLoop {
+    pub(crate) event_loop: platform_impl::EventLoop,
    pub(crate) _marker: PhantomData<*mut ()>, // Not Send nor Sync
 }

@@ -59,16 +59,15 @@ pub struct ActiveEventLoop {
 /// This is used to make specifying options that affect the whole application
 /// easier. But note that constructing multiple event loops is not supported.
 ///
-/// This can be created using [`EventLoop::new`] or [`EventLoop::with_user_event`].
+/// This can be created using [`EventLoop::builder`].
 #[derive(Default)]
-pub struct EventLoopBuilder<T: 'static> {
+pub struct EventLoopBuilder {
    pub(crate) platform_specific: platform_impl::PlatformSpecificEventLoopAttributes,
-    _p: PhantomData<T>,
 }

 static EVENT_LOOP_CREATED: AtomicBool = AtomicBool::new(false);

-impl EventLoopBuilder<()> {
+impl EventLoopBuilder {
    /// Start building a new event loop.
    #[inline]
    #[deprecated = "use `EventLoop::builder` instead"]
@@ -77,7 +76,7 @@ impl EventLoopBuilder<()> {
    }
 }

-impl<T> EventLoopBuilder<T> {
+impl EventLoopBuilder {
    /// Builds a new event loop.
    ///
    /// ***For cross-platform compatibility, the [`EventLoop`] must be created on the main thread,
@@ -103,13 +102,16 @@ impl<T> EventLoopBuilder<T> {
    ///
    /// [`platform`]: crate::platform
    #[cfg_attr(
-        android,
+        android_platform,
        doc = "[`.with_android_app(app)`]: \
               crate::platform::android::EventLoopBuilderExtAndroid::with_android_app"
    )]
-    #[cfg_attr(not(android), doc = "[`.with_android_app(app)`]: #only-available-on-android")]
+    #[cfg_attr(
+        not(android_platform),
+        doc = "[`.with_android_app(app)`]: #only-available-on-android"
+    )]
    #[inline]
-    pub fn build(&mut self) -> Result<EventLoop<T>, EventLoopError> {
+    pub fn build(&mut self) -> Result<EventLoop, EventLoopError> {
        let _span = tracing::debug_span!("winit::EventLoopBuilder::build").entered();

        if EVENT_LOOP_CREATED.swap(true, Ordering::Relaxed) {
@@ -130,7 +132,7 @@ impl<T> EventLoopBuilder<T> {
    }
 }

-impl<T> fmt::Debug for EventLoop<T> {
+impl fmt::Debug for EventLoop {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.pad("EventLoop { .. }")
    }
@@ -144,11 +146,12 @@ impl fmt::Debug for ActiveEventLoop {

 /// Set through [`ActiveEventLoop::set_control_flow()`].
 ///
-/// Indicates the desired behavior of the event loop after [`Event::AboutToWait`] is emitted.
+/// Indicates the desired behavior of the event loop after [`about_to_wait`] is called.
 ///
 /// Defaults to [`Wait`].
 ///
 /// [`Wait`]: Self::Wait
+/// [`about_to_wait`]: crate::application::ApplicationHandler::about_to_wait
 #[derive(Copy, Clone, Debug, Default, PartialEq, Eq)]
 pub enum ControlFlow {
    /// When the current loop iteration finishes, immediately begin a new iteration regardless of
@@ -186,12 +189,12 @@ impl ControlFlow {
    }
 }

-impl EventLoop<()> {
+impl EventLoop {
    /// Create the event loop.
    ///
    /// This is an alias of `EventLoop::builder().build()`.
    #[inline]
-    pub fn new() -> Result<EventLoop<()>, EventLoopError> {
+    pub fn new() -> Result<EventLoop, EventLoopError> {
        Self::builder().build()
    }

@@ -201,33 +204,12 @@ impl EventLoop<()> {
    ///
    /// To get the actual event loop, call [`build`][EventLoopBuilder::build] on that.
    #[inline]
-    pub fn builder() -> EventLoopBuilder<()> {
-        Self::with_user_event()
+    pub fn builder() -> EventLoopBuilder {
+        EventLoopBuilder { platform_specific: Default::default() }
    }
 }

-impl<T> EventLoop<T> {
-    /// Start building a new event loop, with the given type as the user event
-    /// type.
-    pub fn with_user_event() -> EventLoopBuilder<T> {
-        EventLoopBuilder { platform_specific: Default::default(), _p: PhantomData }
-    }
-
-    /// See [`run_app`].
-    ///
-    /// [`run_app`]: Self::run_app
-    #[inline]
-    #[deprecated = "use `EventLoop::run_app` instead"]
-    #[cfg(not(all(web_platform, target_feature = "exception-handling")))]
-    pub fn run<F>(self, event_handler: F) -> Result<(), EventLoopError>
-    where
-        F: FnMut(Event<T>, &ActiveEventLoop),
-    {
-        let _span = tracing::debug_span!("winit::EventLoop::run").entered();
-
-        self.event_loop.run(event_handler)
-    }
-
+impl EventLoop {
    /// Run the application with the event loop on the calling thread.
    ///
    /// See the [`set_control_flow()`] docs on how to change the event loop's behavior.
@@ -258,13 +240,13 @@ impl<T> EventLoop<T> {
    /// [^1]: `EventLoopExtWebSys::spawn_app()` is only available on Web.
    #[inline]
    #[cfg(not(all(web_platform, target_feature = "exception-handling")))]
-    pub fn run_app<A: ApplicationHandler<T>>(self, app: &mut A) -> Result<(), EventLoopError> {
-        self.event_loop.run(|event, event_loop| dispatch_event_for_app(app, event_loop, event))
+    pub fn run_app<A: ApplicationHandler>(self, app: &mut A) -> Result<(), EventLoopError> {
+        self.event_loop.run_app(app)
    }

    /// Creates an [`EventLoopProxy`] that can be used to dispatch user events
    /// to the main event loop, possibly from another thread.
-    pub fn create_proxy(&self) -> EventLoopProxy<T> {
+    pub fn create_proxy(&self) -> EventLoopProxy {
        EventLoopProxy { event_loop_proxy: self.event_loop.create_proxy() }
    }

@@ -320,14 +302,14 @@ impl<T> EventLoop<T> {
 }

 #[cfg(feature = "rwh_06")]
-impl<T> rwh_06::HasDisplayHandle for EventLoop<T> {
+impl rwh_06::HasDisplayHandle for EventLoop {
    fn display_handle(&self) -> Result<rwh_06::DisplayHandle<'_>, rwh_06::HandleError> {
        rwh_06::HasDisplayHandle::display_handle(self.event_loop.window_target())
    }
 }

 #[cfg(feature = "rwh_05")]
-unsafe impl<T> rwh_05::HasRawDisplayHandle for EventLoop<T> {
+unsafe impl rwh_05::HasRawDisplayHandle for EventLoop {
    /// Returns a [`rwh_05::RawDisplayHandle`] for the event loop.
    fn raw_display_handle(&self) -> rwh_05::RawDisplayHandle {
        rwh_05::HasRawDisplayHandle::raw_display_handle(self.event_loop.window_target())
@@ -335,7 +317,7 @@ unsafe impl<T> rwh_05::HasRawDisplayHandle for EventLoop<T> {
 }

 #[cfg(any(x11_platform, wayland_platform))]
-impl<T> AsFd for EventLoop<T> {
+impl AsFd for EventLoop {
    /// Get the underlying [EventLoop]'s `fd` which you can register
    /// into other event loop, like [`calloop`] or [`mio`]. When doing so, the
    /// loop must be polled with the [`pump_app_events`] API.
@@ -349,7 +331,7 @@ impl<T> AsFd for EventLoop<T> {
 }

 #[cfg(any(x11_platform, wayland_platform))]
-impl<T> AsRawFd for EventLoop<T> {
+impl AsRawFd for EventLoop {
    /// Get the underlying [EventLoop]'s raw `fd` which you can register
    /// into other event loop, like [`calloop`] or [`mio`]. When doing so, the
    /// loop must be polled with the [`pump_app_events`] API.
@@ -446,7 +428,7 @@ impl ActiveEventLoop {

    /// This exits the event loop.
    ///
-    /// See [`LoopExiting`][Event::LoopExiting].
+    /// See [`exiting`][crate::application::ApplicationHandler::exiting].
    pub fn exit(&self) {
        let _span = tracing::debug_span!("winit::ActiveEventLoop::exit",).entered();

@@ -531,53 +513,39 @@ unsafe impl rwh_05::HasRawDisplayHandle for OwnedDisplayHandle {
    }
 }

-/// Used to send custom events to [`EventLoop`].
-pub struct EventLoopProxy<T: 'static> {
-    event_loop_proxy: platform_impl::EventLoopProxy<T>,
+/// Control the [`EventLoop`], possibly from a different thread, without referencing it directly.
+#[derive(Clone)]
+pub struct EventLoopProxy {
+    event_loop_proxy: platform_impl::EventLoopProxy,
 }

-impl<T: 'static> Clone for EventLoopProxy<T> {
-    fn clone(&self) -> Self {
-        Self { event_loop_proxy: self.event_loop_proxy.clone() }
+impl EventLoopProxy {
+    /// Wake up the [`EventLoop`], resulting in [`ApplicationHandler::proxy_wake_up()`] being
+    /// called.
+    ///
+    /// Calls to this method are coalesced into a single call to [`proxy_wake_up`], see the
+    /// documentation on that for details.
+    ///
+    /// If the event loop is no longer running, this is a no-op.
+    ///
+    /// [`proxy_wake_up`]: ApplicationHandler::proxy_wake_up
+    ///
+    /// # Platform-specific
+    ///
+    /// - **Windows**: The wake-up may be ignored under high contention, see [#3687].
+    ///
+    /// [#3687]: https://github.com/rust-windowing/winit/pull/3687
+    pub fn wake_up(&self) {
+        self.event_loop_proxy.wake_up();
    }
 }

-impl<T: 'static> EventLoopProxy<T> {
-    /// Send an event to the [`EventLoop`] from which this proxy was created. This emits a
-    /// `UserEvent(event)` event in the event loop, where `event` is the value passed to this
-    /// function.
-    ///
-    /// Returns an `Err` if the associated [`EventLoop`] no longer exists.
-    ///
-    /// [`UserEvent(event)`]: Event::UserEvent
-    pub fn send_event(&self, event: T) -> Result<(), EventLoopClosed<T>> {
-        let _span = tracing::debug_span!("winit::EventLoopProxy::send_event",).entered();
-
-        self.event_loop_proxy.send_event(event)
-    }
-}
-
-impl<T: 'static> fmt::Debug for EventLoopProxy<T> {
+impl fmt::Debug for EventLoopProxy {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.pad("EventLoopProxy { .. }")
    }
 }

-/// The error that is returned when an [`EventLoopProxy`] attempts to wake up an [`EventLoop`] that
-/// no longer exists.
-///
-/// Contains the original event given to [`EventLoopProxy::send_event`].
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
-pub struct EventLoopClosed<T>(pub T);
-
-impl<T> fmt::Display for EventLoopClosed<T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str("Tried to wake up a closed `EventLoop`")
-    }
-}
-
-impl<T: fmt::Debug> error::Error for EventLoopClosed<T> {}
-
 /// Control when device events are captured.
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Default)]
 pub enum DeviceEvents {
@@ -615,23 +583,3 @@ impl AsyncRequestSerial {
        Self { serial }
    }
 }
-
-/// Shim for various run APIs.
-#[inline(always)]
-pub(crate) fn dispatch_event_for_app<T: 'static, A: ApplicationHandler<T>>(
-    app: &mut A,
-    event_loop: &ActiveEventLoop,
-    event: Event<T>,
-) {
-    match event {
-        Event::NewEvents(cause) => app.new_events(event_loop, cause),
-        Event::WindowEvent { window_id, event } => app.window_event(event_loop, window_id, event),
-        Event::DeviceEvent { device_id, event } => app.device_event(event_loop, device_id, event),
-        Event::UserEvent(event) => app.user_event(event_loop, event),
-        Event::Suspended => app.suspended(event_loop),
-        Event::Resumed => app.resumed(event_loop),
-        Event::AboutToWait => app.about_to_wait(event_loop),
-        Event::LoopExiting => app.exiting(event_loop),
-        Event::MemoryWarning => app.memory_warning(event_loop),
-    }
-}
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -19,12 +19,11 @@
 //! window or a key getting pressed while the window is focused. Devices can generate
 //! [`DeviceEvent`]s, which contain unfiltered event data that isn't specific to a certain window.
 //! Some user activity, like mouse movement, can generate both a [`WindowEvent`] *and* a
-//! [`DeviceEvent`]. You can also create and handle your own custom [`Event::UserEvent`]s, if
-//! desired.
+//! [`DeviceEvent`].
 //!
 //! You can retrieve events by calling [`EventLoop::run_app()`]. This function will
 //! dispatch events for every [`Window`] that was created with that particular [`EventLoop`], and
-//! will run until [`exit()`] is used, at which point [`Event::LoopExiting`].
+//! will run until [`exit()`] is used, at which point [`exiting()`] is called.
 //!
 //! Winit no longer uses a `EventLoop::poll_events() -> impl Iterator<Event>`-based event loop
 //! model, since that can't be implemented properly on some platforms (e.g web, iOS) and works
@@ -163,7 +162,7 @@
 //! [`WindowEvent`]: event::WindowEvent
 //! [`DeviceEvent`]: event::DeviceEvent
 //! [`Event::UserEvent`]: event::Event::UserEvent
-//! [`Event::LoopExiting`]: event::Event::LoopExiting
+//! [`exiting()`]: crate::application::ApplicationHandler::exiting
 //! [`raw_window_handle`]: ./window/struct.Window.html#method.raw_window_handle
 //! [`raw_display_handle`]: ./window/struct.Window.html#method.raw_display_handle
 //! [^1]: `EventLoopExtPumpEvents::pump_app_events()` is only available on Windows, macOS, Android, X11 and Wayland.
@@ -178,6 +177,10 @@
 #![cfg_attr(docsrs, feature(doc_auto_cfg, doc_cfg_hide), doc(cfg_hide(doc, docsrs)))]
 #![allow(clippy::missing_safety_doc)]

+#[cfg(feature = "rwh_04")]
+pub use rwh_04 as raw_window_handle_04;
+#[cfg(feature = "rwh_05")]
+pub use rwh_05 as raw_window_handle_05;
 #[cfg(feature = "rwh_06")]
 pub use rwh_06 as raw_window_handle;

--- a/src/platform/android.rs
+++ b/src/platform/android.rs
@@ -62,7 +62,7 @@
 //! 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.30.0",
+//! 2. Enable the `"android-native-activity"` feature for Winit: `winit = { version = "0.30.3",
 //!    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
@@ -78,7 +78,7 @@ use self::activity::{AndroidApp, ConfigurationRef, Rect};
 /// Additional methods on [`EventLoop`] that are specific to Android.
 pub trait EventLoopExtAndroid {}

-impl<T> EventLoopExtAndroid for EventLoop<T> {}
+impl EventLoopExtAndroid for EventLoop {}

 /// Additional methods on [`ActiveEventLoop`] that are specific to Android.
 pub trait ActiveEventLoopExtAndroid {}
@@ -119,7 +119,7 @@ pub trait EventLoopBuilderExtAndroid {
    fn handle_volume_keys(&mut self) -> &mut Self;
 }

-impl<T> EventLoopBuilderExtAndroid for EventLoopBuilder<T> {
+impl EventLoopBuilderExtAndroid for EventLoopBuilder {
    fn with_android_app(&mut self, app: AndroidApp) -> &mut Self {
        self.platform_specific.android_app = Some(app);
        self
--- a/src/platform/ios.rs
+++ b/src/platform/ios.rs
@@ -66,22 +66,9 @@

 use std::os::raw::c_void;

-use crate::event_loop::EventLoop;
 use crate::monitor::{MonitorHandle, VideoModeHandle};
 use crate::window::{Window, WindowAttributes};

-/// Additional methods on [`EventLoop`] that are specific to iOS.
-pub trait EventLoopExtIOS {
-    /// Returns the [`Idiom`] (phone/tablet/tv/etc) for the current device.
-    fn idiom(&self) -> Idiom;
-}
-
-impl<T: 'static> EventLoopExtIOS for EventLoop<T> {
-    fn idiom(&self) -> Idiom {
-        self.event_loop.idiom()
-    }
-}
-
 /// Additional methods on [`Window`] that are specific to iOS.
 pub trait WindowExtIOS {
    /// Sets the [`contentScaleFactor`] of the underlying [`UIWindow`] to `scale_factor`.
@@ -357,7 +344,7 @@ impl MonitorHandleExtIOS for MonitorHandle {
    fn ui_screen(&self) -> *mut c_void {
        // SAFETY: The marker is only used to get the pointer of the screen
        let mtm = unsafe { objc2_foundation::MainThreadMarker::new_unchecked() };
-        objc2::rc::Id::as_ptr(self.inner.ui_screen(mtm)) as *mut c_void
+        objc2::rc::Retained::as_ptr(self.inner.ui_screen(mtm)) as *mut c_void
    }

    #[inline]
@@ -379,24 +366,6 @@ pub enum ValidOrientations {
    Portrait,
 }

-/// The device [idiom].
-///
-/// [idiom]: https://developer.apple.com/documentation/uikit/uidevice/1620037-userinterfaceidiom?language=objc
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub enum Idiom {
-    Unspecified,
-
-    /// iPhone and iPod touch.
-    Phone,
-
-    /// iPad.
-    Pad,
-
-    /// tvOS and Apple TV.
-    TV,
-    CarPlay,
-}
-
 bitflags::bitflags! {
    /// The [edges] of a screen.
    ///
--- a/src/platform/macos.rs
+++ b/src/platform/macos.rs
@@ -338,7 +338,7 @@ pub trait EventLoopBuilderExtMacOS {
    fn with_activate_ignoring_other_apps(&mut self, ignore: bool) -> &mut Self;
 }

-impl<T> EventLoopBuilderExtMacOS for EventLoopBuilder<T> {
+impl EventLoopBuilderExtMacOS for EventLoopBuilder {
    #[inline]
    fn with_activation_policy(&mut self, activation_policy: ActivationPolicy) -> &mut Self {
        self.platform_specific.activation_policy = activation_policy;
@@ -375,7 +375,7 @@ impl MonitorHandleExtMacOS for MonitorHandle {
    fn ns_screen(&self) -> Option<*mut c_void> {
        // SAFETY: We only use the marker to get a pointer
        let mtm = unsafe { objc2_foundation::MainThreadMarker::new_unchecked() };
-        self.inner.ns_screen(mtm).map(|s| objc2::rc::Id::as_ptr(&s) as _)
+        self.inner.ns_screen(mtm).map(|s| objc2::rc::Retained::as_ptr(&s) as _)
    }
 }

--- a/src/platform/pump_events.rs
+++ b/src/platform/pump_events.rs
@@ -1,14 +1,10 @@
 use std::time::Duration;

 use crate::application::ApplicationHandler;
-use crate::event::Event;
-use crate::event_loop::{self, ActiveEventLoop, EventLoop};
+use crate::event_loop::EventLoop;

 /// Additional methods on [`EventLoop`] for pumping events within an external event loop
 pub trait EventLoopExtPumpEvents {
-    /// A type provided by the user that can be passed through [`Event::UserEvent`].
-    type UserEvent: 'static;
-
    /// Pump the `EventLoop` to check for and dispatch pending events.
    ///
    /// This API is designed to enable applications to integrate Winit into an
@@ -103,34 +99,20 @@ pub trait EventLoopExtPumpEvents {
    ///   If you render outside of Winit you are likely to see window resizing artifacts
    ///   since MacOS expects applications to render synchronously during any `drawRect`
    ///   callback.
-    fn pump_app_events<A: ApplicationHandler<Self::UserEvent>>(
+    fn pump_app_events<A: ApplicationHandler>(
+        &mut self,
+        timeout: Option<Duration>,
+        app: &mut A,
+    ) -> PumpStatus;
+}
+
+impl EventLoopExtPumpEvents for EventLoop {
+    fn pump_app_events<A: ApplicationHandler>(
        &mut self,
        timeout: Option<Duration>,
        app: &mut A,
    ) -> PumpStatus {
-        #[allow(deprecated)]
-        self.pump_events(timeout, |event, event_loop| {
-            event_loop::dispatch_event_for_app(app, event_loop, event)
-        })
-    }
-
-    /// See [`pump_app_events`].
-    ///
-    /// [`pump_app_events`]: Self::pump_app_events
-    #[deprecated = "use EventLoopExtPumpEvents::pump_app_events"]
-    fn pump_events<F>(&mut self, timeout: Option<Duration>, event_handler: F) -> PumpStatus
-    where
-        F: FnMut(Event<Self::UserEvent>, &ActiveEventLoop);
-}
-
-impl<T> EventLoopExtPumpEvents for EventLoop<T> {
-    type UserEvent = T;
-
-    fn pump_events<F>(&mut self, timeout: Option<Duration>, event_handler: F) -> PumpStatus
-    where
-        F: FnMut(Event<Self::UserEvent>, &ActiveEventLoop),
-    {
-        self.event_loop.pump_events(timeout, event_handler)
+        self.event_loop.pump_app_events(timeout, app)
    }
 }

--- a/src/platform/run_on_demand.rs
+++ b/src/platform/run_on_demand.rs
@@ -1,24 +1,12 @@
 use crate::application::ApplicationHandler;
 use crate::error::EventLoopError;
-use crate::event::Event;
-use crate::event_loop::{self, ActiveEventLoop, EventLoop};
+use crate::event_loop::{ActiveEventLoop, EventLoop};

 #[cfg(doc)]
 use crate::{platform::pump_events::EventLoopExtPumpEvents, window::Window};

 /// Additional methods on [`EventLoop`] to return control flow to the caller.
 pub trait EventLoopExtRunOnDemand {
-    /// A type provided by the user that can be passed through [`Event::UserEvent`].
-    type UserEvent: 'static;
-
-    /// See [`run_app_on_demand`].
-    ///
-    /// [`run_app_on_demand`]: Self::run_app_on_demand
-    #[deprecated = "use EventLoopExtRunOnDemand::run_app_on_demand"]
-    fn run_on_demand<F>(&mut self, event_handler: F) -> Result<(), EventLoopError>
-    where
-        F: FnMut(Event<Self::UserEvent>, &ActiveEventLoop);
-
    /// Run the application with the event loop on the calling thread.
    ///
    /// Unlike [`EventLoop::run_app`], this function accepts non-`'static` (i.e. non-`move`)
@@ -65,26 +53,19 @@ pub trait EventLoopExtRunOnDemand {
    ///
    /// [`exit()`]: ActiveEventLoop::exit()
    /// [`set_control_flow()`]: ActiveEventLoop::set_control_flow()
-    fn run_app_on_demand<A: ApplicationHandler<Self::UserEvent>>(
+    fn run_app_on_demand<A: ApplicationHandler>(
+        &mut self,
+        app: &mut A,
+    ) -> Result<(), EventLoopError>;
+}
+
+impl EventLoopExtRunOnDemand for EventLoop {
+    fn run_app_on_demand<A: ApplicationHandler>(
        &mut self,
        app: &mut A,
    ) -> Result<(), EventLoopError> {
-        #[allow(deprecated)]
-        self.run_on_demand(|event, event_loop| {
-            event_loop::dispatch_event_for_app(app, event_loop, event)
-        })
-    }
-}
-
-impl<T> EventLoopExtRunOnDemand for EventLoop<T> {
-    type UserEvent = T;
-
-    fn run_on_demand<F>(&mut self, event_handler: F) -> Result<(), EventLoopError>
-    where
-        F: FnMut(Event<Self::UserEvent>, &ActiveEventLoop),
-    {
        self.event_loop.window_target().clear_exit();
-        self.event_loop.run_on_demand(event_handler)
+        self.event_loop.run_app_on_demand(app)
    }
 }

--- a/src/platform/wayland.rs
+++ b/src/platform/wayland.rs
@@ -13,7 +13,7 @@
 //! * `wayland-csd-adwaita` (default).
 //! * `wayland-csd-adwaita-crossfont`.
 //! * `wayland-csd-adwaita-notitle`.
-use crate::event_loop::{ActiveEventLoop, EventLoopBuilder};
+use crate::event_loop::{ActiveEventLoop, EventLoop, EventLoopBuilder};
 use crate::monitor::MonitorHandle;
 use crate::window::{Window, WindowAttributes};

@@ -32,6 +32,19 @@ impl ActiveEventLoopExtWayland for ActiveEventLoop {
    }
 }

+/// Additional methods on [`EventLoop`] that are specific to Wayland.
+pub trait EventLoopExtWayland {
+    /// True if the [`EventLoop`] uses Wayland.
+    fn is_wayland(&self) -> bool;
+}
+
+impl EventLoopExtWayland for EventLoop {
+    #[inline]
+    fn is_wayland(&self) -> bool {
+        self.event_loop.is_wayland()
+    }
+}
+
 /// Additional methods on [`EventLoopBuilder`] that are specific to Wayland.
 pub trait EventLoopBuilderExtWayland {
    /// Force using Wayland.
@@ -44,7 +57,7 @@ pub trait EventLoopBuilderExtWayland {
    fn with_any_thread(&mut self, any_thread: bool) -> &mut Self;
 }

-impl<T> EventLoopBuilderExtWayland for EventLoopBuilder<T> {
+impl EventLoopBuilderExtWayland for EventLoopBuilder {
    #[inline]
    fn with_wayland(&mut self) -> &mut Self {
        self.platform_specific.forced_backend = Some(crate::platform_impl::Backend::Wayland);
--- a/src/platform/web.rs
+++ b/src/platform/web.rs
@@ -55,8 +55,7 @@ use web_sys::HtmlCanvasElement;

 use crate::application::ApplicationHandler;
 use crate::cursor::CustomCursorSource;
-use crate::event::Event;
-use crate::event_loop::{self, ActiveEventLoop, EventLoop};
+use crate::event_loop::{ActiveEventLoop, EventLoop};
 #[cfg(web_platform)]
 use crate::platform_impl::CustomCursorFuture as PlatformCustomCursorFuture;
 use crate::platform_impl::PlatformCustomCursorSource;
@@ -156,9 +155,6 @@ impl WindowAttributesExtWebSys for WindowAttributes {

 /// Additional methods on `EventLoop` that are specific to the web.
 pub trait EventLoopExtWebSys {
-    /// A type provided by the user that can be passed through `Event::UserEvent`.
-    type UserEvent: 'static;
-
    /// Initializes the winit event loop.
    ///
    /// Unlike
@@ -181,31 +177,56 @@ pub trait EventLoopExtWebSys {
        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<Self::UserEvent> + 'static>(self, app: A);
+    fn spawn_app<A: ApplicationHandler + 'static>(self, app: A);

-    /// See [`spawn_app`].
+    /// Sets the strategy for [`ControlFlow::Poll`].
    ///
-    /// [`spawn_app`]: Self::spawn_app
-    #[deprecated = "use EventLoopExtWebSys::spawn_app"]
-    fn spawn<F>(self, event_handler: F)
-    where
-        F: 'static + FnMut(Event<Self::UserEvent>, &ActiveEventLoop);
+    /// See [`PollStrategy`].
+    ///
+    /// [`ControlFlow::Poll`]: crate::event_loop::ControlFlow::Poll
+    fn set_poll_strategy(&self, strategy: PollStrategy);
+
+    /// Gets the strategy for [`ControlFlow::Poll`].
+    ///
+    /// See [`PollStrategy`].
+    ///
+    /// [`ControlFlow::Poll`]: crate::event_loop::ControlFlow::Poll
+    fn poll_strategy(&self) -> PollStrategy;
+
+    /// Sets the strategy for [`ControlFlow::WaitUntil`].
+    ///
+    /// See [`WaitUntilStrategy`].
+    ///
+    /// [`ControlFlow::WaitUntil`]: crate::event_loop::ControlFlow::WaitUntil
+    fn set_wait_until_strategy(&self, strategy: WaitUntilStrategy);
+
+    /// Gets the strategy for [`ControlFlow::WaitUntil`].
+    ///
+    /// See [`WaitUntilStrategy`].
+    ///
+    /// [`ControlFlow::WaitUntil`]: crate::event_loop::ControlFlow::WaitUntil
+    fn wait_until_strategy(&self) -> WaitUntilStrategy;
 }

-impl<T> EventLoopExtWebSys for EventLoop<T> {
-    type UserEvent = T;
-
-    fn spawn_app<A: ApplicationHandler<Self::UserEvent> + 'static>(self, mut app: A) {
-        self.event_loop.spawn(move |event, event_loop| {
-            event_loop::dispatch_event_for_app(&mut app, event_loop, event)
-        });
+impl EventLoopExtWebSys for EventLoop {
+    fn spawn_app<A: ApplicationHandler + 'static>(self, app: A) {
+        self.event_loop.spawn_app(app);
    }

-    fn spawn<F>(self, event_handler: F)
-    where
-        F: 'static + FnMut(Event<Self::UserEvent>, &ActiveEventLoop),
-    {
-        self.event_loop.spawn(event_handler)
+    fn set_poll_strategy(&self, strategy: PollStrategy) {
+        self.event_loop.set_poll_strategy(strategy);
+    }
+
+    fn poll_strategy(&self) -> PollStrategy {
+        self.event_loop.poll_strategy()
+    }
+
+    fn set_wait_until_strategy(&self, strategy: WaitUntilStrategy) {
+        self.event_loop.set_wait_until_strategy(strategy);
+    }
+
+    fn wait_until_strategy(&self) -> WaitUntilStrategy {
+        self.event_loop.wait_until_strategy()
    }
 }

@@ -224,6 +245,20 @@ pub trait ActiveEventLoopExtWebSys {
    /// [`ControlFlow::Poll`]: crate::event_loop::ControlFlow::Poll
    fn poll_strategy(&self) -> PollStrategy;

+    /// Sets the strategy for [`ControlFlow::WaitUntil`].
+    ///
+    /// See [`WaitUntilStrategy`].
+    ///
+    /// [`ControlFlow::WaitUntil`]: crate::event_loop::ControlFlow::WaitUntil
+    fn set_wait_until_strategy(&self, strategy: WaitUntilStrategy);
+
+    /// Gets the strategy for [`ControlFlow::WaitUntil`].
+    ///
+    /// See [`WaitUntilStrategy`].
+    ///
+    /// [`ControlFlow::WaitUntil`]: crate::event_loop::ControlFlow::WaitUntil
+    fn wait_until_strategy(&self) -> WaitUntilStrategy;
+
    /// Async version of [`ActiveEventLoop::create_custom_cursor()`] which waits until the
    /// cursor has completely finished loading.
    fn create_custom_cursor_async(&self, source: CustomCursorSource) -> CustomCursorFuture;
@@ -244,6 +279,16 @@ impl ActiveEventLoopExtWebSys for ActiveEventLoop {
    fn poll_strategy(&self) -> PollStrategy {
        self.p.poll_strategy()
    }
+
+    #[inline]
+    fn set_wait_until_strategy(&self, strategy: WaitUntilStrategy) {
+        self.p.set_wait_until_strategy(strategy);
+    }
+
+    #[inline]
+    fn wait_until_strategy(&self) -> WaitUntilStrategy {
+        self.p.wait_until_strategy()
+    }
 }

 /// Strategy used for [`ControlFlow::Poll`][crate::event_loop::ControlFlow::Poll].
@@ -272,6 +317,29 @@ pub enum PollStrategy {
    Scheduler,
 }

+/// Strategy used for [`ControlFlow::WaitUntil`][crate::event_loop::ControlFlow::WaitUntil].
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub enum WaitUntilStrategy {
+    /// Uses the [Prioritized Task Scheduling API] to queue the next event loop. If not available
+    /// this will fallback to [`setTimeout()`].
+    ///
+    /// This strategy is commonly not affected by browser throttling unless the window is not
+    /// focused.
+    ///
+    /// This is the default strategy.
+    ///
+    /// [Prioritized Task Scheduling API]: https://developer.mozilla.org/en-US/docs/Web/API/Prioritized_Task_Scheduling_API
+    /// [`setTimeout()`]: https://developer.mozilla.org/en-US/docs/Web/API/setTimeout
+    #[default]
+    Scheduler,
+    /// Equal to [`Scheduler`][Self::Scheduler] but wakes up the event loop from a [worker].
+    ///
+    /// This strategy is commonly not affected by browser throttling regardless of window focus.
+    ///
+    /// [worker]: https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API
+    Worker,
+}
+
 pub trait CustomCursorExtWebSys {
    /// Returns if this cursor is an animation.
    fn is_animation(&self) -> bool;
--- a/src/platform/windows.rs
+++ b/src/platform/windows.rs
@@ -227,7 +227,7 @@ pub trait EventLoopBuilderExtWindows {
        F: FnMut(*const c_void) -> bool + 'static;
 }

-impl<T> EventLoopBuilderExtWindows for EventLoopBuilder<T> {
+impl EventLoopBuilderExtWindows for EventLoopBuilder {
    #[inline]
    fn with_any_thread(&mut self, any_thread: bool) -> &mut Self {
        self.platform_specific.any_thread = any_thread;
@@ -476,10 +476,10 @@ pub trait WindowAttributesExtWindows {
    /// the menus look. If you use this, it is recommended that you combine it with
    /// `with_theme(Some(Theme::Light))` to avoid a jarring effect.
    #[cfg_attr(
-        platform_windows,
+        windows_platform,
        doc = "[`CreateMenu`]: windows_sys::Win32::UI::WindowsAndMessaging::CreateMenu"
    )]
-    #[cfg_attr(not(platform_windows), doc = "[`CreateMenu`]: #only-available-on-windows")]
+    #[cfg_attr(not(windows_platform), doc = "[`CreateMenu`]: #only-available-on-windows")]
    fn with_menu(self, menu: HMENU) -> Self;

    /// This sets `ICON_BIG`. A good ceiling here is 256x256.
--- a/src/platform/x11.rs
+++ b/src/platform/x11.rs
@@ -2,7 +2,7 @@
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};

-use crate::event_loop::{ActiveEventLoop, EventLoopBuilder};
+use crate::event_loop::{ActiveEventLoop, EventLoop, EventLoopBuilder};
 use crate::monitor::MonitorHandle;
 use crate::window::{Window, WindowAttributes};

@@ -99,6 +99,19 @@ impl ActiveEventLoopExtX11 for ActiveEventLoop {
    }
 }

+/// Additional methods on [`EventLoop`] that are specific to X11.
+pub trait EventLoopExtX11 {
+    /// True if the [`EventLoop`] uses X11.
+    fn is_x11(&self) -> bool;
+}
+
+impl EventLoopExtX11 for EventLoop {
+    #[inline]
+    fn is_x11(&self) -> bool {
+        !self.event_loop.is_wayland()
+    }
+}
+
 /// Additional methods on [`EventLoopBuilder`] that are specific to X11.
 pub trait EventLoopBuilderExtX11 {
    /// Force using X11.
@@ -111,7 +124,7 @@ pub trait EventLoopBuilderExtX11 {
    fn with_any_thread(&mut self, any_thread: bool) -> &mut Self;
 }

-impl<T> EventLoopBuilderExtX11 for EventLoopBuilder<T> {
+impl EventLoopBuilderExtX11 for EventLoopBuilder {
    #[inline]
    fn with_x11(&mut self) -> &mut Self {
        self.platform_specific.forced_backend = Some(crate::platform_impl::Backend::X);
--- a/src/platform_impl/android/mod.rs
+++ b/src/platform_impl/android/mod.rs
@@ -1,11 +1,9 @@
-#![cfg(android_platform)]
-
 use std::cell::Cell;
 use std::collections::VecDeque;
 use std::hash::Hash;
 use std::marker::PhantomData;
 use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::{mpsc, Arc, Mutex};
+use std::sync::{Arc, Mutex};
 use std::time::{Duration, Instant};

 use android_activity::input::{InputEvent, KeyAction, Keycode, MotionAction};
@@ -14,12 +12,13 @@ use android_activity::{
 };
 use tracing::{debug, trace, warn};

+use crate::application::ApplicationHandler;
 use crate::cursor::Cursor;
 use crate::dpi::{PhysicalPosition, PhysicalSize, Position, Size};
 use crate::error;
 use crate::error::EventLoopError;
 use crate::event::{self, Force, InnerSizeWriter, StartCause};
-use crate::event_loop::{self, ActiveEventLoop as RootAEL, ControlFlow, DeviceEvents};
+use crate::event_loop::{self, ControlFlow, DeviceEvents};
 use crate::platform::pump_events::PumpStatus;
 use crate::platform_impl::Fullscreen;
 use crate::window::{
@@ -43,41 +42,6 @@ fn min_timeout(a: Option<Duration>, b: Option<Duration>) -> Option<Duration> {
    a.map_or(b, |a_timeout| b.map_or(Some(a_timeout), |b_timeout| Some(a_timeout.min(b_timeout))))
 }

-struct PeekableReceiver<T> {
-    recv: mpsc::Receiver<T>,
-    first: Option<T>,
-}
-
-impl<T> PeekableReceiver<T> {
-    pub fn from_recv(recv: mpsc::Receiver<T>) -> Self {
-        Self { recv, first: None }
-    }
-
-    pub fn has_incoming(&mut self) -> bool {
-        if self.first.is_some() {
-            return true;
-        }
-        match self.recv.try_recv() {
-            Ok(v) => {
-                self.first = Some(v);
-                true
-            },
-            Err(mpsc::TryRecvError::Empty) => false,
-            Err(mpsc::TryRecvError::Disconnected) => {
-                warn!("Channel was disconnected when checking incoming");
-                false
-            },
-        }
-    }
-
-    pub fn try_recv(&mut self) -> Result<T, mpsc::TryRecvError> {
-        if let Some(first) = self.first.take() {
-            return Ok(first);
-        }
-        self.recv.try_recv()
-    }
-}
-
 #[derive(Clone)]
 struct SharedFlagSetter {
    flag: Arc<AtomicBool>,
@@ -133,13 +97,12 @@ impl RedrawRequester {
 #[derive(Debug, Clone, Eq, PartialEq, Hash)]
 pub struct KeyEventExtra {}

-pub struct EventLoop<T: 'static> {
+pub struct EventLoop {
    android_app: AndroidApp,
    window_target: event_loop::ActiveEventLoop,
    redraw_flag: SharedFlag,
-    user_events_sender: mpsc::Sender<T>,
-    user_events_receiver: PeekableReceiver<T>, // must wake looper whenever something gets sent
-    loop_running: bool,                        // Dispatched `NewEvents<Init>`
+    proxy_wake_up: Arc<AtomicBool>,
+    loop_running: bool, // Dispatched `NewEvents<Init>`
    running: bool,
    pending_redraw: bool,
    cause: StartCause,
@@ -159,11 +122,11 @@ impl Default for PlatformSpecificEventLoopAttributes {
    }
 }

-impl<T: 'static> EventLoop<T> {
+impl EventLoop {
    pub(crate) fn new(
        attributes: &PlatformSpecificEventLoopAttributes,
    ) -> Result<Self, EventLoopError> {
-        let (user_events_sender, user_events_receiver) = mpsc::channel();
+        let proxy_wake_up = Arc::new(AtomicBool::new(false));

        let android_app = attributes.android_app.as_ref().expect(
            "An `AndroidApp` as passed to android_main() is required to create an `EventLoop` on \
@@ -186,8 +149,7 @@ impl<T: 'static> EventLoop<T> {
                _marker: PhantomData,
            },
            redraw_flag,
-            user_events_sender,
-            user_events_receiver: PeekableReceiver::from_recv(user_events_receiver),
+            proxy_wake_up,
            loop_running: false,
            running: false,
            pending_redraw: false,
@@ -197,27 +159,28 @@ impl<T: 'static> EventLoop<T> {
        })
    }

-    fn single_iteration<F>(&mut self, main_event: Option<MainEvent<'_>>, callback: &mut F)
-    where
-        F: FnMut(event::Event<T>, &RootAEL),
-    {
+    fn single_iteration<A: ApplicationHandler>(
+        &mut self,
+        main_event: Option<MainEvent<'_>>,
+        app: &mut A,
+    ) {
        trace!("Mainloop iteration");

        let cause = self.cause;
        let mut pending_redraw = self.pending_redraw;
        let mut resized = false;

-        callback(event::Event::NewEvents(cause), self.window_target());
+        app.new_events(self.window_target(), cause);

        if let Some(event) = main_event {
            trace!("Handling main event {:?}", event);

            match event {
                MainEvent::InitWindow { .. } => {
-                    callback(event::Event::Resumed, self.window_target());
+                    app.resumed(self.window_target());
                },
                MainEvent::TerminateWindow { .. } => {
-                    callback(event::Event::Suspended, self.window_target());
+                    app.suspended(self.window_target());
                },
                MainEvent::WindowResized { .. } => resized = true,
                MainEvent::RedrawNeeded { .. } => pending_redraw = true,
@@ -226,23 +189,15 @@ impl<T: 'static> EventLoop<T> {
                },
                MainEvent::GainedFocus => {
                    HAS_FOCUS.store(true, Ordering::Relaxed);
-                    callback(
-                        event::Event::WindowEvent {
-                            window_id: window::WindowId(WindowId),
-                            event: event::WindowEvent::Focused(true),
-                        },
-                        self.window_target(),
-                    );
+                    let window_id = window::WindowId(WindowId);
+                    let event = event::WindowEvent::Focused(true);
+                    app.window_event(self.window_target(), window_id, event);
                },
                MainEvent::LostFocus => {
                    HAS_FOCUS.store(false, Ordering::Relaxed);
-                    callback(
-                        event::Event::WindowEvent {
-                            window_id: window::WindowId(WindowId),
-                            event: event::WindowEvent::Focused(false),
-                        },
-                        self.window_target(),
-                    );
+                    let window_id = window::WindowId(WindowId);
+                    let event = event::WindowEvent::Focused(false);
+                    app.window_event(self.window_target(), window_id, event);
                },
                MainEvent::ConfigChanged { .. } => {
                    let monitor = MonitorHandle::new(self.android_app.clone());
@@ -252,20 +207,19 @@ impl<T: 'static> EventLoop<T> {
                        let new_inner_size = Arc::new(Mutex::new(
                            MonitorHandle::new(self.android_app.clone()).size(),
                        ));
-                        let event = event::Event::WindowEvent {
-                            window_id: window::WindowId(WindowId),
-                            event: event::WindowEvent::ScaleFactorChanged {
-                                inner_size_writer: InnerSizeWriter::new(Arc::downgrade(
-                                    &new_inner_size,
-                                )),
-                                scale_factor,
-                            },
+                        let window_id = window::WindowId(WindowId);
+                        let event = event::WindowEvent::ScaleFactorChanged {
+                            inner_size_writer: InnerSizeWriter::new(Arc::downgrade(
+                                &new_inner_size,
+                            )),
+                            scale_factor,
                        };
-                        callback(event, self.window_target());
+
+                        app.window_event(self.window_target(), window_id, event);
                    }
                },
                MainEvent::LowMemory => {
-                    callback(event::Event::MemoryWarning, self.window_target());
+                    app.memory_warning(self.window_target());
                },
                MainEvent::Start => {
                    // XXX: how to forward this state to applications?
@@ -313,7 +267,7 @@ impl<T: 'static> EventLoop<T> {
        match android_app.input_events_iter() {
            Ok(mut input_iter) => loop {
                let read_event =
-                    input_iter.next(|event| self.handle_input_event(&android_app, event, callback));
+                    input_iter.next(|event| self.handle_input_event(&android_app, event, app));

                if !read_event {
                    break;
@@ -324,11 +278,8 @@ impl<T: 'static> EventLoop<T> {
            },
        }

-        // Empty the user event buffer
-        {
-            while let Ok(event) = self.user_events_receiver.try_recv() {
-                callback(crate::event::Event::UserEvent(event), self.window_target());
-            }
+        if self.proxy_wake_up.swap(false, Ordering::Relaxed) {
+            app.proxy_wake_up(self.window_target());
        }

        if self.running {
@@ -340,39 +291,32 @@ impl<T: 'static> EventLoop<T> {
                } else {
                    PhysicalSize::new(0, 0)
                };
-                let event = event::Event::WindowEvent {
-                    window_id: window::WindowId(WindowId),
-                    event: event::WindowEvent::Resized(size),
-                };
-                callback(event, self.window_target());
+                let window_id = window::WindowId(WindowId);
+                let event = event::WindowEvent::Resized(size);
+                app.window_event(self.window_target(), window_id, event);
            }

            pending_redraw |= self.redraw_flag.get_and_reset();
            if pending_redraw {
                pending_redraw = false;
-                let event = event::Event::WindowEvent {
-                    window_id: window::WindowId(WindowId),
-                    event: event::WindowEvent::RedrawRequested,
-                };
-                callback(event, self.window_target());
+                let window_id = window::WindowId(WindowId);
+                let event = event::WindowEvent::RedrawRequested;
+                app.window_event(self.window_target(), window_id, event);
            }
        }

        // This is always the last event we dispatch before poll again
-        callback(event::Event::AboutToWait, self.window_target());
+        app.about_to_wait(self.window_target());

        self.pending_redraw = pending_redraw;
    }

-    fn handle_input_event<F>(
+    fn handle_input_event<A: ApplicationHandler>(
        &mut self,
        android_app: &AndroidApp,
        event: &InputEvent<'_>,
-        callback: &mut F,
-    ) -> InputStatus
-    where
-        F: FnMut(event::Event<T>, &RootAEL),
-    {
+        app: &mut A,
+    ) -> InputStatus {
        let mut input_status = InputStatus::Handled;
        match event {
            InputEvent::MotionEvent(motion_event) => {
@@ -410,17 +354,16 @@ impl<T: 'static> EventLoop<T> {
                            "Input event {device_id:?}, {phase:?}, loc={location:?}, \
                             pointer={pointer:?}"
                        );
-                        let event = event::Event::WindowEvent {
-                            window_id,
-                            event: event::WindowEvent::Touch(event::Touch {
-                                device_id,
-                                phase,
-                                location,
-                                id: pointer.pointer_id() as u64,
-                                force: Some(Force::Normalized(pointer.pressure() as f64)),
-                            }),
-                        };
-                        callback(event, self.window_target());
+
+                        let event = event::WindowEvent::Touch(event::Touch {
+                            device_id,
+                            phase,
+                            location,
+                            id: pointer.pointer_id() as u64,
+                            force: Some(Force::Normalized(pointer.pressure() as f64)),
+                        });
+
+                        app.window_event(self.window_target(), window_id, event);
                    }
                }
            },
@@ -448,23 +391,22 @@ impl<T: 'static> EventLoop<T> {
                            &mut self.combining_accent,
                        );

-                        let event = event::Event::WindowEvent {
-                            window_id: window::WindowId(WindowId),
-                            event: event::WindowEvent::KeyboardInput {
-                                device_id: event::DeviceId(DeviceId(key.device_id())),
-                                event: event::KeyEvent {
-                                    state,
-                                    physical_key: keycodes::to_physical_key(keycode),
-                                    logical_key: keycodes::to_logical(key_char, keycode),
-                                    location: keycodes::to_location(keycode),
-                                    repeat: key.repeat_count() > 0,
-                                    text: None,
-                                    platform_specific: KeyEventExtra {},
-                                },
-                                is_synthetic: false,
+                        let window_id = window::WindowId(WindowId);
+                        let event = event::WindowEvent::KeyboardInput {
+                            device_id: event::DeviceId(DeviceId(key.device_id())),
+                            event: event::KeyEvent {
+                                state,
+                                physical_key: keycodes::to_physical_key(keycode),
+                                logical_key: keycodes::to_logical(key_char, keycode),
+                                location: keycodes::to_location(keycode),
+                                repeat: key.repeat_count() > 0,
+                                text: None,
+                                platform_specific: KeyEventExtra {},
                            },
+                            is_synthetic: false,
                        };
-                        callback(event, self.window_target());
+
+                        app.window_event(self.window_target(), window_id, event);
                    },
                }
            },
@@ -476,19 +418,16 @@ impl<T: 'static> EventLoop<T> {
        input_status
    }

-    pub fn run<F>(mut self, event_handler: F) -> Result<(), EventLoopError>
-    where
-        F: FnMut(event::Event<T>, &event_loop::ActiveEventLoop),
-    {
-        self.run_on_demand(event_handler)
+    pub fn run_app<A: ApplicationHandler>(mut self, app: &mut A) -> Result<(), EventLoopError> {
+        self.run_app_on_demand(app)
    }

-    pub fn run_on_demand<F>(&mut self, mut event_handler: F) -> Result<(), EventLoopError>
-    where
-        F: FnMut(event::Event<T>, &event_loop::ActiveEventLoop),
-    {
+    pub fn run_app_on_demand<A: ApplicationHandler>(
+        &mut self,
+        app: &mut A,
+    ) -> Result<(), EventLoopError> {
        loop {
-            match self.pump_events(None, &mut event_handler) {
+            match self.pump_app_events(None, app) {
                PumpStatus::Exit(0) => {
                    break Ok(());
                },
@@ -502,10 +441,11 @@ impl<T: 'static> EventLoop<T> {
        }
    }

-    pub fn pump_events<F>(&mut self, timeout: Option<Duration>, mut callback: F) -> PumpStatus
-    where
-        F: FnMut(event::Event<T>, &RootAEL),
-    {
+    pub fn pump_app_events<A: ApplicationHandler>(
+        &mut self,
+        timeout: Option<Duration>,
+        app: &mut A,
+    ) -> PumpStatus {
        if !self.loop_running {
            self.loop_running = true;

@@ -516,18 +456,18 @@ impl<T: 'static> EventLoop<T> {
            self.cause = StartCause::Init;

            // run the initial loop iteration
-            self.single_iteration(None, &mut callback);
+            self.single_iteration(None, app);
        }

        // Consider the possibility that the `StartCause::Init` iteration could
        // request to Exit
        if !self.exiting() {
-            self.poll_events_with_timeout(timeout, &mut callback);
+            self.poll_events_with_timeout(timeout, app);
        }
        if self.exiting() {
            self.loop_running = false;

-            callback(event::Event::LoopExiting, self.window_target());
+            app.exiting(self.window_target());

            PumpStatus::Exit(0)
        } else {
@@ -535,32 +475,34 @@ impl<T: 'static> EventLoop<T> {
        }
    }

-    fn poll_events_with_timeout<F>(&mut self, mut timeout: Option<Duration>, mut callback: F)
-    where
-        F: FnMut(event::Event<T>, &RootAEL),
-    {
+    fn poll_events_with_timeout<A: ApplicationHandler>(
+        &mut self,
+        mut timeout: Option<Duration>,
+        app: &mut A,
+    ) {
        let start = Instant::now();

        self.pending_redraw |= self.redraw_flag.get_and_reset();

-        timeout =
-            if self.running && (self.pending_redraw || self.user_events_receiver.has_incoming()) {
-                // If we already have work to do then we don't want to block on the next poll
-                Some(Duration::ZERO)
-            } else {
-                let control_flow_timeout = match self.control_flow() {
-                    ControlFlow::Wait => None,
-                    ControlFlow::Poll => Some(Duration::ZERO),
-                    ControlFlow::WaitUntil(wait_deadline) => {
-                        Some(wait_deadline.saturating_duration_since(start))
-                    },
-                };
-
-                min_timeout(control_flow_timeout, timeout)
+        timeout = if self.running
+            && (self.pending_redraw || self.proxy_wake_up.load(Ordering::Relaxed))
+        {
+            // If we already have work to do then we don't want to block on the next poll
+            Some(Duration::ZERO)
+        } else {
+            let control_flow_timeout = match self.control_flow() {
+                ControlFlow::Wait => None,
+                ControlFlow::Poll => Some(Duration::ZERO),
+                ControlFlow::WaitUntil(wait_deadline) => {
+                    Some(wait_deadline.saturating_duration_since(start))
+                },
            };

-        let app = self.android_app.clone(); // Don't borrow self as part of poll expression
-        app.poll_events(timeout, |poll_event| {
+            min_timeout(control_flow_timeout, timeout)
+        };
+
+        let android_app = self.android_app.clone(); // Don't borrow self as part of poll expression
+        android_app.poll_events(timeout, |poll_event| {
            let mut main_event = None;

            match poll_event {
@@ -575,7 +517,7 @@ impl<T: 'static> EventLoop<T> {
                    // We also ignore wake ups while suspended.
                    self.pending_redraw |= self.redraw_flag.get_and_reset();
                    if !self.running
-                        || (!self.pending_redraw && !self.user_events_receiver.has_incoming())
+                        || (!self.pending_redraw && !self.proxy_wake_up.load(Ordering::Relaxed))
                    {
                        return;
                    }
@@ -601,7 +543,7 @@ impl<T: 'static> EventLoop<T> {
                },
            };

-            self.single_iteration(main_event, &mut callback);
+            self.single_iteration(main_event, app);
        });
    }

@@ -609,9 +551,9 @@ impl<T: 'static> EventLoop<T> {
        &self.window_target
    }

-    pub fn create_proxy(&self) -> EventLoopProxy<T> {
+    pub fn create_proxy(&self) -> EventLoopProxy {
        EventLoopProxy {
-            user_events_sender: self.user_events_sender.clone(),
+            proxy_wake_up: self.proxy_wake_up.clone(),
            waker: self.android_app.create_waker(),
        }
    }
@@ -625,25 +567,16 @@ impl<T: 'static> EventLoop<T> {
    }
 }

-pub struct EventLoopProxy<T: 'static> {
-    user_events_sender: mpsc::Sender<T>,
+#[derive(Clone)]
+pub struct EventLoopProxy {
+    proxy_wake_up: Arc<AtomicBool>,
    waker: AndroidAppWaker,
 }

-impl<T: 'static> Clone for EventLoopProxy<T> {
-    fn clone(&self) -> Self {
-        EventLoopProxy {
-            user_events_sender: self.user_events_sender.clone(),
-            waker: self.waker.clone(),
-        }
-    }
-}
-
-impl<T> EventLoopProxy<T> {
-    pub fn send_event(&self, event: T) -> Result<(), event_loop::EventLoopClosed<T>> {
-        self.user_events_sender.send(event).map_err(|err| event_loop::EventLoopClosed(err.0))?;
+impl EventLoopProxy {
+    pub fn wake_up(&self) {
+        self.proxy_wake_up.store(true, Ordering::Relaxed);
        self.waker.wake();
-        Ok(())
    }
 }

--- a/src/platform_impl/apple/appkit/app.rs
+++ b/src/platform_impl/apple/appkit/app.rs
@@ -4,8 +4,8 @@ use objc2::{declare_class, msg_send, mutability, ClassType, DeclaredClass};
 use objc2_app_kit::{NSApplication, NSEvent, NSEventModifierFlags, NSEventType, NSResponder};
 use objc2_foundation::{MainThreadMarker, NSObject};

-use super::app_delegate::ApplicationDelegate;
-use super::event::flags_contains;
+use super::app_state::ApplicationDelegate;
+use super::DEVICE_ID;
 use crate::event::{DeviceEvent, ElementState};

 declare_class!(
@@ -32,7 +32,7 @@ declare_class!(
            let event_type = unsafe { event.r#type() };
            let modifier_flags = unsafe { event.modifierFlags() };
            if event_type == NSEventType::KeyUp
-                && flags_contains(modifier_flags, NSEventModifierFlags::NSEventModifierFlagCommand)
+                && modifier_flags.contains(NSEventModifierFlags::NSEventModifierFlagCommand)
            {
                if let Some(key_window) = self.keyWindow() {
                    key_window.sendEvent(event);
@@ -58,27 +58,47 @@ fn maybe_dispatch_device_event(delegate: &ApplicationDelegate, event: &NSEvent)
            let delta_y = unsafe { event.deltaY() } as f64;

            if delta_x != 0.0 {
-                delegate.queue_device_event(DeviceEvent::Motion { axis: 0, value: delta_x });
+                delegate.maybe_queue_with_handler(move |app, event_loop| {
+                    app.device_event(event_loop, DEVICE_ID, DeviceEvent::Motion {
+                        axis: 0,
+                        value: delta_x,
+                    });
+                });
            }

            if delta_y != 0.0 {
-                delegate.queue_device_event(DeviceEvent::Motion { axis: 1, value: delta_y })
+                delegate.maybe_queue_with_handler(move |app, event_loop| {
+                    app.device_event(event_loop, DEVICE_ID, DeviceEvent::Motion {
+                        axis: 1,
+                        value: delta_y,
+                    });
+                })
            }

            if delta_x != 0.0 || delta_y != 0.0 {
-                delegate.queue_device_event(DeviceEvent::MouseMotion { delta: (delta_x, delta_y) });
+                delegate.maybe_queue_with_handler(move |app, event_loop| {
+                    app.device_event(event_loop, DEVICE_ID, DeviceEvent::MouseMotion {
+                        delta: (delta_x, delta_y),
+                    });
+                });
            }
        },
        NSEventType::LeftMouseDown | NSEventType::RightMouseDown | NSEventType::OtherMouseDown => {
-            delegate.queue_device_event(DeviceEvent::Button {
-                button: unsafe { event.buttonNumber() } as u32,
-                state: ElementState::Pressed,
+            let button = unsafe { event.buttonNumber() } as u32;
+            delegate.maybe_queue_with_handler(move |app, event_loop| {
+                app.device_event(event_loop, DEVICE_ID, DeviceEvent::Button {
+                    button,
+                    state: ElementState::Pressed,
+                });
            });
        },
        NSEventType::LeftMouseUp | NSEventType::RightMouseUp | NSEventType::OtherMouseUp => {
-            delegate.queue_device_event(DeviceEvent::Button {
-                button: unsafe { event.buttonNumber() } as u32,
-                state: ElementState::Released,
+            let button = unsafe { event.buttonNumber() } as u32;
+            delegate.maybe_queue_with_handler(move |app, event_loop| {
+                app.device_event(event_loop, DEVICE_ID, DeviceEvent::Button {
+                    button,
+                    state: ElementState::Released,
+                });
            });
        },
        _ => (),
--- a/src/platform_impl/apple/appkit/app_state.rs
+++ b/src/platform_impl/apple/appkit/app_state.rs
@@ -1,40 +1,32 @@
 use std::cell::{Cell, RefCell};
-use std::collections::VecDeque;
 use std::mem;
 use std::rc::Weak;
-use std::sync::{Arc, Mutex};
+use std::sync::atomic::{AtomicBool, Ordering as AtomicOrdering};
+use std::sync::Arc;
 use std::time::Instant;

-use objc2::rc::Id;
-use objc2::runtime::AnyObject;
+use objc2::rc::Retained;
 use objc2::{declare_class, msg_send_id, mutability, ClassType, DeclaredClass};
 use objc2_app_kit::{NSApplication, NSApplicationActivationPolicy, NSApplicationDelegate};
-use objc2_foundation::{MainThreadMarker, NSObject, NSObjectProtocol, NSSize};
+use objc2_foundation::{MainThreadMarker, NSNotification, NSObject, NSObjectProtocol};
+
+use crate::application::ApplicationHandler;
+use crate::event::{StartCause, WindowEvent};
+use crate::event_loop::{ActiveEventLoop as RootActiveEventLoop, ControlFlow};
+use crate::window::WindowId as RootWindowId;

 use super::event_handler::EventHandler;
 use super::event_loop::{stop_app_immediately, ActiveEventLoop, PanicInfo};
 use super::observer::{EventLoopWaker, RunLoop};
-use super::window::WinitWindow;
-use super::{menu, WindowId, DEVICE_ID};
-use crate::dpi::PhysicalSize;
-use crate::event::{DeviceEvent, Event, InnerSizeWriter, StartCause, WindowEvent};
-use crate::event_loop::{ActiveEventLoop as RootActiveEventLoop, ControlFlow};
-use crate::window::WindowId as RootWindowId;
+use super::{menu, WindowId};

 #[derive(Debug)]
-struct Policy(NSApplicationActivationPolicy);
-
-impl Default for Policy {
-    fn default() -> Self {
-        Self(NSApplicationActivationPolicy::Regular)
-    }
-}
-
-#[derive(Debug, Default)]
-pub(super) struct State {
-    activation_policy: Policy,
+pub(super) struct AppState {
+    activation_policy: NSApplicationActivationPolicy,
    default_menu: bool,
    activate_ignoring_other_apps: bool,
+    run_loop: RunLoop,
+    proxy_wake_up: Arc<AtomicBool>,
    event_handler: EventHandler,
    stop_on_launch: Cell<bool>,
    stop_before_wait: Cell<bool>,
@@ -50,8 +42,9 @@ pub(super) struct State {
    waker: RefCell<EventLoopWaker>,
    start_time: Cell<Option<Instant>>,
    wait_timeout: Cell<Option<Instant>>,
-    pending_events: RefCell<VecDeque<QueuedEvent>>,
    pending_redraw: RefCell<Vec<WindowId>>,
+    // NOTE: This is strongly referenced by our `NSWindowDelegate` and our `NSView` subclass, and
+    // as such should be careful to not add fields that, in turn, strongly reference those.
 }

 declare_class!(
@@ -65,62 +58,20 @@ declare_class!(
    }

    impl DeclaredClass for ApplicationDelegate {
-        type Ivars = State;
+        type Ivars = AppState;
    }

    unsafe impl NSObjectProtocol for ApplicationDelegate {}

    unsafe impl NSApplicationDelegate for ApplicationDelegate {
-        // Note: This will, globally, only be run once, no matter how many
-        // `EventLoop`s the user creates.
        #[method(applicationDidFinishLaunching:)]
-        fn did_finish_launching(&self, _sender: Option<&AnyObject>) {
-            trace_scope!("applicationDidFinishLaunching:");
-            self.ivars().is_launched.set(true);
-
-            let mtm = MainThreadMarker::from(self);
-            let app = NSApplication::sharedApplication(mtm);
-            // We need to delay setting the activation policy and activating the app
-            // until `applicationDidFinishLaunching` has been called. Otherwise the
-            // menu bar is initially unresponsive on macOS 10.15.
-            app.setActivationPolicy(self.ivars().activation_policy.0);
-
-            window_activation_hack(&app);
-            #[allow(deprecated)]
-            app.activateIgnoringOtherApps(self.ivars().activate_ignoring_other_apps);
-
-            if self.ivars().default_menu {
-                // The menubar initialization should be before the `NewEvents` event, to allow
-                // overriding of the default menu even if it's created
-                menu::initialize(&app);
-            }
-
-            self.ivars().waker.borrow_mut().start();
-
-            self.set_is_running(true);
-            self.dispatch_init_events();
-
-            // If the application is being launched via `EventLoop::pump_app_events()` then we'll
-            // want to stop the app once it is launched (and return to the external loop)
-            //
-            // In this case we still want to consider Winit's `EventLoop` to be "running",
-            // so we call `start_running()` above.
-            if self.ivars().stop_on_launch.get() {
-                // Note: the original idea had been to only stop the underlying `RunLoop`
-                // for the app but that didn't work as expected (`-[NSApplication run]`
-                // effectively ignored the attempt to stop the RunLoop and re-started it).
-                //
-                // So we return from `pump_events` by stopping the application.
-                let app = NSApplication::sharedApplication(mtm);
-                stop_app_immediately(&app);
-            }
+        fn app_did_finish_launching(&self, notification: &NSNotification) {
+            self.did_finish_launching(notification)
        }

        #[method(applicationWillTerminate:)]
-        fn will_terminate(&self, _sender: Option<&AnyObject>) {
-            trace_scope!("applicationWillTerminate:");
-            // TODO: Notify every window that it will be destroyed, like done in iOS?
-            self.internal_exit();
+        fn app_will_terminate(&self, notification: &NSNotification) {
+            self.will_terminate(notification)
        }
    }
 );
@@ -129,25 +80,90 @@ impl ApplicationDelegate {
    pub(super) fn new(
        mtm: MainThreadMarker,
        activation_policy: NSApplicationActivationPolicy,
+        proxy_wake_up: Arc<AtomicBool>,
        default_menu: bool,
        activate_ignoring_other_apps: bool,
-    ) -> Id<Self> {
-        let this = mtm.alloc().set_ivars(State {
-            activation_policy: Policy(activation_policy),
+    ) -> Retained<Self> {
+        let this = mtm.alloc().set_ivars(AppState {
+            activation_policy,
+            proxy_wake_up,
            default_menu,
            activate_ignoring_other_apps,
-            ..Default::default()
+            run_loop: RunLoop::main(mtm),
+            event_handler: EventHandler::new(),
+            stop_on_launch: Cell::new(false),
+            stop_before_wait: Cell::new(false),
+            stop_after_wait: Cell::new(false),
+            stop_on_redraw: Cell::new(false),
+            is_launched: Cell::new(false),
+            is_running: Cell::new(false),
+            exit: Cell::new(false),
+            control_flow: Cell::new(ControlFlow::default()),
+            waker: RefCell::new(EventLoopWaker::new()),
+            start_time: Cell::new(None),
+            wait_timeout: Cell::new(None),
+            pending_redraw: RefCell::new(vec![]),
        });
        unsafe { msg_send_id![super(this), init] }
    }

-    pub fn get(mtm: MainThreadMarker) -> Id<Self> {
+    // NOTE: This will, globally, only be run once, no matter how many
+    // `EventLoop`s the user creates.
+    fn did_finish_launching(&self, _notification: &NSNotification) {
+        trace_scope!("applicationDidFinishLaunching:");
+        self.ivars().is_launched.set(true);
+
+        let mtm = MainThreadMarker::from(self);
+        let app = NSApplication::sharedApplication(mtm);
+        // We need to delay setting the activation policy and activating the app
+        // until `applicationDidFinishLaunching` has been called. Otherwise the
+        // menu bar is initially unresponsive on macOS 10.15.
+        app.setActivationPolicy(self.ivars().activation_policy);
+
+        window_activation_hack(&app);
+        #[allow(deprecated)]
+        app.activateIgnoringOtherApps(self.ivars().activate_ignoring_other_apps);
+
+        if self.ivars().default_menu {
+            // The menubar initialization should be before the `NewEvents` event, to allow
+            // overriding of the default menu even if it's created
+            menu::initialize(&app);
+        }
+
+        self.ivars().waker.borrow_mut().start();
+
+        self.set_is_running(true);
+        self.dispatch_init_events();
+
+        // If the application is being launched via `EventLoop::pump_app_events()` then we'll
+        // want to stop the app once it is launched (and return to the external loop)
+        //
+        // In this case we still want to consider Winit's `EventLoop` to be "running",
+        // so we call `start_running()` above.
+        if self.ivars().stop_on_launch.get() {
+            // NOTE: the original idea had been to only stop the underlying `RunLoop`
+            // for the app but that didn't work as expected (`-[NSApplication run]`
+            // effectively ignored the attempt to stop the RunLoop and re-started it).
+            //
+            // So we return from `pump_events` by stopping the application.
+            let app = NSApplication::sharedApplication(mtm);
+            stop_app_immediately(&app);
+        }
+    }
+
+    fn will_terminate(&self, _notification: &NSNotification) {
+        trace_scope!("applicationWillTerminate:");
+        // TODO: Notify every window that it will be destroyed, like done in iOS?
+        self.internal_exit();
+    }
+
+    pub fn get(mtm: MainThreadMarker) -> Retained<Self> {
        let app = NSApplication::sharedApplication(mtm);
        let delegate =
            unsafe { app.delegate() }.expect("a delegate was not configured on the application");
        if delegate.is_kind_of::<Self>() {
            // SAFETY: Just checked that the delegate is an instance of `ApplicationDelegate`
-            unsafe { Id::cast(delegate) }
+            unsafe { Retained::cast(delegate) }
        } else {
            panic!("tried to get a delegate that was not the one Winit has registered")
        }
@@ -157,7 +173,7 @@ impl ApplicationDelegate {
    /// of the given closure.
    pub fn set_event_handler<R>(
        &self,
-        handler: impl FnMut(Event<HandlePendingUserEvents>, &RootActiveEventLoop),
+        handler: &mut dyn ApplicationHandler,
        closure: impl FnOnce() -> R,
    ) -> R {
        self.ivars().event_handler.set(handler, closure)
@@ -188,10 +204,12 @@ impl ApplicationDelegate {

    /// Clears the `running` state and resets the `control_flow` state when an `EventLoop` exits.
    ///
-    /// Note: that if the `NSApplication` has been launched then that state is preserved,
+    /// NOTE: that if the `NSApplication` has been launched then that state is preserved,
    /// and we won't need to re-launch the app if subsequent EventLoops are run.
    pub fn internal_exit(&self) {
-        self.handle_event(Event::LoopExiting);
+        self.with_handler(|app, event_loop| {
+            app.exiting(event_loop);
+        });

        self.set_is_running(false);
        self.set_stop_on_redraw(false);
@@ -232,38 +250,13 @@ impl ApplicationDelegate {
        self.ivars().control_flow.get()
    }

-    pub fn queue_window_event(&self, window_id: WindowId, event: WindowEvent) {
-        self.ivars()
-            .pending_events
-            .borrow_mut()
-            .push_back(QueuedEvent::WindowEvent(window_id, event));
-    }
-
-    pub fn queue_device_event(&self, event: DeviceEvent) {
-        self.ivars().pending_events.borrow_mut().push_back(QueuedEvent::DeviceEvent(event));
-    }
-
-    pub fn queue_static_scale_factor_changed_event(
-        &self,
-        window: Id<WinitWindow>,
-        suggested_size: PhysicalSize<u32>,
-        scale_factor: f64,
-    ) {
-        self.ivars().pending_events.borrow_mut().push_back(QueuedEvent::ScaleFactorChanged {
-            window,
-            suggested_size,
-            scale_factor,
-        });
-    }
-
    pub fn handle_redraw(&self, window_id: WindowId) {
        let mtm = MainThreadMarker::from(self);
        // Redraw request might come out of order from the OS.
        // -> Don't go back into the event handler when our callstack originates from there
        if !self.ivars().event_handler.in_use() {
-            self.handle_event(Event::WindowEvent {
-                window_id: RootWindowId(window_id),
-                event: WindowEvent::RedrawRequested,
+            self.with_handler(|app, event_loop| {
+                app.window_event(event_loop, RootWindowId(window_id), WindowEvent::RedrawRequested);
            });

            // `pump_events` will request to stop immediately _after_ dispatching RedrawRequested
@@ -281,19 +274,46 @@ impl ApplicationDelegate {
        if !pending_redraw.contains(&window_id) {
            pending_redraw.push(window_id);
        }
-        unsafe { RunLoop::get() }.wakeup();
+        self.ivars().run_loop.wakeup();
    }

-    fn handle_event(&self, event: Event<HandlePendingUserEvents>) {
-        self.ivars().event_handler.handle_event(event, &ActiveEventLoop::new_root(self.retain()))
+    #[track_caller]
+    pub fn maybe_queue_with_handler(
+        &self,
+        callback: impl FnOnce(&mut dyn ApplicationHandler, &RootActiveEventLoop) + 'static,
+    ) {
+        // Most programmer actions in AppKit (e.g. change window fullscreen, set focused, etc.)
+        // result in an event being queued, and applied at a later point.
+        //
+        // However, it is not documented which actions do this, and which ones are done immediately,
+        // so to make sure that we don't encounter re-entrancy issues, we first check if we're
+        // currently handling another event, and if we are, we queue the event instead.
+        if !self.ivars().event_handler.in_use() {
+            self.with_handler(callback);
+        } else {
+            tracing::debug!("had to queue event since another is currently being handled");
+            let this = self.retain();
+            self.ivars().run_loop.queue_closure(move || {
+                this.with_handler(callback);
+            });
+        }
+    }
+
+    #[track_caller]
+    fn with_handler(
+        &self,
+        callback: impl FnOnce(&mut dyn ApplicationHandler, &RootActiveEventLoop),
+    ) {
+        let event_loop = ActiveEventLoop::new_root(self.retain());
+        self.ivars().event_handler.handle(callback, &event_loop);
    }

    /// dispatch `NewEvents(Init)` + `Resumed`
    pub fn dispatch_init_events(&self) {
-        self.handle_event(Event::NewEvents(StartCause::Init));
+        self.with_handler(|app, event_loop| app.new_events(event_loop, StartCause::Init));
        // NB: For consistency all platforms must emit a 'resumed' event even though macOS
        // applications don't themselves have a formal suspend/resume lifecycle.
-        self.handle_event(Event::Resumed);
+        self.with_handler(|app, event_loop| app.resumed(event_loop));
    }

    // Called by RunLoopObserver after finishing waiting for new events
@@ -303,8 +323,7 @@ impl ApplicationDelegate {
            .upgrade()
            .expect("The panic info must exist here. This failure indicates a developer error.");

-        // Return when in event handler due to https://github.com/rust-windowing/winit/issues/1779
-        if panic_info.is_panicking() || !self.ivars().event_handler.ready() || !self.is_running() {
+        if panic_info.is_panicking() || !self.is_running() {
            return;
        }

@@ -326,7 +345,7 @@ impl ApplicationDelegate {
            },
        };

-        self.handle_event(Event::NewEvents(cause));
+        self.with_handler(|app, event_loop| app.new_events(event_loop, cause));
    }

    // Called by RunLoopObserver before waiting for new events
@@ -336,65 +355,23 @@ impl ApplicationDelegate {
            .upgrade()
            .expect("The panic info must exist here. This failure indicates a developer error.");

-        // Return when in event handler due to https://github.com/rust-windowing/winit/issues/1779
-        // XXX: how does it make sense that `event_handler.ready()` can ever return `false` here if
-        // we're about to return to the `CFRunLoop` to poll for new events?
-        if panic_info.is_panicking() || !self.ivars().event_handler.ready() || !self.is_running() {
+        if panic_info.is_panicking() || !self.is_running() {
            return;
        }

-        self.handle_event(Event::UserEvent(HandlePendingUserEvents));
-
-        let events = mem::take(&mut *self.ivars().pending_events.borrow_mut());
-        for event in events {
-            match event {
-                QueuedEvent::WindowEvent(window_id, event) => {
-                    self.handle_event(Event::WindowEvent {
-                        window_id: RootWindowId(window_id),
-                        event,
-                    });
-                },
-                QueuedEvent::DeviceEvent(event) => {
-                    self.handle_event(Event::DeviceEvent { device_id: DEVICE_ID, event });
-                },
-                QueuedEvent::ScaleFactorChanged { window, suggested_size, scale_factor } => {
-                    let new_inner_size = Arc::new(Mutex::new(suggested_size));
-                    let scale_factor_changed_event = Event::WindowEvent {
-                        window_id: RootWindowId(window.id()),
-                        event: WindowEvent::ScaleFactorChanged {
-                            scale_factor,
-                            inner_size_writer: InnerSizeWriter::new(Arc::downgrade(
-                                &new_inner_size,
-                            )),
-                        },
-                    };
-
-                    self.handle_event(scale_factor_changed_event);
-
-                    let physical_size = *new_inner_size.lock().unwrap();
-                    drop(new_inner_size);
-                    let logical_size = physical_size.to_logical(scale_factor);
-                    let size = NSSize::new(logical_size.width, logical_size.height);
-                    window.setContentSize(size);
-
-                    let resized_event = Event::WindowEvent {
-                        window_id: RootWindowId(window.id()),
-                        event: WindowEvent::Resized(physical_size),
-                    };
-                    self.handle_event(resized_event);
-                },
-            }
+        if self.ivars().proxy_wake_up.swap(false, AtomicOrdering::Relaxed) {
+            self.with_handler(|app, event_loop| app.proxy_wake_up(event_loop));
        }

        let redraw = mem::take(&mut *self.ivars().pending_redraw.borrow_mut());
        for window_id in redraw {
-            self.handle_event(Event::WindowEvent {
-                window_id: RootWindowId(window_id),
-                event: WindowEvent::RedrawRequested,
+            self.with_handler(|app, event_loop| {
+                app.window_event(event_loop, RootWindowId(window_id), WindowEvent::RedrawRequested);
            });
        }
-
-        self.handle_event(Event::AboutToWait);
+        self.with_handler(|app, event_loop| {
+            app.about_to_wait(event_loop);
+        });

        if self.exiting() {
            let app = NSApplication::sharedApplication(mtm);
@@ -416,20 +393,6 @@ impl ApplicationDelegate {
    }
 }

-#[derive(Debug)]
-pub(crate) enum QueuedEvent {
-    WindowEvent(WindowId, WindowEvent),
-    DeviceEvent(DeviceEvent),
-    ScaleFactorChanged {
-        window: Id<WinitWindow>,
-        suggested_size: PhysicalSize<u32>,
-        scale_factor: f64,
-    },
-}
-
-#[derive(Debug)]
-pub(crate) struct HandlePendingUserEvents;
-
 /// Returns the minimum `Option<Instant>`, taking into account that `None`
 /// equates to an infinite timeout, not a zero timeout (so can't just use
 /// `Option::min`)
--- a/src/platform_impl/apple/appkit/cursor.rs
+++ b/src/platform_impl/apple/appkit/cursor.rs
@@ -2,7 +2,7 @@ use std::ffi::c_uchar;
 use std::slice;
 use std::sync::OnceLock;

-use objc2::rc::Id;
+use objc2::rc::Retained;
 use objc2::runtime::Sel;
 use objc2::{msg_send_id, sel, ClassType};
 use objc2_app_kit::{NSBitmapImageRep, NSCursor, NSDeviceRGBColorSpace, NSImage};
@@ -15,7 +15,7 @@ use crate::cursor::{CursorImage, OnlyCursorImageSource};
 use crate::window::CursorIcon;

 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
-pub struct CustomCursor(pub(crate) Id<NSCursor>);
+pub struct CustomCursor(pub(crate) Retained<NSCursor>);

 // SAFETY: NSCursor is immutable and thread-safe
 // TODO(madsmtm): Put this logic in objc2-app-kit itself
@@ -28,7 +28,7 @@ impl CustomCursor {
    }
 }

-pub(crate) fn cursor_from_image(cursor: &CursorImage) -> Id<NSCursor> {
+pub(crate) fn cursor_from_image(cursor: &CursorImage) -> Retained<NSCursor> {
    let width = cursor.width;
    let height = cursor.height;

@@ -60,14 +60,14 @@ pub(crate) fn cursor_from_image(cursor: &CursorImage) -> Id<NSCursor> {
    NSCursor::initWithImage_hotSpot(NSCursor::alloc(), &image, hotspot)
 }

-pub(crate) fn default_cursor() -> Id<NSCursor> {
+pub(crate) fn default_cursor() -> Retained<NSCursor> {
    NSCursor::arrowCursor()
 }

-unsafe fn try_cursor_from_selector(sel: Sel) -> Option<Id<NSCursor>> {
+unsafe fn try_cursor_from_selector(sel: Sel) -> Option<Retained<NSCursor>> {
    let cls = NSCursor::class();
    if cls.responds_to(sel) {
-        let cursor: Id<NSCursor> = unsafe { msg_send_id![cls, performSelector: sel] };
+        let cursor: Retained<NSCursor> = unsafe { msg_send_id![cls, performSelector: sel] };
        Some(cursor)
    } else {
        tracing::warn!("cursor `{sel}` appears to be invalid");
@@ -82,7 +82,7 @@ macro_rules! def_undocumented_cursor {
    )*} => {$(
        $(#[$($m)*])*
        #[allow(non_snake_case)]
-        fn $name() -> Id<NSCursor> {
+        fn $name() -> Retained<NSCursor> {
            unsafe { try_cursor_from_selector(sel!($name)).unwrap_or_else(|| default_cursor()) }
        }
    )*};
@@ -112,7 +112,7 @@ def_undocumented_cursor!(

 // Note that loading `busybutclickable` with this code won't animate
 // the frames; instead you'll just get them all in a column.
-unsafe fn load_webkit_cursor(name: &NSString) -> Id<NSCursor> {
+unsafe fn load_webkit_cursor(name: &NSString) -> Retained<NSCursor> {
    // Snatch a cursor from WebKit; They fit the style of the native
    // cursors, and will seem completely standard to macOS users.
    //
@@ -128,7 +128,7 @@ unsafe fn load_webkit_cursor(name: &NSString) -> Id<NSCursor> {

    // TODO: Handle PLists better
    let info_path = cursor_path.stringByAppendingPathComponent(ns_string!("info.plist"));
-    let info: Id<NSDictionary<NSObject, NSObject>> = unsafe {
+    let info: Retained<NSDictionary<NSObject, NSObject>> = unsafe {
        msg_send_id![
            <NSDictionary<NSObject, NSObject>>::class(),
            dictionaryWithContentsOfFile: &*info_path,
@@ -155,15 +155,15 @@ unsafe fn load_webkit_cursor(name: &NSString) -> Id<NSCursor> {
    NSCursor::initWithImage_hotSpot(NSCursor::alloc(), &image, hotspot)
 }

-fn webkit_move() -> Id<NSCursor> {
+fn webkit_move() -> Retained<NSCursor> {
    unsafe { load_webkit_cursor(ns_string!("move")) }
 }

-fn webkit_cell() -> Id<NSCursor> {
+fn webkit_cell() -> Retained<NSCursor> {
    unsafe { load_webkit_cursor(ns_string!("cell")) }
 }

-pub(crate) fn invisible_cursor() -> Id<NSCursor> {
+pub(crate) fn invisible_cursor() -> Retained<NSCursor> {
    // 16x16 GIF data for invisible cursor
    // You can reproduce this via ImageMagick.
    // $ convert -size 16x16 xc:none cursor.gif
@@ -174,7 +174,7 @@ pub(crate) fn invisible_cursor() -> Id<NSCursor> {
        0xa3, 0x9c, 0xb4, 0xda, 0x8b, 0xb3, 0x3e, 0x05, 0x00, 0x3b,
    ];

-    fn new_invisible() -> Id<NSCursor> {
+    fn new_invisible() -> Retained<NSCursor> {
        // TODO: Consider using `dataWithBytesNoCopy:`
        let data = NSData::with_bytes(CURSOR_BYTES);
        let image = NSImage::initWithData(NSImage::alloc(), &data).unwrap();
@@ -187,7 +187,7 @@ pub(crate) fn invisible_cursor() -> Id<NSCursor> {
    CURSOR.get_or_init(|| CustomCursor(new_invisible())).0.clone()
 }

-pub(crate) fn cursor_from_icon(icon: CursorIcon) -> Id<NSCursor> {
+pub(crate) fn cursor_from_icon(icon: CursorIcon) -> Retained<NSCursor> {
    match icon {
        CursorIcon::Default => default_cursor(),
        CursorIcon::Pointer => NSCursor::pointingHandCursor(),
--- a/src/platform_impl/apple/appkit/event.rs
+++ b/src/platform_impl/apple/appkit/event.rs
@@ -2,17 +2,17 @@ use std::ffi::c_void;

 use core_foundation::base::CFRelease;
 use core_foundation::data::{CFDataGetBytePtr, CFDataRef};
-use objc2::rc::Id;
+use objc2::rc::Retained;
 use objc2_app_kit::{NSEvent, NSEventModifierFlags, NSEventSubtype, NSEventType};
 use objc2_foundation::{run_on_main, NSPoint};
 use smol_str::SmolStr;

+use super::ffi;
 use crate::event::{ElementState, KeyEvent, Modifiers};
 use crate::keyboard::{
    Key, KeyCode, KeyLocation, ModifiersKeys, ModifiersState, NamedKey, NativeKey, NativeKeyCode,
    PhysicalKey,
 };
-use crate::platform_impl::platform::ffi;

 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct KeyEventExtra {
@@ -133,8 +133,8 @@ pub(crate) fn create_key_event(
        let key_without_modifiers = get_modifierless_char(scancode);

        let modifiers = unsafe { ns_event.modifierFlags() };
-        let has_ctrl = flags_contains(modifiers, NSEventModifierFlags::NSEventModifierFlagControl);
-        let has_cmd = flags_contains(modifiers, NSEventModifierFlags::NSEventModifierFlagCommand);
+        let has_ctrl = modifiers.contains(NSEventModifierFlags::NSEventModifierFlagControl);
+        let has_cmd = modifiers.contains(NSEventModifierFlags::NSEventModifierFlagCommand);

        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
@@ -305,16 +305,12 @@ const NX_DEVICELALTKEYMASK: NSEventModifierFlags = NSEventModifierFlags(0x000000
 const NX_DEVICERALTKEYMASK: NSEventModifierFlags = NSEventModifierFlags(0x00000040);
 const NX_DEVICERCTLKEYMASK: NSEventModifierFlags = NSEventModifierFlags(0x00002000);

-pub(super) fn flags_contains(flags: NSEventModifierFlags, value: NSEventModifierFlags) -> bool {
-    flags.0 & value.0 == value.0
-}
-
 pub(super) fn lalt_pressed(event: &NSEvent) -> bool {
-    flags_contains(unsafe { event.modifierFlags() }, NX_DEVICELALTKEYMASK)
+    unsafe { event.modifierFlags() }.contains(NX_DEVICELALTKEYMASK)
 }

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

 pub(super) fn event_mods(event: &NSEvent) -> Modifiers {
@@ -322,38 +318,33 @@ pub(super) fn event_mods(event: &NSEvent) -> Modifiers {
    let mut state = ModifiersState::empty();
    let mut pressed_mods = ModifiersKeys::empty();

-    state.set(
-        ModifiersState::SHIFT,
-        flags_contains(flags, NSEventModifierFlags::NSEventModifierFlagShift),
-    );
-    pressed_mods.set(ModifiersKeys::LSHIFT, flags_contains(flags, NX_DEVICELSHIFTKEYMASK));
-    pressed_mods.set(ModifiersKeys::RSHIFT, flags_contains(flags, NX_DEVICERSHIFTKEYMASK));
+    state
+        .set(ModifiersState::SHIFT, flags.contains(NSEventModifierFlags::NSEventModifierFlagShift));
+    pressed_mods.set(ModifiersKeys::LSHIFT, flags.contains(NX_DEVICELSHIFTKEYMASK));
+    pressed_mods.set(ModifiersKeys::RSHIFT, flags.contains(NX_DEVICERSHIFTKEYMASK));

    state.set(
        ModifiersState::CONTROL,
-        flags_contains(flags, NSEventModifierFlags::NSEventModifierFlagControl),
+        flags.contains(NSEventModifierFlags::NSEventModifierFlagControl),
    );
-    pressed_mods.set(ModifiersKeys::LCONTROL, flags_contains(flags, NX_DEVICELCTLKEYMASK));
-    pressed_mods.set(ModifiersKeys::RCONTROL, flags_contains(flags, NX_DEVICERCTLKEYMASK));
+    pressed_mods.set(ModifiersKeys::LCONTROL, flags.contains(NX_DEVICELCTLKEYMASK));
+    pressed_mods.set(ModifiersKeys::RCONTROL, flags.contains(NX_DEVICERCTLKEYMASK));

-    state.set(
-        ModifiersState::ALT,
-        flags_contains(flags, NSEventModifierFlags::NSEventModifierFlagOption),
-    );
-    pressed_mods.set(ModifiersKeys::LALT, flags_contains(flags, NX_DEVICELALTKEYMASK));
-    pressed_mods.set(ModifiersKeys::RALT, flags_contains(flags, NX_DEVICERALTKEYMASK));
+    state.set(ModifiersState::ALT, flags.contains(NSEventModifierFlags::NSEventModifierFlagOption));
+    pressed_mods.set(ModifiersKeys::LALT, flags.contains(NX_DEVICELALTKEYMASK));
+    pressed_mods.set(ModifiersKeys::RALT, flags.contains(NX_DEVICERALTKEYMASK));

    state.set(
        ModifiersState::SUPER,
-        flags_contains(flags, NSEventModifierFlags::NSEventModifierFlagCommand),
+        flags.contains(NSEventModifierFlags::NSEventModifierFlagCommand),
    );
-    pressed_mods.set(ModifiersKeys::LSUPER, flags_contains(flags, NX_DEVICELCMDKEYMASK));
-    pressed_mods.set(ModifiersKeys::RSUPER, flags_contains(flags, NX_DEVICERCMDKEYMASK));
+    pressed_mods.set(ModifiersKeys::LSUPER, flags.contains(NX_DEVICELCMDKEYMASK));
+    pressed_mods.set(ModifiersKeys::RSUPER, flags.contains(NX_DEVICERCMDKEYMASK));

    Modifiers { state, pressed_mods }
 }

-pub(super) fn dummy_event() -> Option<Id<NSEvent>> {
+pub(super) fn dummy_event() -> Option<Retained<NSEvent>> {
    unsafe {
        NSEvent::otherEventWithType_location_modifierFlags_timestamp_windowNumber_context_subtype_data1_data2(
            NSEventType::ApplicationDefined,
--- a/src/platform_impl/apple/appkit/event_handler.rs
+++ b/src/platform_impl/apple/appkit/event_handler.rs
@@ -1,31 +1,34 @@
 use std::cell::RefCell;
 use std::{fmt, mem};

-use super::app_delegate::HandlePendingUserEvents;
-use crate::event::Event;
+use crate::application::ApplicationHandler;
 use crate::event_loop::ActiveEventLoop as RootActiveEventLoop;

-struct EventHandlerData {
-    #[allow(clippy::type_complexity)]
-    handler: Box<dyn FnMut(Event<HandlePendingUserEvents>, &RootActiveEventLoop) + 'static>,
-}
-
-impl fmt::Debug for EventHandlerData {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("EventHandlerData").finish_non_exhaustive()
-    }
-}
-
-#[derive(Debug, Default)]
+#[derive(Default)]
 pub(crate) struct EventHandler {
    /// This can be in the following states:
    /// - Not registered by the event loop (None).
    /// - Present (Some(handler)).
    /// - Currently executing the handler / in use (RefCell borrowed).
-    inner: RefCell<Option<EventHandlerData>>,
+    inner: RefCell<Option<&'static mut dyn ApplicationHandler>>,
+}
+
+impl fmt::Debug for EventHandler {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let state = match self.inner.try_borrow().as_deref() {
+            Ok(Some(_)) => "<available>",
+            Ok(None) => "<not set>",
+            Err(_) => "<in use>",
+        };
+        f.debug_struct("EventHandler").field("state", &state).finish_non_exhaustive()
+    }
 }

 impl EventHandler {
+    pub(crate) fn new() -> Self {
+        Self { inner: RefCell::new(None) }
+    }
+
    /// Set the event loop handler for the duration of the given closure.
    ///
    /// This is similar to using the `scoped-tls` or `scoped-tls-hkt` crates
@@ -33,7 +36,7 @@ impl EventHandler {
    /// from within the closure.
    pub(crate) fn set<'handler, R>(
        &self,
-        handler: impl FnMut(Event<HandlePendingUserEvents>, &RootActiveEventLoop) + 'handler,
+        app: &'handler mut dyn ApplicationHandler,
        closure: impl FnOnce() -> R,
    ) -> R {
        // SAFETY: We extend the lifetime of the handler here so that we can
@@ -44,9 +47,9 @@ impl EventHandler {
        // extended beyond `'handler`.
        let handler = unsafe {
            mem::transmute::<
-                Box<dyn FnMut(Event<HandlePendingUserEvents>, &RootActiveEventLoop) + 'handler>,
-                Box<dyn FnMut(Event<HandlePendingUserEvents>, &RootActiveEventLoop) + 'static>,
-            >(Box::new(handler))
+                &'handler mut dyn ApplicationHandler,
+                &'static mut dyn ApplicationHandler,
+            >(app)
        };

        match self.inner.try_borrow_mut().as_deref_mut() {
@@ -54,7 +57,7 @@ impl EventHandler {
                unreachable!("tried to set handler while another was already set");
            },
            Ok(data @ None) => {
-                *data = Some(EventHandlerData { handler });
+                *data = Some(handler);
            },
            Err(_) => {
                unreachable!("tried to set handler that is currently in use");
@@ -101,24 +104,20 @@ impl EventHandler {
        self.inner.try_borrow().is_err()
    }

-    pub(crate) fn ready(&self) -> bool {
-        matches!(self.inner.try_borrow().as_deref(), Ok(Some(_)))
-    }
-
-    pub(crate) fn handle_event(
+    pub(crate) fn handle(
        &self,
-        event: Event<HandlePendingUserEvents>,
+        callback: impl FnOnce(&mut dyn ApplicationHandler, &RootActiveEventLoop),
        event_loop: &RootActiveEventLoop,
    ) {
        match self.inner.try_borrow_mut().as_deref_mut() {
-            Ok(Some(EventHandlerData { handler })) => {
+            Ok(Some(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.
                //
                // If the handler unwinds, the `RefMut` will ensure that the
                // handler is no longer borrowed.
-                (handler)(event, event_loop);
+                callback(*user_app, event_loop);
            },
            Ok(None) => {
                // `NSApplication`, our app delegate and this handler are all
--- a/src/platform_impl/apple/appkit/event_loop.rs
+++ b/src/platform_impl/apple/appkit/event_loop.rs
@@ -6,33 +6,32 @@ use std::os::raw::c_void;
 use std::panic::{catch_unwind, resume_unwind, RefUnwindSafe, UnwindSafe};
 use std::ptr;
 use std::rc::{Rc, Weak};
-use std::sync::mpsc;
+use std::sync::atomic::{AtomicBool, Ordering as AtomicOrdering};
+use std::sync::Arc;
 use std::time::{Duration, Instant};

 use core_foundation::base::{CFIndex, CFRelease};
 use core_foundation::runloop::{
-    kCFRunLoopCommonModes, CFRunLoopAddSource, CFRunLoopGetMain, CFRunLoopSourceContext,
+    kCFRunLoopDefaultMode, CFRunLoopAddSource, CFRunLoopGetMain, CFRunLoopSourceContext,
    CFRunLoopSourceCreate, CFRunLoopSourceRef, CFRunLoopSourceSignal, CFRunLoopWakeUp,
 };
-use objc2::rc::{autoreleasepool, Id};
+use objc2::rc::{autoreleasepool, Retained};
 use objc2::runtime::ProtocolObject;
 use objc2::{msg_send_id, ClassType};
 use objc2_app_kit::{NSApplication, NSApplicationActivationPolicy, NSWindow};
 use objc2_foundation::{MainThreadMarker, NSObjectProtocol};

 use super::app::WinitApplication;
-use super::app_delegate::{ApplicationDelegate, HandlePendingUserEvents};
+use super::app_state::ApplicationDelegate;
+use super::cursor::CustomCursor;
 use super::event::dummy_event;
 use super::monitor::{self, MonitorHandle};
 use super::observer::setup_control_flow_observers;
+use crate::application::ApplicationHandler;
 use crate::error::EventLoopError;
-use crate::event::Event;
-use crate::event_loop::{
-    ActiveEventLoop as RootWindowTarget, ControlFlow, DeviceEvents, EventLoopClosed,
-};
+use crate::event_loop::{ActiveEventLoop as RootWindowTarget, ControlFlow, DeviceEvents};
 use crate::platform::macos::ActivationPolicy;
 use crate::platform::pump_events::PumpStatus;
-use crate::platform_impl::platform::cursor::CustomCursor;
 use crate::window::{CustomCursor as RootCustomCursor, CustomCursorSource};

 #[derive(Default)]
@@ -67,17 +66,21 @@ impl PanicInfo {

 #[derive(Debug)]
 pub struct ActiveEventLoop {
-    delegate: Id<ApplicationDelegate>,
+    delegate: Retained<ApplicationDelegate>,
    pub(super) mtm: MainThreadMarker,
 }

 impl ActiveEventLoop {
-    pub(super) fn new_root(delegate: Id<ApplicationDelegate>) -> RootWindowTarget {
+    pub(super) fn new_root(delegate: Retained<ApplicationDelegate>) -> RootWindowTarget {
        let mtm = MainThreadMarker::from(&*delegate);
        let p = Self { delegate, mtm };
        RootWindowTarget { p, _marker: PhantomData }
    }

+    pub(super) fn app_delegate(&self) -> &ApplicationDelegate {
+        &self.delegate
+    }
+
    pub fn create_custom_cursor(&self, source: CustomCursorSource) -> RootCustomCursor {
        RootCustomCursor { inner: CustomCursor::new(source.inner) }
    }
@@ -133,9 +136,7 @@ impl ActiveEventLoop {
    pub(crate) fn owned_display_handle(&self) -> OwnedDisplayHandle {
        OwnedDisplayHandle
    }
-}

-impl ActiveEventLoop {
    pub(crate) fn hide_application(&self) {
        NSApplication::sharedApplication(self.mtm).hide(None)
    }
@@ -153,35 +154,19 @@ impl ActiveEventLoop {
    }
 }

-fn map_user_event<T: 'static>(
-    mut handler: impl FnMut(Event<T>, &RootWindowTarget),
-    receiver: Rc<mpsc::Receiver<T>>,
-) -> impl FnMut(Event<HandlePendingUserEvents>, &RootWindowTarget) {
-    move |event, window_target| match event.map_nonuser_event() {
-        Ok(event) => (handler)(event, window_target),
-        Err(_) => {
-            for event in receiver.try_iter() {
-                (handler)(Event::UserEvent(event), window_target);
-            }
-        },
-    }
-}
-
-pub struct EventLoop<T: 'static> {
+pub struct EventLoop {
    /// Store a reference to the application for convenience.
    ///
    /// We intentionally don't store `WinitApplication` since we want to have
    /// the possibility of swapping that out at some point.
-    app: Id<NSApplication>,
+    app: Retained<NSApplication>,
    /// The application delegate that we've registered.
    ///
    /// The delegate is only weakly referenced by NSApplication, so we must
    /// keep it around here as well.
-    delegate: Id<ApplicationDelegate>,
+    delegate: Retained<ApplicationDelegate>,

-    // Event sender and receiver, used for EventLoopProxy.
-    sender: mpsc::Sender<T>,
-    receiver: Rc<mpsc::Receiver<T>>,
+    proxy_wake_up: Arc<AtomicBool>,

    window_target: RootWindowTarget,
    panic_info: Rc<PanicInfo>,
@@ -204,14 +189,14 @@ impl Default for PlatformSpecificEventLoopAttributes {
    }
 }

-impl<T> EventLoop<T> {
+impl EventLoop {
    pub(crate) fn new(
        attributes: &PlatformSpecificEventLoopAttributes,
    ) -> Result<Self, EventLoopError> {
        let mtm = MainThreadMarker::new()
            .expect("on macOS, `EventLoop` must be created on the main thread!");

-        let app: Id<NSApplication> =
+        let app: Retained<NSApplication> =
            unsafe { msg_send_id![WinitApplication::class(), sharedApplication] };

        if !app.is_kind_of::<WinitApplication>() {
@@ -226,9 +211,13 @@ impl<T> EventLoop<T> {
            ActivationPolicy::Accessory => NSApplicationActivationPolicy::Accessory,
            ActivationPolicy::Prohibited => NSApplicationActivationPolicy::Prohibited,
        };
+
+        let proxy_wake_up = Arc::new(AtomicBool::new(false));
+
        let delegate = ApplicationDelegate::new(
            mtm,
            activation_policy,
+            proxy_wake_up.clone(),
            attributes.default_menu,
            attributes.activate_ignoring_other_apps,
        );
@@ -238,18 +227,16 @@ impl<T> EventLoop<T> {
        });

        let panic_info: Rc<PanicInfo> = Default::default();
-        setup_control_flow_observers(Rc::downgrade(&panic_info));
+        setup_control_flow_observers(mtm, Rc::downgrade(&panic_info));

-        let (sender, receiver) = mpsc::channel();
        Ok(EventLoop {
            app,
            delegate: delegate.clone(),
-            sender,
-            receiver: Rc::new(receiver),
            window_target: RootWindowTarget {
                p: ActiveEventLoop { delegate, mtm },
                _marker: PhantomData,
            },
+            proxy_wake_up,
            panic_info,
        })
    }
@@ -258,24 +245,19 @@ impl<T> EventLoop<T> {
        &self.window_target
    }

-    pub fn run<F>(mut self, handler: F) -> Result<(), EventLoopError>
-    where
-        F: FnMut(Event<T>, &RootWindowTarget),
-    {
-        self.run_on_demand(handler)
+    pub fn run_app<A: ApplicationHandler>(mut self, app: &mut 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
    // redundant wake ups.
-    pub fn run_on_demand<F>(&mut self, handler: F) -> Result<(), EventLoopError>
-    where
-        F: FnMut(Event<T>, &RootWindowTarget),
-    {
-        let handler = map_user_event(handler, self.receiver.clone());
-
-        self.delegate.set_event_handler(handler, || {
+    pub fn run_app_on_demand<A: ApplicationHandler>(
+        &mut self,
+        app: &mut A,
+    ) -> Result<(), EventLoopError> {
+        self.delegate.set_event_handler(app, || {
            autoreleasepool(|_| {
                // clear / normalize pump_events state
                self.delegate.set_wait_timeout(None);
@@ -308,13 +290,12 @@ impl<T> EventLoop<T> {
        Ok(())
    }

-    pub fn pump_events<F>(&mut self, timeout: Option<Duration>, handler: F) -> PumpStatus
-    where
-        F: FnMut(Event<T>, &RootWindowTarget),
-    {
-        let handler = map_user_event(handler, self.receiver.clone());
-
-        self.delegate.set_event_handler(handler, || {
+    pub fn pump_app_events<A: ApplicationHandler>(
+        &mut self,
+        timeout: Option<Duration>,
+        app: &mut A,
+    ) -> PumpStatus {
+        self.delegate.set_event_handler(app, || {
            autoreleasepool(|_| {
                // As a special case, if the application hasn't been launched yet then we at least
                // run the loop until it has fully launched.
@@ -378,8 +359,8 @@ impl<T> EventLoop<T> {
        })
    }

-    pub fn create_proxy(&self) -> EventLoopProxy<T> {
-        EventLoopProxy::new(self.sender.clone())
+    pub fn create_proxy(&self) -> EventLoopProxy {
+        EventLoopProxy::new(self.proxy_wake_up.clone())
    }
 }

@@ -437,15 +418,15 @@ pub fn stop_app_on_panic<F: FnOnce() -> R + UnwindSafe, R>(
    }
 }

-pub struct EventLoopProxy<T> {
-    sender: mpsc::Sender<T>,
+pub struct EventLoopProxy {
+    proxy_wake_up: Arc<AtomicBool>,
    source: CFRunLoopSourceRef,
 }

-unsafe impl<T: Send> Send for EventLoopProxy<T> {}
-unsafe impl<T: Send> Sync for EventLoopProxy<T> {}
+unsafe impl Send for EventLoopProxy {}
+unsafe impl Sync for EventLoopProxy {}

-impl<T> Drop for EventLoopProxy<T> {
+impl Drop for EventLoopProxy {
    fn drop(&mut self) {
        unsafe {
            CFRelease(self.source as _);
@@ -453,14 +434,14 @@ impl<T> Drop for EventLoopProxy<T> {
    }
 }

-impl<T> Clone for EventLoopProxy<T> {
+impl Clone for EventLoopProxy {
    fn clone(&self) -> Self {
-        EventLoopProxy::new(self.sender.clone())
+        EventLoopProxy::new(self.proxy_wake_up.clone())
    }
 }

-impl<T> EventLoopProxy<T> {
-    fn new(sender: mpsc::Sender<T>) -> Self {
+impl EventLoopProxy {
+    fn new(proxy_wake_up: Arc<AtomicBool>) -> Self {
        unsafe {
            // just wake up the eventloop
            extern "C" fn event_loop_proxy_handler(_: *const c_void) {}
@@ -480,23 +461,21 @@ impl<T> EventLoopProxy<T> {
                cancel: None,
                perform: event_loop_proxy_handler,
            };
-            let source =
-                CFRunLoopSourceCreate(ptr::null_mut(), CFIndex::max_value() - 1, &mut context);
-            CFRunLoopAddSource(rl, source, kCFRunLoopCommonModes);
+            let source = CFRunLoopSourceCreate(ptr::null_mut(), CFIndex::MAX - 1, &mut context);
+            CFRunLoopAddSource(rl, source, kCFRunLoopDefaultMode);
            CFRunLoopWakeUp(rl);

-            EventLoopProxy { sender, source }
+            EventLoopProxy { proxy_wake_up, source }
        }
    }

-    pub fn send_event(&self, event: T) -> Result<(), EventLoopClosed<T>> {
-        self.sender.send(event).map_err(|mpsc::SendError(x)| EventLoopClosed(x))?;
+    pub fn wake_up(&self) {
+        self.proxy_wake_up.store(true, AtomicOrdering::Relaxed);
        unsafe {
            // let the main thread know there's a new event
            CFRunLoopSourceSignal(self.source);
            let rl = CFRunLoopGetMain();
            CFRunLoopWakeUp(rl);
        }
-        Ok(())
    }
 }
--- a/src/platform_impl/apple/appkit/ffi.rs
+++ b/src/platform_impl/apple/appkit/ffi.rs
--- a/src/platform_impl/apple/appkit/menu.rs
+++ b/src/platform_impl/apple/appkit/menu.rs
@@ -1,4 +1,4 @@
-use objc2::rc::Id;
+use objc2::rc::Retained;
 use objc2::runtime::Sel;
 use objc2::sel;
 use objc2_app_kit::{NSApplication, NSEventModifierFlags, NSMenu, NSMenuItem};
@@ -48,10 +48,10 @@ pub fn initialize(app: &NSApplication) {
        Some(sel!(hideOtherApplications:)),
        Some(KeyEquivalent {
            key: ns_string!("h"),
-            masks: Some(NSEventModifierFlags(
-                NSEventModifierFlags::NSEventModifierFlagOption.0
-                    | NSEventModifierFlags::NSEventModifierFlagCommand.0,
-            )),
+            masks: Some(
+                NSEventModifierFlags::NSEventModifierFlagOption
+                    | NSEventModifierFlags::NSEventModifierFlagCommand,
+            ),
        }),
    );

@@ -91,7 +91,7 @@ fn menu_item(
    title: &NSString,
    selector: Option<Sel>,
    key_equivalent: Option<KeyEquivalent<'_>>,
-) -> Id<NSMenuItem> {
+) -> Retained<NSMenuItem> {
    let (key, masks) = match key_equivalent {
        Some(ke) => (ke.key, ke.masks),
        None => (ns_string!(""), None),
--- a/src/platform_impl/apple/appkit/mod.rs
+++ b/src/platform_impl/apple/appkit/mod.rs
@@ -2,7 +2,7 @@
 mod util;

 mod app;
-mod app_delegate;
+mod app_state;
 mod cursor;
 mod event;
 mod event_handler;
--- a/src/platform_impl/apple/appkit/monitor.rs
+++ b/src/platform_impl/apple/appkit/monitor.rs
@@ -9,7 +9,7 @@ use core_foundation::string::CFString;
 use core_graphics::display::{
    CGDirectDisplayID, CGDisplay, CGDisplayBounds, CGDisplayCopyDisplayMode,
 };
-use objc2::rc::Id;
+use objc2::rc::Retained;
 use objc2::runtime::AnyObject;
 use objc2_app_kit::NSScreen;
 use objc2_foundation::{ns_string, run_on_main, MainThreadMarker, NSNumber, NSPoint, NSRect};
@@ -295,7 +295,7 @@ impl MonitorHandle {
        }
    }

-    pub(crate) fn ns_screen(&self, mtm: MainThreadMarker) -> Option<Id<NSScreen>> {
+    pub(crate) fn ns_screen(&self, mtm: MainThreadMarker) -> Option<Retained<NSScreen>> {
        let uuid = unsafe { ffi::CGDisplayCreateUUIDFromDisplayID(self.0) };
        NSScreen::screens(mtm).into_iter().find(|screen| {
            let other_native_id = get_display_id(screen);
--- a/src/platform_impl/apple/appkit/observer.rs
+++ b/src/platform_impl/apple/appkit/observer.rs
@@ -1,21 +1,28 @@
+//! Utilities for working with `CFRunLoop`.
+//!
+//! See Apple's documentation on Run Loops for details:
+//! <https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/Multithreading/RunLoopManagement/RunLoopManagement.html>
+use std::cell::Cell;
 use std::ffi::c_void;
 use std::panic::{AssertUnwindSafe, UnwindSafe};
 use std::ptr;
 use std::rc::Weak;
 use std::time::Instant;

-use core_foundation::base::{CFIndex, CFOptionFlags, CFRelease};
+use block2::Block;
+use core_foundation::base::{CFIndex, CFOptionFlags, CFRelease, CFTypeRef};
 use core_foundation::date::CFAbsoluteTimeGetCurrent;
 use core_foundation::runloop::{
-    kCFRunLoopAfterWaiting, kCFRunLoopBeforeWaiting, kCFRunLoopCommonModes, kCFRunLoopExit,
+    kCFRunLoopAfterWaiting, kCFRunLoopBeforeWaiting, kCFRunLoopDefaultMode, kCFRunLoopExit,
    CFRunLoopActivity, CFRunLoopAddObserver, CFRunLoopAddTimer, CFRunLoopGetMain,
    CFRunLoopObserverCallBack, CFRunLoopObserverContext, CFRunLoopObserverCreate,
    CFRunLoopObserverRef, CFRunLoopRef, CFRunLoopTimerCreate, CFRunLoopTimerInvalidate,
    CFRunLoopTimerRef, CFRunLoopTimerSetNextFireDate, CFRunLoopWakeUp,
 };
 use objc2_foundation::MainThreadMarker;
+use tracing::error;

-use super::app_delegate::ApplicationDelegate;
+use super::app_state::ApplicationDelegate;
 use super::event_loop::{stop_app_on_panic, PanicInfo};
 use super::ffi;

@@ -84,10 +91,20 @@ extern "C" fn control_flow_end_handler(
    }
 }

+#[derive(Debug)]
 pub struct RunLoop(CFRunLoopRef);

+impl Default for RunLoop {
+    fn default() -> Self {
+        Self(ptr::null_mut())
+    }
+}
+
 impl RunLoop {
-    pub unsafe fn get() -> Self {
+    pub fn main(mtm: MainThreadMarker) -> Self {
+        // SAFETY: We have a MainThreadMarker here, which means we know we're on the main thread, so
+        // scheduling (and scheduling a non-`Send` block) to that thread is allowed.
+        let _ = mtm;
        RunLoop(unsafe { CFRunLoopGetMain() })
    }

@@ -112,11 +129,81 @@ impl RunLoop {
                context,
            )
        };
-        unsafe { CFRunLoopAddObserver(self.0, observer, kCFRunLoopCommonModes) };
+        unsafe { CFRunLoopAddObserver(self.0, observer, kCFRunLoopDefaultMode) };
+    }
+
+    /// Submit a closure to run on the main thread as the next step in the run loop, before other
+    /// event sources are processed.
+    ///
+    /// This is used for running event handlers, as those are not allowed to run re-entrantly.
+    ///
+    /// # Implementation
+    ///
+    /// This queuing could be implemented in the following several ways with subtle differences in
+    /// timing. This list is sorted in rough order in which they are run:
+    ///
+    /// 1. Using `CFRunLoopPerformBlock` or `-[NSRunLoop performBlock:]`.
+    ///
+    /// 2. Using `-[NSObject performSelectorOnMainThread:withObject:waitUntilDone:]` or wrapping the
+    ///    event in `NSEvent` and posting that to `-[NSApplication postEvent:atStart:]` (both
+    ///    creates a custom `CFRunLoopSource`, and signals that to wake up the main event loop).
+    ///
+    ///    a. `atStart = true`.
+    ///
+    ///    b. `atStart = false`.
+    ///
+    /// 3. `dispatch_async` or `dispatch_async_f`. Note that this may appear before 2b, it does not
+    ///    respect the ordering that runloop events have.
+    ///
+    /// We choose the first one, both for ease-of-implementation, but mostly for consistency, as we
+    /// want the event to be queued in a way that preserves the order the events originally arrived
+    /// in.
+    ///
+    /// As an example, let's assume that we receive two events from the user, a mouse click which we
+    /// handled by queuing it, and a window resize which we handled immediately. If we allowed
+    /// AppKit to choose the ordering when queuing the mouse event, it might get put in the back of
+    /// the queue, and the events would appear out of order to the user of Winit. So we must instead
+    /// put the event at the very front of the queue, to be handled as soon as possible after
+    /// handling whatever event it's currently handling.
+    pub fn queue_closure(&self, closure: impl FnOnce() + 'static) {
+        extern "C" {
+            fn CFRunLoopPerformBlock(rl: CFRunLoopRef, mode: CFTypeRef, block: &Block<dyn Fn()>);
+        }
+
+        // Convert `FnOnce()` to `Block<dyn Fn()>`.
+        let closure = Cell::new(Some(closure));
+        let block = block2::RcBlock::new(move || {
+            if let Some(closure) = closure.take() {
+                closure()
+            } else {
+                error!("tried to execute queued closure on main thread twice");
+            }
+        });
+
+        // There are a few common modes (`kCFRunLoopCommonModes`) defined by Cocoa:
+        // - `NSDefaultRunLoopMode`, alias of `kCFRunLoopDefaultMode`.
+        // - `NSEventTrackingRunLoopMode`, used when mouse-dragging and live-resizing a window.
+        // - `NSModalPanelRunLoopMode`, used when running a modal inside the Winit event loop.
+        // - `NSConnectionReplyMode`: TODO.
+        //
+        // We only want to run event handlers in the default mode, as we support running a blocking
+        // modal inside a Winit event handler (see [#1779]) which outrules the modal panel mode, and
+        // resizing such panel window enters the event tracking run loop mode, so we can't directly
+        // trigger events inside that mode either.
+        //
+        // Any events that are queued while running a modal or when live-resizing will instead wait,
+        // and be delivered to the application afterwards.
+        //
+        // [#1779]: https://github.com/rust-windowing/winit/issues/1779
+        let mode = unsafe { kCFRunLoopDefaultMode as CFTypeRef };
+
+        // SAFETY: The runloop is valid, the mode is a `CFStringRef`, and the block is `'static`.
+        unsafe { CFRunLoopPerformBlock(self.0, mode, &block) }
    }
 }

-pub fn setup_control_flow_observers(panic_info: Weak<PanicInfo>) {
+pub fn setup_control_flow_observers(mtm: MainThreadMarker, panic_info: Weak<PanicInfo>) {
+    let run_loop = RunLoop::main(mtm);
    unsafe {
        let mut context = CFRunLoopObserverContext {
            info: Weak::into_raw(panic_info) as *mut _,
@@ -125,16 +212,15 @@ pub fn setup_control_flow_observers(panic_info: Weak<PanicInfo>) {
            release: None,
            copyDescription: None,
        };
-        let run_loop = RunLoop::get();
        run_loop.add_observer(
            kCFRunLoopAfterWaiting,
-            CFIndex::min_value(),
+            CFIndex::MIN,
            control_flow_begin_handler,
            &mut context as *mut _,
        );
        run_loop.add_observer(
            kCFRunLoopExit | kCFRunLoopBeforeWaiting,
-            CFIndex::max_value(),
+            CFIndex::MAX,
            control_flow_end_handler,
            &mut context as *mut _,
        );
@@ -165,8 +251,8 @@ impl Drop for EventLoopWaker {
    }
 }

-impl Default for EventLoopWaker {
-    fn default() -> EventLoopWaker {
+impl EventLoopWaker {
+    pub(crate) fn new() -> Self {
        extern "C" fn wakeup_main_loop(_timer: CFRunLoopTimerRef, _info: *mut c_void) {}
        unsafe {
            // Create a timer with a 0.1µs interval (1ns does not work) to mimic polling.
@@ -174,31 +260,29 @@ impl Default for EventLoopWaker {
            // future, but that gets changed to fire immediately in did_finish_launching
            let timer = CFRunLoopTimerCreate(
                ptr::null_mut(),
-                std::f64::MAX,
+                f64::MAX,
                0.000_000_1,
                0,
                0,
                wakeup_main_loop,
                ptr::null_mut(),
            );
-            CFRunLoopAddTimer(CFRunLoopGetMain(), timer, kCFRunLoopCommonModes);
-            EventLoopWaker { timer, start_instant: Instant::now(), next_fire_date: None }
+            CFRunLoopAddTimer(CFRunLoopGetMain(), timer, kCFRunLoopDefaultMode);
+            Self { timer, start_instant: Instant::now(), next_fire_date: None }
        }
    }
-}

-impl EventLoopWaker {
    pub fn stop(&mut self) {
        if self.next_fire_date.is_some() {
            self.next_fire_date = None;
-            unsafe { CFRunLoopTimerSetNextFireDate(self.timer, std::f64::MAX) }
+            unsafe { CFRunLoopTimerSetNextFireDate(self.timer, f64::MAX) }
        }
    }

    pub fn start(&mut self) {
        if self.next_fire_date != Some(self.start_instant) {
            self.next_fire_date = Some(self.start_instant);
-            unsafe { CFRunLoopTimerSetNextFireDate(self.timer, std::f64::MIN) }
+            unsafe { CFRunLoopTimerSetNextFireDate(self.timer, f64::MIN) }
        }
    }

--- a/src/platform_impl/apple/appkit/util.rs
+++ b/src/platform_impl/apple/appkit/util.rs
@@ -1,11 +1,9 @@
-use objc2_foundation::{NSNotFound, NSRange, NSUInteger};
 use tracing::trace;

-pub static EMPTY_RANGE: NSRange = NSRange { location: NSNotFound as NSUInteger, length: 0 };
-
 macro_rules! trace_scope {
    ($s:literal) => {
-        let _crate = $crate::platform_impl::platform::util::TraceGuard::new(module_path!(), $s);
+        let _crate =
+            $crate::platform_impl::platform::appkit::util::TraceGuard::new(module_path!(), $s);
    };
 }

--- a/src/platform_impl/apple/appkit/view.rs
+++ b/src/platform_impl/apple/appkit/view.rs
@@ -3,29 +3,27 @@ use std::cell::{Cell, RefCell};
 use std::collections::{HashMap, VecDeque};
 use std::ptr;

-use objc2::rc::{Id, WeakId};
+use objc2::rc::{Retained, WeakId};
 use objc2::runtime::{AnyObject, Sel};
-use objc2::{
-    class, declare_class, msg_send, msg_send_id, mutability, sel, ClassType, DeclaredClass,
-};
+use objc2::{declare_class, msg_send_id, mutability, sel, ClassType, DeclaredClass};
 use objc2_app_kit::{
    NSApplication, NSCursor, NSEvent, NSEventPhase, NSResponder, NSTextInputClient,
-    NSTrackingRectTag, NSView,
+    NSTrackingRectTag, NSView, NSViewFrameDidChangeNotification,
 };
 use objc2_foundation::{
    MainThreadMarker, NSArray, NSAttributedString, NSAttributedStringKey, NSCopying,
-    NSMutableAttributedString, NSObject, NSObjectProtocol, NSPoint, NSRange, NSRect, NSSize,
-    NSString, NSUInteger,
+    NSMutableAttributedString, NSNotFound, NSNotificationCenter, NSObject, NSObjectProtocol,
+    NSPoint, NSRange, NSRect, NSSize, NSString, NSUInteger,
 };

-use super::app_delegate::ApplicationDelegate;
+use super::app_state::ApplicationDelegate;
 use super::cursor::{default_cursor, invisible_cursor};
 use super::event::{
    code_to_key, code_to_location, create_key_event, event_mods, lalt_pressed, ralt_pressed,
    scancode_to_physicalkey,
 };
 use super::window::WinitWindow;
-use super::{util, DEVICE_ID};
+use super::DEVICE_ID;
 use crate::dpi::{LogicalPosition, LogicalSize};
 use crate::event::{
    DeviceEvent, ElementState, Ime, Modifiers, MouseButton, MouseScrollDelta, TouchPhase,
@@ -33,11 +31,12 @@ use crate::event::{
 };
 use crate::keyboard::{Key, KeyCode, KeyLocation, ModifiersState, NamedKey};
 use crate::platform::macos::OptionAsAlt;
+use crate::window::WindowId as RootWindowId;

 #[derive(Debug)]
 struct CursorState {
    visible: bool,
-    cursor: Id<NSCursor>,
+    cursor: Retained<NSCursor>,
 }

 impl Default for CursorState {
@@ -110,8 +109,11 @@ fn get_left_modifier_code(key: &Key) -> KeyCode {
    }
 }

-#[derive(Debug, Default)]
+#[derive(Debug)]
 pub struct ViewState {
+    /// Strong reference to the global application state.
+    app_delegate: Retained<ApplicationDelegate>,
+
    cursor_state: RefCell<CursorState>,
    ime_position: Cell<NSPoint>,
    ime_size: Cell<NSSize>,
@@ -130,7 +132,7 @@ pub struct ViewState {
    /// to the application, even during IME
    forward_key_to_app: Cell<bool>,

-    marked_text: RefCell<Id<NSMutableAttributedString>>,
+    marked_text: RefCell<Retained<NSMutableAttributedString>>,
    accepts_first_mouse: bool,

    // Weak reference because the window keeps a strong reference to the view
@@ -199,19 +201,15 @@ declare_class!(
        }

        #[method(drawRect:)]
-        fn draw_rect(&self, rect: NSRect) {
+        fn draw_rect(&self, _rect: NSRect) {
            trace_scope!("drawRect:");

            // It's a workaround for https://github.com/rust-windowing/winit/issues/2640, don't replace with `self.window_id()`.
            if let Some(window) = self.ivars()._ns_window.load() {
-                let app_delegate = ApplicationDelegate::get(MainThreadMarker::from(self));
-                app_delegate.handle_redraw(window.id());
+                self.ivars().app_delegate.handle_redraw(window.id());
            }

-            #[allow(clippy::let_unit_value)]
-            unsafe {
-                let _: () = msg_send![super(self), drawRect: rect];
-            }
+            // This is a direct subclass of NSView, no need to call superclass' drawRect:
        }

        #[method(acceptsFirstResponder)]
@@ -224,7 +222,7 @@ declare_class!(
        // IMKInputSession [0x7fc573576ff0 presentFunctionRowItemTextInputViewWithEndpoint:completionHandler:] : [self textInputContext]=0x7fc573558e10 *NO* NSRemoteViewController to client, NSError=Error Domain=NSCocoaErrorDomain Code=4099 "The connection from pid 0 was invalidated from this process." UserInfo={NSDebugDescription=The connection from pid 0 was invalidated from this process.}, com.apple.inputmethod.EmojiFunctionRowItem
        // TODO: Add an API extension for using `NSTouchBar`
        #[method_id(touchBar)]
-        fn touch_bar(&self) -> Option<Id<NSObject>> {
+        fn touch_bar(&self) -> Option<Retained<NSObject>> {
            trace_scope!("touchBar");
            None
        }
@@ -257,33 +255,36 @@ declare_class!(
            if length > 0 {
                NSRange::new(0, length)
            } else {
-                util::EMPTY_RANGE
+                // Documented to return `{NSNotFound, 0}` if there is no marked range.
+                NSRange::new(NSNotFound as NSUInteger, 0)
            }
        }

        #[method(selectedRange)]
        fn selected_range(&self) -> NSRange {
            trace_scope!("selectedRange");
-            util::EMPTY_RANGE
+            // Documented to return `{NSNotFound, 0}` if there is no selection.
+            NSRange::new(NSNotFound as NSUInteger, 0)
        }

        #[method(setMarkedText:selectedRange:replacementRange:)]
        fn set_marked_text(
            &self,
            string: &NSObject,
-            _selected_range: NSRange,
+            selected_range: NSRange,
            _replacement_range: NSRange,
        ) {
+            // TODO: Use _replacement_range, requires changing the event to report surrounding text.
            trace_scope!("setMarkedText:selectedRange:replacementRange:");

            // SAFETY: This method is guaranteed to get either a `NSString` or a `NSAttributedString`.
-            let (marked_text, preedit_string) = if string.is_kind_of::<NSAttributedString>() {
+            let (marked_text, string) = if string.is_kind_of::<NSAttributedString>() {
                let string: *const NSObject = string;
                let string: *const NSAttributedString = string.cast();
                let string = unsafe { &*string };
                (
                    NSMutableAttributedString::from_attributed_nsstring(string),
-                    string.string().to_string(),
+                    string.string(),
                )
            } else {
                let string: *const NSObject = string;
@@ -291,7 +292,7 @@ declare_class!(
                let string = unsafe { &*string };
                (
                    NSMutableAttributedString::from_nsstring(string),
-                    string.to_string(),
+                    string.copy(),
                )
            };

@@ -311,16 +312,21 @@ declare_class!(
                self.ivars().ime_state.set(ImeState::Ground);
            }

-            // Empty string basically means that there's no preedit, so indicate that by sending
-            // `None` cursor range.
-            let cursor_range = if preedit_string.is_empty() {
+            let cursor_range = if string.is_empty() {
+                // An empty string basically means that there's no preedit, so indicate that by
+                // sending a `None` cursor range.
                None
            } else {
-                Some((preedit_string.len(), preedit_string.len()))
+                // Convert the selected range from UTF-16 indices to UTF-8 indices.
+                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))
            };

            // Send WindowEvent for updating marked text
-            self.queue_event(WindowEvent::Ime(Ime::Preedit(preedit_string, cursor_range)));
+            self.queue_event(WindowEvent::Ime(Ime::Preedit(string.to_string(), cursor_range)));
        }

        #[method(unmarkText)]
@@ -341,7 +347,7 @@ declare_class!(
        }

        #[method_id(validAttributesForMarkedText)]
-        fn valid_attributes_for_marked_text(&self) -> Id<NSArray<NSAttributedStringKey>> {
+        fn valid_attributes_for_marked_text(&self) -> Retained<NSArray<NSAttributedStringKey>> {
            trace_scope!("validAttributesForMarkedText");
            NSArray::new()
        }
@@ -351,7 +357,7 @@ declare_class!(
            &self,
            _range: NSRange,
            _actual_range: *mut NSRange,
-        ) -> Option<Id<NSAttributedString>> {
+        ) -> Option<Retained<NSAttributedString>> {
            trace_scope!("attributedSubstringForProposedRange:actualRange:");
            None
        }
@@ -380,6 +386,7 @@ declare_class!(

        #[method(insertText:replacementRange:)]
        fn insert_text(&self, string: &NSObject, _replacement_range: NSRange) {
+            // TODO: Use _replacement_range, requires changing the event to report surrounding text.
            trace_scope!("insertText:replacementRange:");

            // SAFETY: This method is guaranteed to get either a `NSString` or a `NSAttributedString`.
@@ -680,7 +687,9 @@ declare_class!(

            self.update_modifiers(event, false);

-            self.queue_device_event(DeviceEvent::MouseWheel { delta });
+            self.ivars().app_delegate.maybe_queue_with_handler(move |app, event_loop|
+                app.device_event(event_loop, DEVICE_ID, DeviceEvent::MouseWheel { delta })
+            );
            self.queue_event(WindowEvent::MouseWheel {
                device_id: DEVICE_ID,
                delta,
@@ -773,34 +782,40 @@ declare_class!(

 impl WinitView {
    pub(super) fn new(
+        app_delegate: &ApplicationDelegate,
        window: &WinitWindow,
        accepts_first_mouse: bool,
        option_as_alt: OptionAsAlt,
-    ) -> Id<Self> {
+    ) -> Retained<Self> {
        let mtm = MainThreadMarker::from(window);
        let this = mtm.alloc().set_ivars(ViewState {
+            app_delegate: app_delegate.retain(),
+            cursor_state: Default::default(),
+            ime_position: Default::default(),
+            ime_size: Default::default(),
+            modifiers: Default::default(),
+            phys_modifiers: Default::default(),
+            tracking_rect: Default::default(),
+            ime_state: Default::default(),
+            input_source: Default::default(),
+            ime_allowed: Default::default(),
+            forward_key_to_app: Default::default(),
+            marked_text: Default::default(),
            accepts_first_mouse,
            _ns_window: WeakId::new(&window.retain()),
            option_as_alt: Cell::new(option_as_alt),
-            ..Default::default()
        });
-        let this: Id<Self> = unsafe { msg_send_id![super(this), init] };
+        let this: Retained<Self> = unsafe { msg_send_id![super(this), init] };

        this.setPostsFrameChangedNotifications(true);
-        let notification_center: &AnyObject =
-            unsafe { msg_send![class!(NSNotificationCenter), defaultCenter] };
-        // About frame change
-        let frame_did_change_notification_name =
-            NSString::from_str("NSViewFrameDidChangeNotification");
-        #[allow(clippy::let_unit_value)]
+        let notification_center = unsafe { NSNotificationCenter::defaultCenter() };
        unsafe {
-            let _: () = msg_send![
-                notification_center,
-                addObserver: &*this,
-                selector: sel!(frameDidChange:),
-                name: &*frame_did_change_notification_name,
-                object: &*this,
-            ];
+            notification_center.addObserver_selector_name_object(
+                &this,
+                sel!(frameDidChange:),
+                Some(NSViewFrameDidChangeNotification),
+                Some(&this),
+            )
        }

        *this.ivars().input_source.borrow_mut() = this.current_input_source();
@@ -808,7 +823,7 @@ impl WinitView {
        this
    }

-    fn window(&self) -> Id<WinitWindow> {
+    fn window(&self) -> Retained<WinitWindow> {
        // TODO: Simply use `window` property on `NSView`.
        // That only returns a window _after_ the view has been attached though!
        // (which is incompatible with `frameDidChange:`)
@@ -818,13 +833,10 @@ impl WinitView {
    }

    fn queue_event(&self, event: WindowEvent) {
-        let app_delegate = ApplicationDelegate::get(MainThreadMarker::from(self));
-        app_delegate.queue_window_event(self.window().id(), event);
-    }
-
-    fn queue_device_event(&self, event: DeviceEvent) {
-        let app_delegate = ApplicationDelegate::get(MainThreadMarker::from(self));
-        app_delegate.queue_device_event(event);
+        let window_id = RootWindowId(self.window().id());
+        self.ivars().app_delegate.maybe_queue_with_handler(move |app, event_loop| {
+            app.window_event(event_loop, window_id, event);
+        });
    }

    fn scale_factor(&self) -> f64 {
@@ -843,11 +855,11 @@ impl WinitView {
            .unwrap_or_default()
    }

-    pub(super) fn cursor_icon(&self) -> Id<NSCursor> {
+    pub(super) fn cursor_icon(&self) -> Retained<NSCursor> {
        self.ivars().cursor_state.borrow().cursor.clone()
    }

-    pub(super) fn set_cursor_icon(&self, icon: Id<NSCursor>) {
+    pub(super) fn set_cursor_icon(&self, icon: Retained<NSCursor>) {
        let mut cursor_state = self.ivars().cursor_state.borrow_mut();
        cursor_state.cursor = icon;
    }
@@ -1080,7 +1092,7 @@ fn mouse_button(event: &NSEvent) -> MouseButton {
 // NOTE: to get option as alt working we need to rewrite events
 // we're getting from the operating system, which makes it
 // impossible to provide such events as extra in `KeyEvent`.
-fn replace_event(event: &NSEvent, option_as_alt: OptionAsAlt) -> Id<NSEvent> {
+fn replace_event(event: &NSEvent, option_as_alt: OptionAsAlt) -> Retained<NSEvent> {
    let ev_mods = event_mods(event).state;
    let ignore_alt_characters = match option_as_alt {
        OptionAsAlt::OnlyLeft if lalt_pressed(event) => true,
--- a/src/platform_impl/apple/appkit/window.rs
+++ b/src/platform_impl/apple/appkit/window.rs
@@ -1,6 +1,6 @@
 #![allow(clippy::unnecessary_cast)]

-use objc2::rc::{autoreleasepool, Id};
+use objc2::rc::{autoreleasepool, Retained};
 use objc2::{declare_class, mutability, ClassType, DeclaredClass};
 use objc2_app_kit::{NSResponder, NSWindow};
 use objc2_foundation::{MainThreadBound, MainThreadMarker, NSObject};
@@ -11,9 +11,9 @@ use crate::error::OsError as RootOsError;
 use crate::window::WindowAttributes;

 pub(crate) struct Window {
-    window: MainThreadBound<Id<WinitWindow>>,
+    window: MainThreadBound<Retained<WinitWindow>>,
    /// The window only keeps a weak reference to this, so we must keep it around here.
-    delegate: MainThreadBound<Id<WindowDelegate>>,
+    delegate: MainThreadBound<Retained<WindowDelegate>>,
 }

 impl Drop for Window {
@@ -28,7 +28,9 @@ impl Window {
        attributes: WindowAttributes,
    ) -> Result<Self, RootOsError> {
        let mtm = window_target.mtm;
-        let delegate = autoreleasepool(|_| WindowDelegate::new(attributes, mtm))?;
+        let delegate = autoreleasepool(|_| {
+            WindowDelegate::new(window_target.app_delegate(), attributes, mtm)
+        })?;
        Ok(Window {
            window: MainThreadBound::new(delegate.window().retain(), mtm),
            delegate: MainThreadBound::new(delegate, mtm),
--- a/src/platform_impl/apple/appkit/window_delegate.rs
+++ b/src/platform_impl/apple/appkit/window_delegate.rs
@@ -1,41 +1,45 @@
 #![allow(clippy::unnecessary_cast)]
 use std::cell::{Cell, RefCell};
 use std::collections::VecDeque;
+use std::ffi::c_void;
 use std::ptr;
+use std::sync::{Arc, Mutex};

 use core_graphics::display::{CGDisplay, CGPoint};
 use monitor::VideoModeHandle;
-use objc2::rc::{autoreleasepool, Id};
+use objc2::rc::{autoreleasepool, Retained};
 use objc2::runtime::{AnyObject, ProtocolObject};
-use objc2::{
-    class, declare_class, msg_send, msg_send_id, mutability, sel, ClassType, DeclaredClass,
-};
+use objc2::{declare_class, msg_send_id, mutability, sel, ClassType, DeclaredClass};
 use objc2_app_kit::{
-    NSAppKitVersionNumber, NSAppKitVersionNumber10_12, NSAppearance, NSApplication,
-    NSApplicationPresentationOptions, NSBackingStoreType, NSDraggingDestination,
-    NSFilenamesPboardType, NSPasteboard, NSRequestUserAttentionType, NSScreen, NSView,
-    NSWindowButton, NSWindowDelegate, NSWindowFullScreenButton, NSWindowLevel,
-    NSWindowOcclusionState, NSWindowOrderingMode, NSWindowSharingType, NSWindowStyleMask,
-    NSWindowTabbingMode, NSWindowTitleVisibility,
+    NSAppKitVersionNumber, NSAppKitVersionNumber10_12, NSAppearance, NSAppearanceCustomization,
+    NSAppearanceNameAqua, NSApplication, NSApplicationPresentationOptions, NSBackingStoreType,
+    NSColor, NSDraggingDestination, NSFilenamesPboardType, NSPasteboard,
+    NSRequestUserAttentionType, NSScreen, NSView, NSWindowButton, NSWindowDelegate,
+    NSWindowFullScreenButton, NSWindowLevel, NSWindowOcclusionState, NSWindowOrderingMode,
+    NSWindowSharingType, NSWindowStyleMask, NSWindowTabbingMode, NSWindowTitleVisibility,
 };
 use objc2_foundation::{
-    CGFloat, MainThreadMarker, NSArray, NSCopying, NSObject, NSObjectProtocol, NSPoint, NSRect,
-    NSSize, NSString,
+    ns_string, CGFloat, MainThreadMarker, NSArray, NSCopying, NSDictionary, NSKeyValueChangeKey,
+    NSKeyValueChangeNewKey, NSKeyValueChangeOldKey, NSKeyValueObservingOptions, NSObject,
+    NSObjectNSDelayedPerforming, NSObjectNSKeyValueObserverRegistration, NSObjectProtocol, NSPoint,
+    NSRect, NSSize, NSString,
 };
+use tracing::{trace, warn};

-use super::app_delegate::ApplicationDelegate;
+use super::app_state::ApplicationDelegate;
 use super::cursor::cursor_from_icon;
 use super::monitor::{self, flip_window_screen_coordinates, get_display_id};
+use super::observer::RunLoop;
 use super::view::WinitView;
 use super::window::WinitWindow;
 use super::{ffi, Fullscreen, MonitorHandle, OsError, WindowId};
 use crate::dpi::{LogicalPosition, LogicalSize, PhysicalPosition, PhysicalSize, Position, Size};
 use crate::error::{ExternalError, NotSupportedError, OsError as RootOsError};
-use crate::event::WindowEvent;
+use crate::event::{InnerSizeWriter, WindowEvent};
 use crate::platform::macos::{OptionAsAlt, WindowExtMacOS};
 use crate::window::{
    Cursor, CursorGrabMode, Icon, ImePurpose, ResizeDirection, Theme, UserAttentionType,
-    WindowAttributes, WindowButtons, WindowLevel,
+    WindowAttributes, WindowButtons, WindowId as RootWindowId, WindowLevel,
 };

 #[derive(Clone, Debug)]
@@ -74,9 +78,10 @@ impl Default for PlatformSpecificWindowAttributes {

 #[derive(Debug)]
 pub(crate) struct State {
-    window: Id<WinitWindow>,
+    /// Strong reference to the global application state.
+    app_delegate: Retained<ApplicationDelegate>,

-    current_theme: Cell<Option<Theme>>,
+    window: Retained<WinitWindow>,

    // During `windowDidResize`, we use this to only send Moved if the position changed.
    //
@@ -183,7 +188,17 @@ declare_class!(
        #[method(windowDidChangeBackingProperties:)]
        fn window_did_change_backing_properties(&self, _: Option<&AnyObject>) {
            trace_scope!("windowDidChangeBackingProperties:");
-            self.queue_static_scale_factor_changed_event();
+            let scale_factor = self.scale_factor();
+            if scale_factor == self.ivars().previous_scale_factor.get() {
+                return;
+            };
+            self.ivars().previous_scale_factor.set(scale_factor);
+
+            let mtm = MainThreadMarker::from(self);
+            let this = self.retain();
+            RunLoop::main(mtm).queue_closure(move || {
+                this.handle_scale_factor_changed(scale_factor);
+            });
        }

        #[method(windowDidBecomeKey:)]
@@ -230,7 +245,7 @@ declare_class!(
                None => {
                    let current_monitor = self.current_monitor_inner();
                    *fullscreen = Some(Fullscreen::Borderless(current_monitor));
-                }
+                },
            }
            self.ivars().in_fullscreen_transition.set(true);
        }
@@ -261,11 +276,9 @@ declare_class!(
            let mut options = proposed_options;
            let fullscreen = self.ivars().fullscreen.borrow();
            if let Some(Fullscreen::Exclusive(_)) = &*fullscreen {
-                options = NSApplicationPresentationOptions(
-                    NSApplicationPresentationOptions::NSApplicationPresentationFullScreen.0
-                        | NSApplicationPresentationOptions::NSApplicationPresentationHideDock.0
-                        | NSApplicationPresentationOptions::NSApplicationPresentationHideMenuBar.0,
-                );
+                options = NSApplicationPresentationOptions::NSApplicationPresentationFullScreen
+                    | NSApplicationPresentationOptions::NSApplicationPresentationHideDock
+                    | NSApplicationPresentationOptions::NSApplicationPresentationHideMenuBar;
            }

            options
@@ -316,14 +329,12 @@ declare_class!(
            self.ivars().in_fullscreen_transition.set(false);
            self.ivars().target_fullscreen.replace(None);
            if self.ivars().initial_fullscreen.get() {
-                #[allow(clippy::let_unit_value)]
                unsafe {
-                    let _: () = msg_send![
-                        self.window(),
-                        performSelector: sel!(toggleFullScreen:),
-                        withObject: ptr::null::<AnyObject>(),
-                        afterDelay: 0.5,
-                    ];
+                    self.window().performSelector_withObject_afterDelay(
+                        sel!(toggleFullScreen:),
+                        None,
+                        0.5,
+                    )
                };
            } else {
                self.restore_state_from_fullscreen();
@@ -334,8 +345,7 @@ declare_class!(
        #[method(windowDidChangeOcclusionState:)]
        fn window_did_change_occlusion_state(&self, _: Option<&AnyObject>) {
            trace_scope!("windowDidChangeOcclusionState:");
-            let visible = self.window().occlusionState().0 & NSWindowOcclusionState::Visible.0
-                == NSWindowOcclusionState::Visible.0;
+            let visible = self.window().occlusionState().contains(NSWindowOcclusionState::Visible);
            self.queue_event(WindowEvent::Occluded(!visible));
        }

@@ -359,11 +369,9 @@ declare_class!(

            use std::path::PathBuf;

-            let pb: Id<NSPasteboard> = unsafe { msg_send_id![sender, draggingPasteboard] };
-            let filenames = pb
-                .propertyListForType(unsafe { NSFilenamesPboardType })
-                .unwrap();
-            let filenames: Id<NSArray<NSString>> = unsafe { Id::cast(filenames) };
+            let pb: Retained<NSPasteboard> = unsafe { msg_send_id![sender, draggingPasteboard] };
+            let filenames = pb.propertyListForType(unsafe { NSFilenamesPboardType }).unwrap();
+            let filenames: Retained<NSArray<NSString>> = unsafe { Retained::cast(filenames) };

            filenames.into_iter().for_each(|file| {
                let path = PathBuf::from(file.to_string());
@@ -387,11 +395,9 @@ declare_class!(

            use std::path::PathBuf;

-            let pb: Id<NSPasteboard> = unsafe { msg_send_id![sender, draggingPasteboard] };
-            let filenames = pb
-                .propertyListForType(unsafe { NSFilenamesPboardType })
-                .unwrap();
-            let filenames: Id<NSArray<NSString>> = unsafe { Id::cast(filenames) };
+            let pb: Retained<NSPasteboard> = unsafe { msg_send_id![sender, draggingPasteboard] };
+            let filenames = pb.propertyListForType(unsafe { NSFilenamesPboardType }).unwrap();
+            let filenames: Retained<NSArray<NSString>> = unsafe { Retained::cast(filenames) };

            filenames.into_iter().for_each(|file| {
                let path = PathBuf::from(file.to_string());
@@ -415,34 +421,71 @@ declare_class!(
        }
    }

+    // Key-Value Observing
    unsafe impl WindowDelegate {
-        // Observe theme change
-        #[method(effectiveAppearanceDidChange:)]
-        fn effective_appearance_did_change(this: *mut Self, sender: Option<&AnyObject>) {
-            trace_scope!("effectiveAppearanceDidChange:");
-            unsafe {
-                msg_send![
-                    this,
-                    performSelectorOnMainThread: sel!(effectiveAppearanceDidChangedOnMainThread:),
-                    withObject: sender,
-                    waitUntilDone: false,
-                ]
-            }
-        }
+        #[method(observeValueForKeyPath:ofObject:change:context:)]
+        fn observe_value(
+            &self,
+            key_path: Option<&NSString>,
+            _object: Option<&AnyObject>,
+            change: Option<&NSDictionary<NSKeyValueChangeKey, AnyObject>>,
+            _context: *mut c_void,
+        ) {
+            trace_scope!("observeValueForKeyPath:ofObject:change:context:");
+            // NOTE: We don't _really_ need to check the key path, as there should only be one, but
+            // in the future we might want to observe other key paths.
+            if key_path == Some(ns_string!("effectiveAppearance")) {
+                let change = change.expect("requested a change dictionary in `addObserver`, but none was provided");
+                let old = change.get(unsafe { NSKeyValueChangeOldKey }).expect("requested change dictionary did not contain `NSKeyValueChangeOldKey`");
+                let new = change.get(unsafe { NSKeyValueChangeNewKey }).expect("requested change dictionary did not contain `NSKeyValueChangeNewKey`");

-        #[method(effectiveAppearanceDidChangedOnMainThread:)]
-        fn effective_appearance_did_changed_on_main_thread(&self, _: Option<&AnyObject>) {
-            let mtm = MainThreadMarker::from(self);
-            let theme = get_ns_theme(mtm);
-            let old_theme = self.ivars().current_theme.replace(Some(theme));
-            if old_theme != Some(theme) {
-                self.queue_event(WindowEvent::ThemeChanged(theme));
+                // SAFETY: The value of `effectiveAppearance` is `NSAppearance`
+                let old: *const AnyObject = old;
+                let old: *const NSAppearance = old.cast();
+                let old: &NSAppearance = unsafe { &*old };
+                let new: *const AnyObject = new;
+                let new: *const NSAppearance = new.cast();
+                let new: &NSAppearance = unsafe { &*new };
+
+                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 unsafe { self.window().appearance() }.is_some() {
+                    return;
+                }
+
+                let old = appearance_to_theme(old);
+                let new = appearance_to_theme(new);
+                // Check that the theme changed in Winit's terms (the theme might have changed on
+                // other parameters, such as level of contrast, but the event should not be emitted
+                // in those cases).
+                if old == new {
+                    return;
+                }
+
+                self.queue_event(WindowEvent::ThemeChanged(new));
+            } else {
+                panic!("unknown observed keypath {key_path:?}");
            }
        }
    }
 );

-fn new_window(attrs: &WindowAttributes, mtm: MainThreadMarker) -> Option<Id<WinitWindow>> {
+impl Drop for WindowDelegate {
+    fn drop(&mut self) {
+        unsafe {
+            self.window().removeObserver_forKeyPath(self, ns_string!("effectiveAppearance"));
+        }
+    }
+}
+
+fn new_window(
+    app_delegate: &ApplicationDelegate,
+    attrs: &WindowAttributes,
+    mtm: MainThreadMarker,
+) -> Option<Retained<WinitWindow>> {
    autoreleasepool(|_| {
        let screen = match attrs.fullscreen.clone().map(Into::into) {
            Some(Fullscreen::Borderless(Some(monitor)))
@@ -487,38 +530,38 @@ fn new_window(attrs: &WindowAttributes, mtm: MainThreadMarker) -> Option<Id<Wini
            // if decorations is set to false, ignore pl_attrs
            //
            // if the titlebar is hidden, ignore other pl_attrs
-            NSWindowStyleMask::Borderless.0
-                | NSWindowStyleMask::Resizable.0
-                | NSWindowStyleMask::Miniaturizable.0
+            NSWindowStyleMask::Borderless
+                | NSWindowStyleMask::Resizable
+                | NSWindowStyleMask::Miniaturizable
        } else {
            // default case, resizable window with titlebar and titlebar buttons
-            NSWindowStyleMask::Closable.0
-                | NSWindowStyleMask::Miniaturizable.0
-                | NSWindowStyleMask::Resizable.0
-                | NSWindowStyleMask::Titled.0
+            NSWindowStyleMask::Closable
+                | NSWindowStyleMask::Miniaturizable
+                | NSWindowStyleMask::Resizable
+                | NSWindowStyleMask::Titled
        };

        if !attrs.resizable {
-            masks &= !NSWindowStyleMask::Resizable.0;
+            masks &= !NSWindowStyleMask::Resizable;
        }

        if !attrs.enabled_buttons.contains(WindowButtons::MINIMIZE) {
-            masks &= !NSWindowStyleMask::Miniaturizable.0;
+            masks &= !NSWindowStyleMask::Miniaturizable;
        }

        if !attrs.enabled_buttons.contains(WindowButtons::CLOSE) {
-            masks &= !NSWindowStyleMask::Closable.0;
+            masks &= !NSWindowStyleMask::Closable;
        }

        if attrs.platform_specific.fullsize_content_view {
-            masks |= NSWindowStyleMask::FullSizeContentView.0;
+            masks |= NSWindowStyleMask::FullSizeContentView;
        }

-        let window: Option<Id<WinitWindow>> = unsafe {
+        let window: Option<Retained<WinitWindow>> = unsafe {
            msg_send_id![
                super(mtm.alloc().set_ivars(())),
                initWithContentRect: frame,
-                styleMask: NSWindowStyleMask(masks),
+                styleMask: masks,
                backing: NSBackingStoreType::NSBackingStoreBuffered,
                defer: false,
            ]
@@ -579,6 +622,7 @@ fn new_window(attrs: &WindowAttributes, mtm: MainThreadMarker) -> Option<Id<Wini
        }

        let view = WinitView::new(
+            app_delegate,
            &window,
            attrs.platform_specific.accepts_first_mouse,
            attrs.platform_specific.option_as_alt,
@@ -605,6 +649,8 @@ fn new_window(attrs: &WindowAttributes, mtm: MainThreadMarker) -> Option<Id<Wini

        if attrs.transparent {
            window.setOpaque(false);
+            // See `set_transparent` for details on why we do this.
+            window.setBackgroundColor(unsafe { Some(&NSColor::clearColor()) });
        }

        // register for drag and drop operations.
@@ -618,8 +664,12 @@ fn new_window(attrs: &WindowAttributes, mtm: MainThreadMarker) -> Option<Id<Wini
 }

 impl WindowDelegate {
-    pub fn new(attrs: WindowAttributes, mtm: MainThreadMarker) -> Result<Id<Self>, RootOsError> {
-        let window = new_window(&attrs, mtm)
+    pub(super) fn new(
+        app_delegate: &ApplicationDelegate,
+        attrs: WindowAttributes,
+        mtm: MainThreadMarker,
+    ) -> Result<Retained<Self>, RootOsError> {
+        let window = new_window(app_delegate, &attrs, mtm)
            .ok_or_else(|| os_error!(OsError::CreationError("couldn't create `NSWindow`")))?;

        #[cfg(feature = "rwh_06")]
@@ -627,8 +677,8 @@ impl WindowDelegate {
            Some(rwh_06::RawWindowHandle::AppKit(handle)) => {
                // SAFETY: Caller ensures the pointer is valid or NULL
                // Unwrap is fine, since the pointer comes from `NonNull`.
-                let parent_view: Id<NSView> =
-                    unsafe { Id::retain(handle.ns_view.as_ptr().cast()) }.unwrap();
+                let parent_view: Retained<NSView> =
+                    unsafe { Retained::retain(handle.ns_view.as_ptr().cast()) }.unwrap();
                let parent = parent_view.window().ok_or_else(|| {
                    os_error!(OsError::CreationError("parent view should be installed in a window"))
                })?;
@@ -654,14 +704,13 @@ impl WindowDelegate {

        let scale_factor = window.backingScaleFactor() as _;

-        let current_theme = match attrs.preferred_theme {
-            Some(theme) => Some(theme),
-            None => Some(get_ns_theme(mtm)),
-        };
+        if let Some(appearance) = theme_to_appearance(attrs.preferred_theme) {
+            unsafe { window.setAppearance(Some(&appearance)) };
+        }

        let delegate = mtm.alloc().set_ivars(State {
+            app_delegate: app_delegate.retain(),
            window: window.retain(),
-            current_theme: Cell::new(current_theme),
            previous_position: Cell::new(None),
            previous_scale_factor: Cell::new(scale_factor),
            resize_increments: Cell::new(resize_increments),
@@ -677,25 +726,27 @@ impl WindowDelegate {
            is_simple_fullscreen: Cell::new(false),
            saved_style: Cell::new(None),
        });
-        let delegate: Id<WindowDelegate> = unsafe { msg_send_id![super(delegate), init] };
+        let delegate: Retained<WindowDelegate> = unsafe { msg_send_id![super(delegate), init] };

        if scale_factor != 1.0 {
-            delegate.queue_static_scale_factor_changed_event();
+            let delegate = delegate.clone();
+            RunLoop::main(mtm).queue_closure(move || {
+                delegate.handle_scale_factor_changed(scale_factor);
+            });
        }
        window.setDelegate(Some(ProtocolObject::from_ref(&*delegate)));

-        // Enable theme change event
-        let notification_center: Id<AnyObject> =
-            unsafe { msg_send_id![class!(NSDistributedNotificationCenter), defaultCenter] };
-        let notification_name = NSString::from_str("AppleInterfaceThemeChangedNotification");
-        let _: () = unsafe {
-            msg_send![
-                &notification_center,
-                addObserver: &*delegate,
-                selector: sel!(effectiveAppearanceDidChange:),
-                name: &*notification_name,
-                object: ptr::null::<AnyObject>(),
-            ]
+        // Listen for theme change event.
+        //
+        // SAFETY: The observer is un-registered in the `Drop` of the delegate.
+        unsafe {
+            window.addObserver_forKeyPath_options_context(
+                &delegate,
+                ns_string!("effectiveAppearance"),
+                NSKeyValueObservingOptions::NSKeyValueObservingOptionNew
+                    | NSKeyValueObservingOptions::NSKeyValueObservingOptionOld,
+                ptr::null_mut(),
+            )
        };

        if attrs.blur {
@@ -740,9 +791,9 @@ impl WindowDelegate {
    }

    #[track_caller]
-    pub(super) fn view(&self) -> Id<WinitView> {
+    pub(super) fn view(&self) -> Retained<WinitView> {
        // SAFETY: The view inside WinitWindow is always `WinitView`
-        unsafe { Id::cast(self.window().contentView().unwrap()) }
+        unsafe { Retained::cast(self.window().contentView().unwrap()) }
    }

    #[track_caller]
@@ -756,26 +807,33 @@ impl WindowDelegate {
    }

    pub(crate) fn queue_event(&self, event: WindowEvent) {
-        let app_delegate = ApplicationDelegate::get(MainThreadMarker::from(self));
-        app_delegate.queue_window_event(self.window().id(), event);
+        let window_id = RootWindowId(self.window().id());
+        self.ivars().app_delegate.maybe_queue_with_handler(move |app, event_loop| {
+            app.window_event(event_loop, window_id, event);
+        });
    }

-    fn queue_static_scale_factor_changed_event(&self) {
-        let scale_factor = self.scale_factor();
-        if scale_factor == self.ivars().previous_scale_factor.get() {
-            return;
-        };
+    fn handle_scale_factor_changed(&self, scale_factor: CGFloat) {
+        let window = self.window();

-        self.ivars().previous_scale_factor.set(scale_factor);
-        let content_size = self.window().contentRectForFrameRect(self.window().frame()).size;
+        let content_size = window.contentRectForFrameRect(window.frame()).size;
        let content_size = LogicalSize::new(content_size.width, content_size.height);

-        let app_delegate = ApplicationDelegate::get(MainThreadMarker::from(self));
-        app_delegate.queue_static_scale_factor_changed_event(
-            self.window().retain(),
-            content_size.to_physical(scale_factor),
+        let suggested_size = content_size.to_physical(scale_factor);
+        let new_inner_size = Arc::new(Mutex::new(suggested_size));
+        self.queue_event(WindowEvent::ScaleFactorChanged {
            scale_factor,
-        );
+            inner_size_writer: InnerSizeWriter::new(Arc::downgrade(&new_inner_size)),
+        });
+        let physical_size = *new_inner_size.lock().unwrap();
+        drop(new_inner_size);
+
+        if physical_size != suggested_size {
+            let logical_size = physical_size.to_logical(scale_factor);
+            let size = NSSize::new(logical_size.width, logical_size.height);
+            window.setContentSize(size);
+        }
+        self.queue_event(WindowEvent::Resized(physical_size));
    }

    fn emit_move_event(&self) {
@@ -803,7 +861,23 @@ impl WindowDelegate {
    }

    pub fn set_transparent(&self, transparent: bool) {
-        self.window().setOpaque(!transparent)
+        // This is just a hint for Quartz, it doesn't actually speculate with window alpha.
+        // Providing a wrong value here could result in visual artifacts, when the window is
+        // transparent.
+        self.window().setOpaque(!transparent);
+
+        // AppKit draws the window with a background color by default, which is usually really
+        // nice, but gets in the way when we want to allow the contents of the window to be
+        // 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 {
+            unsafe { NSColor::clearColor() }
+        } else {
+            unsafe { NSColor::windowBackgroundColor() }
+        };
+
+        self.window().setBackgroundColor(Some(&color));
    }

    pub fn set_blur(&self, blur: bool) {
@@ -833,8 +907,7 @@ impl WindowDelegate {
    }

    pub fn request_redraw(&self) {
-        let app_delegate = ApplicationDelegate::get(MainThreadMarker::from(self));
-        app_delegate.queue_redraw(self.window().id());
+        self.ivars().app_delegate.queue_redraw(self.window().id());
    }

    #[inline]
@@ -903,8 +976,8 @@ impl WindowDelegate {

    pub fn set_max_inner_size(&self, dimensions: Option<Size>) {
        let dimensions = dimensions.unwrap_or(Size::Logical(LogicalSize {
-            width: std::f32::MAX as f64,
-            height: std::f32::MAX as f64,
+            width: f32::MAX as f64,
+            height: f32::MAX as f64,
        }));
        let scale_factor = self.scale_factor();
        let max_size = dimensions.to_logical::<CGFloat>(scale_factor);
@@ -958,13 +1031,13 @@ impl WindowDelegate {
        self.ivars().resizable.set(resizable);
        let fullscreen = self.ivars().fullscreen.borrow().is_some();
        if !fullscreen {
-            let mut mask = self.window().styleMask().0;
+            let mut mask = self.window().styleMask();
            if resizable {
-                mask |= NSWindowStyleMask::Resizable.0;
+                mask |= NSWindowStyleMask::Resizable;
            } else {
-                mask &= !NSWindowStyleMask::Resizable.0;
+                mask &= !NSWindowStyleMask::Resizable;
            }
-            self.set_style_mask(NSWindowStyleMask(mask));
+            self.set_style_mask(mask);
        }
        // Otherwise, we don't change the mask until we exit fullscreen.
    }
@@ -976,23 +1049,23 @@ impl WindowDelegate {

    #[inline]
    pub fn set_enabled_buttons(&self, buttons: WindowButtons) {
-        let mut mask = self.window().styleMask().0;
+        let mut mask = self.window().styleMask();

        if buttons.contains(WindowButtons::CLOSE) {
-            mask |= NSWindowStyleMask::Closable.0;
+            mask |= NSWindowStyleMask::Closable;
        } else {
-            mask &= !NSWindowStyleMask::Closable.0;
+            mask &= !NSWindowStyleMask::Closable;
        }

        if buttons.contains(WindowButtons::MINIMIZE) {
-            mask |= NSWindowStyleMask::Miniaturizable.0;
+            mask |= NSWindowStyleMask::Miniaturizable;
        } else {
-            mask &= !NSWindowStyleMask::Miniaturizable.0;
+            mask &= !NSWindowStyleMask::Miniaturizable;
        }

        // This must happen before the button's "enabled" status has been set,
        // hence we do it synchronously.
-        self.set_style_mask(NSWindowStyleMask(mask));
+        self.set_style_mask(mask);

        // We edit the button directly instead of using `NSResizableWindowMask`,
        // since that mask also affect the resizability of the window (which is
@@ -1113,9 +1186,8 @@ impl WindowDelegate {
        // we make it resizable temporarily.
        let curr_mask = self.window().styleMask();

-        let required =
-            NSWindowStyleMask(NSWindowStyleMask::Titled.0 | NSWindowStyleMask::Resizable.0);
-        let needs_temp_mask = !mask_contains(curr_mask, required);
+        let required = NSWindowStyleMask::Titled | NSWindowStyleMask::Resizable;
+        let needs_temp_mask = !curr_mask.contains(required);
        if needs_temp_mask {
            self.set_style_mask(required);
        }
@@ -1132,12 +1204,12 @@ impl WindowDelegate {

    fn saved_style(&self) -> NSWindowStyleMask {
        let base_mask =
-            self.ivars().saved_style.take().unwrap_or_else(|| self.window().styleMask()).0;
-        NSWindowStyleMask(if self.ivars().resizable.get() {
-            base_mask | NSWindowStyleMask::Resizable.0
+            self.ivars().saved_style.take().unwrap_or_else(|| self.window().styleMask());
+        if self.ivars().resizable.get() {
+            base_mask | NSWindowStyleMask::Resizable
        } else {
-            base_mask & !NSWindowStyleMask::Resizable.0
-        })
+            base_mask & !NSWindowStyleMask::Resizable
+        }
    }

    /// This is called when the window is exiting fullscreen, whether by the
@@ -1192,7 +1264,7 @@ impl WindowDelegate {
            return;
        }

-        if mask_contains(self.window().styleMask(), NSWindowStyleMask::Resizable) {
+        if self.window().styleMask().contains(NSWindowStyleMask::Resizable) {
            // Just use the native zoom if resizable
            self.window().zoom(None);
        } else {
@@ -1344,9 +1416,8 @@ impl WindowDelegate {
                // set a normal style temporarily. The previous state will be
                // restored in `WindowDelegate::window_did_exit_fullscreen`.
                let curr_mask = self.window().styleMask();
-                let required =
-                    NSWindowStyleMask(NSWindowStyleMask::Titled.0 | NSWindowStyleMask::Resizable.0);
-                if !mask_contains(curr_mask, required) {
+                let required = NSWindowStyleMask::Titled | NSWindowStyleMask::Resizable;
+                if !curr_mask.contains(required) {
                    self.set_style_mask(required);
                    self.ivars().saved_style.set(Some(curr_mask));
                }
@@ -1377,11 +1448,10 @@ impl WindowDelegate {
                // delegate in `window:willUseFullScreenPresentationOptions:`.
                self.ivars().save_presentation_opts.set(Some(app.presentationOptions()));

-                let presentation_options = NSApplicationPresentationOptions(
-                    NSApplicationPresentationOptions::NSApplicationPresentationFullScreen.0
-                        | NSApplicationPresentationOptions::NSApplicationPresentationHideDock.0
-                        | NSApplicationPresentationOptions::NSApplicationPresentationHideMenuBar.0,
-                );
+                let presentation_options =
+                    NSApplicationPresentationOptions::NSApplicationPresentationFullScreen
+                        | NSApplicationPresentationOptions::NSApplicationPresentationHideDock
+                        | NSApplicationPresentationOptions::NSApplicationPresentationHideMenuBar;
                app.setPresentationOptions(presentation_options);

                let window_level = unsafe { ffi::CGShieldingWindowLevel() } as NSWindowLevel + 1;
@@ -1389,9 +1459,9 @@ impl WindowDelegate {
            },
            (Some(Fullscreen::Exclusive(ref video_mode)), Some(Fullscreen::Borderless(_))) => {
                let presentation_options = self.ivars().save_presentation_opts.get().unwrap_or(
-                    NSApplicationPresentationOptions(NSApplicationPresentationOptions::NSApplicationPresentationFullScreen.0
-                        | NSApplicationPresentationOptions::NSApplicationPresentationAutoHideDock.0
-                        | NSApplicationPresentationOptions::NSApplicationPresentationAutoHideMenuBar.0),
+                    NSApplicationPresentationOptions::NSApplicationPresentationFullScreen
+                        | NSApplicationPresentationOptions::NSApplicationPresentationAutoHideDock
+                        | NSApplicationPresentationOptions::NSApplicationPresentationAutoHideMenuBar
                );
                app.setPresentationOptions(presentation_options);

@@ -1430,19 +1500,19 @@ impl WindowDelegate {

        let new_mask = {
            let mut new_mask = if decorations {
-                NSWindowStyleMask::Closable.0
-                    | NSWindowStyleMask::Miniaturizable.0
-                    | NSWindowStyleMask::Resizable.0
-                    | NSWindowStyleMask::Titled.0
+                NSWindowStyleMask::Closable
+                    | NSWindowStyleMask::Miniaturizable
+                    | NSWindowStyleMask::Resizable
+                    | NSWindowStyleMask::Titled
            } else {
-                NSWindowStyleMask::Borderless.0 | NSWindowStyleMask::Resizable.0
+                NSWindowStyleMask::Borderless | NSWindowStyleMask::Resizable
            };
            if !resizable {
-                new_mask &= !NSWindowStyleMask::Resizable.0;
+                new_mask &= !NSWindowStyleMask::Resizable;
            }
            new_mask
        };
-        self.set_style_mask(NSWindowStyleMask(new_mask));
+        self.set_style_mask(new_mask);
    }

    #[inline]
@@ -1545,7 +1615,7 @@ impl WindowDelegate {
    pub fn raw_window_handle_rwh_04(&self) -> rwh_04::RawWindowHandle {
        let mut window_handle = rwh_04::AppKitHandle::empty();
        window_handle.ns_window = self.window() as *const WinitWindow as *mut _;
-        window_handle.ns_view = Id::as_ptr(&self.contentView().unwrap()) as *mut _;
+        window_handle.ns_view = Retained::as_ptr(&self.contentView().unwrap()) as *mut _;
        rwh_04::RawWindowHandle::AppKit(window_handle)
    }

@@ -1554,7 +1624,7 @@ impl WindowDelegate {
    pub fn raw_window_handle_rwh_05(&self) -> rwh_05::RawWindowHandle {
        let mut window_handle = rwh_05::AppKitWindowHandle::empty();
        window_handle.ns_window = self.window() as *const WinitWindow as *mut _;
-        window_handle.ns_view = Id::as_ptr(&self.view()) as *mut _;
+        window_handle.ns_view = Retained::as_ptr(&self.view()) as *mut _;
        rwh_05::RawWindowHandle::AppKit(window_handle)
    }

@@ -1568,8 +1638,8 @@ impl WindowDelegate {
    #[inline]
    pub fn raw_window_handle_rwh_06(&self) -> rwh_06::RawWindowHandle {
        let window_handle = rwh_06::AppKitWindowHandle::new({
-            let ptr = Id::as_ptr(&self.view()) as *mut _;
-            std::ptr::NonNull::new(ptr).expect("Id<T> should never be null")
+            let ptr = Retained::as_ptr(&self.view()) as *mut _;
+            std::ptr::NonNull::new(ptr).expect("Retained<T> should never be null")
        });
        rwh_06::RawWindowHandle::AppKit(window_handle)
    }
@@ -1577,26 +1647,30 @@ impl WindowDelegate {
    fn toggle_style_mask(&self, mask: NSWindowStyleMask, on: bool) {
        let current_style_mask = self.window().styleMask();
        if on {
-            self.set_style_mask(NSWindowStyleMask(current_style_mask.0 | mask.0));
+            self.set_style_mask(current_style_mask | mask);
        } else {
-            self.set_style_mask(NSWindowStyleMask(current_style_mask.0 & (!mask.0)));
+            self.set_style_mask(current_style_mask & !mask);
        }
    }

-    #[inline]
-    pub fn theme(&self) -> Option<Theme> {
-        self.ivars().current_theme.get()
-    }
-
    #[inline]
    pub fn has_focus(&self) -> bool {
        self.window().isKeyWindow()
    }

+    pub fn theme(&self) -> Option<Theme> {
+        // Note: We could choose between returning the value of `effectiveAppearance` or
+        // `appearance`, depending on what the user is asking about:
+        // - "how should I render on this particular frame".
+        // - "what is the configuration for this window".
+        //
+        // We choose the latter for consistency with the `set_theme` call, though it might also be
+        // useful to expose the former.
+        Some(appearance_to_theme(unsafe { &*self.window().appearance()? }))
+    }
+
    pub fn set_theme(&self, theme: Option<Theme>) {
-        let mtm = MainThreadMarker::from(self);
-        set_ns_theme(theme, mtm);
-        self.ivars().current_theme.set(theme.or_else(|| Some(get_ns_theme(mtm))));
+        unsafe { self.window().setAppearance(theme_to_appearance(theme).as_deref()) };
    }

    #[inline]
@@ -1652,10 +1726,9 @@ impl WindowExtMacOS for WindowDelegate {
            self.ivars().is_simple_fullscreen.set(true);

            // Simulate pre-Lion fullscreen by hiding the dock and menu bar
-            let presentation_options = NSApplicationPresentationOptions(
-                NSApplicationPresentationOptions::NSApplicationPresentationAutoHideDock.0
-                    | NSApplicationPresentationOptions::NSApplicationPresentationAutoHideMenuBar.0,
-            );
+            let presentation_options =
+                NSApplicationPresentationOptions::NSApplicationPresentationAutoHideDock
+                    | NSApplicationPresentationOptions::NSApplicationPresentationAutoHideMenuBar;
            app.setPresentationOptions(presentation_options);

            // Hide the titlebar
@@ -1753,43 +1826,42 @@ impl WindowExtMacOS for WindowDelegate {
    }
 }

-fn mask_contains(mask: NSWindowStyleMask, value: NSWindowStyleMask) -> bool {
-    mask.0 & value.0 == value.0
-}
-
 const DEFAULT_STANDARD_FRAME: NSRect =
    NSRect::new(NSPoint::new(50.0, 50.0), NSSize::new(800.0, 600.0));

-pub(super) fn get_ns_theme(mtm: MainThreadMarker) -> Theme {
-    let app = NSApplication::sharedApplication(mtm);
-    let has_theme: bool = unsafe { msg_send![&app, respondsToSelector: sel!(effectiveAppearance)] };
-    if !has_theme {
-        return Theme::Light;
-    }
-    let appearance = app.effectiveAppearance();
-    let name = appearance
-        .bestMatchFromAppearancesWithNames(&NSArray::from_id_slice(&[
-            NSString::from_str("NSAppearanceNameAqua"),
-            NSString::from_str("NSAppearanceNameDarkAqua"),
-        ]))
-        .unwrap();
-    match &*name.to_string() {
-        "NSAppearanceNameDarkAqua" => Theme::Dark,
-        _ => Theme::Light,
+fn dark_appearance_name() -> &'static NSString {
+    // Don't use the static `NSAppearanceNameDarkAqua` to allow linking on macOS < 10.14
+    ns_string!("NSAppearanceNameDarkAqua")
+}
+
+fn appearance_to_theme(appearance: &NSAppearance) -> Theme {
+    let best_match = appearance.bestMatchFromAppearancesWithNames(&NSArray::from_id_slice(&[
+        unsafe { NSAppearanceNameAqua.copy() },
+        dark_appearance_name().copy(),
+    ]));
+    if let Some(best_match) = best_match {
+        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
+        Theme::Light
    }
 }

-fn set_ns_theme(theme: Option<Theme>, mtm: MainThreadMarker) {
-    let app = NSApplication::sharedApplication(mtm);
-    let has_theme: bool = unsafe { msg_send![&app, respondsToSelector: sel!(effectiveAppearance)] };
-    if has_theme {
-        let appearance = theme.map(|t| {
-            let name = match t {
-                Theme::Dark => NSString::from_str("NSAppearanceNameDarkAqua"),
-                Theme::Light => NSString::from_str("NSAppearanceNameAqua"),
-            };
-            NSAppearance::appearanceNamed(&name).unwrap()
-        });
-        app.setAppearance(appearance.as_ref().map(|a| a.as_ref()));
+fn theme_to_appearance(theme: Option<Theme>) -> Option<Retained<NSAppearance>> {
+    let appearance = match theme? {
+        Theme::Light => unsafe { NSAppearance::appearanceNamed(NSAppearanceNameAqua) },
+        Theme::Dark => NSAppearance::appearanceNamed(dark_appearance_name()),
+    };
+    if let Some(appearance) = appearance {
+        Some(appearance)
+    } else {
+        warn!(?theme, "could not find appearance for theme");
+        // Assume system appearance in this case
+        None
    }
 }
--- a/src/platform_impl/apple/mod.rs
+++ b/src/platform_impl/apple/mod.rs
@@ -0,0 +1,11 @@
+//! Apple/Darwin-specific implementations
+
+#[cfg(target_os = "macos")]
+mod appkit;
+#[cfg(not(target_os = "macos"))]
+mod uikit;
+
+#[cfg(target_os = "macos")]
+pub use self::appkit::*;
+#[cfg(not(target_os = "macos"))]
+pub use self::uikit::*;
--- a/src/platform_impl/apple/uikit/app_delegate.rs
+++ b/src/platform_impl/apple/uikit/app_delegate.rs
@@ -0,0 +1,60 @@
+use objc2::{declare_class, mutability, ClassType, DeclaredClass};
+use objc2_foundation::{MainThreadMarker, NSObject};
+use objc2_ui_kit::UIApplication;
+
+use super::app_state::{self, send_occluded_event_for_all_windows, EventWrapper};
+use crate::event::Event;
+
+declare_class!(
+    pub struct AppDelegate;
+
+    unsafe impl ClassType for AppDelegate {
+        type Super = NSObject;
+        type Mutability = mutability::InteriorMutable;
+        const NAME: &'static str = "WinitApplicationDelegate";
+    }
+
+    impl DeclaredClass for AppDelegate {}
+
+    // UIApplicationDelegate protocol
+    unsafe impl AppDelegate {
+        #[method(application:didFinishLaunchingWithOptions:)]
+        fn did_finish_launching(&self, _application: &UIApplication, _: *mut NSObject) -> bool {
+            app_state::did_finish_launching(MainThreadMarker::new().unwrap());
+            true
+        }
+
+        #[method(applicationDidBecomeActive:)]
+        fn did_become_active(&self, _application: &UIApplication) {
+            let mtm = MainThreadMarker::new().unwrap();
+            app_state::handle_nonuser_event(mtm, EventWrapper::StaticEvent(Event::Resumed))
+        }
+
+        #[method(applicationWillResignActive:)]
+        fn will_resign_active(&self, _application: &UIApplication) {
+            let mtm = MainThreadMarker::new().unwrap();
+            app_state::handle_nonuser_event(mtm, EventWrapper::StaticEvent(Event::Suspended))
+        }
+
+        #[method(applicationWillEnterForeground:)]
+        fn will_enter_foreground(&self, application: &UIApplication) {
+            send_occluded_event_for_all_windows(application, false);
+        }
+
+        #[method(applicationDidEnterBackground:)]
+        fn did_enter_background(&self, application: &UIApplication) {
+            send_occluded_event_for_all_windows(application, true);
+        }
+
+        #[method(applicationWillTerminate:)]
+        fn will_terminate(&self, application: &UIApplication) {
+            app_state::terminated(application);
+        }
+
+        #[method(applicationDidReceiveMemoryWarning:)]
+        fn did_receive_memory_warning(&self, _application: &UIApplication) {
+            let mtm = MainThreadMarker::new().unwrap();
+            app_state::handle_nonuser_event(mtm, EventWrapper::StaticEvent(Event::MemoryWarning))
+        }
+    }
+);
--- a/src/platform_impl/apple/uikit/app_state.rs
+++ b/src/platform_impl/apple/uikit/app_state.rs
@@ -10,17 +10,18 @@ use std::{fmt, mem, ptr};
 use core_foundation::base::CFRelease;
 use core_foundation::date::CFAbsoluteTimeGetCurrent;
 use core_foundation::runloop::{
-    kCFRunLoopCommonModes, CFRunLoopAddTimer, CFRunLoopGetMain, CFRunLoopRef, CFRunLoopTimerCreate,
+    kCFRunLoopDefaultMode, CFRunLoopAddTimer, CFRunLoopGetMain, CFRunLoopRef, CFRunLoopTimerCreate,
    CFRunLoopTimerInvalidate, CFRunLoopTimerRef, CFRunLoopTimerSetNextFireDate,
 };
-use objc2::rc::Id;
+use objc2::rc::Retained;
 use objc2::runtime::AnyObject;
 use objc2::{msg_send, sel};
 use objc2_foundation::{
-    CGRect, CGSize, MainThreadMarker, NSInteger, NSOperatingSystemVersion, NSProcessInfo,
+    CGRect, CGSize, MainThreadMarker, NSInteger, NSObjectProtocol, NSOperatingSystemVersion,
+    NSProcessInfo,
 };
+use objc2_ui_kit::{UIApplication, UICoordinateSpace, UIView, UIWindow};

-use super::uikit::UIView;
 use super::window::WinitUIWindow;
 use crate::dpi::PhysicalSize;
 use crate::event::{Event, InnerSizeWriter, StartCause, WindowEvent};
@@ -39,12 +40,9 @@ macro_rules! bug_assert {
    };
 }

-#[derive(Debug)]
-pub(crate) struct HandlePendingUserEvents;
-
 pub(crate) struct EventLoopHandler {
    #[allow(clippy::type_complexity)]
-    pub(crate) handler: Box<dyn FnMut(Event<HandlePendingUserEvents>, &RootActiveEventLoop)>,
+    pub(crate) handler: Box<dyn FnMut(Event, &RootActiveEventLoop)>,
    pub(crate) event_loop: RootActiveEventLoop,
 }

@@ -58,20 +56,20 @@ impl fmt::Debug for EventLoopHandler {
 }

 impl EventLoopHandler {
-    fn handle_event(&mut self, event: Event<HandlePendingUserEvents>) {
+    fn handle_event(&mut self, event: Event) {
        (self.handler)(event, &self.event_loop)
    }
 }

 #[derive(Debug)]
 pub(crate) enum EventWrapper {
-    StaticEvent(Event<HandlePendingUserEvents>),
+    StaticEvent(Event),
    ScaleFactorChanged(ScaleFactorChanged),
 }

 #[derive(Debug)]
 pub struct ScaleFactorChanged {
-    pub(super) window: Id<WinitUIWindow>,
+    pub(super) window: Retained<WinitUIWindow>,
    pub(super) suggested_size: PhysicalSize<u32>,
    pub(super) scale_factor: f64,
 }
@@ -87,7 +85,7 @@ enum UserCallbackTransitionResult<'a> {
    },
 }

-impl Event<HandlePendingUserEvents> {
+impl Event {
    fn is_redraw(&self) -> bool {
        matches!(self, Event::WindowEvent { event: WindowEvent::RedrawRequested, .. })
    }
@@ -98,25 +96,25 @@ impl Event<HandlePendingUserEvents> {
 #[must_use = "dropping `AppStateImpl` without inspecting it is probably a bug"]
 enum AppStateImpl {
    NotLaunched {
-        queued_windows: Vec<Id<WinitUIWindow>>,
+        queued_windows: Vec<Retained<WinitUIWindow>>,
        queued_events: Vec<EventWrapper>,
-        queued_gpu_redraws: HashSet<Id<WinitUIWindow>>,
+        queued_gpu_redraws: HashSet<Retained<WinitUIWindow>>,
    },
    Launching {
-        queued_windows: Vec<Id<WinitUIWindow>>,
+        queued_windows: Vec<Retained<WinitUIWindow>>,
        queued_events: Vec<EventWrapper>,
        queued_handler: EventLoopHandler,
-        queued_gpu_redraws: HashSet<Id<WinitUIWindow>>,
+        queued_gpu_redraws: HashSet<Retained<WinitUIWindow>>,
    },
    ProcessingEvents {
        handler: EventLoopHandler,
-        queued_gpu_redraws: HashSet<Id<WinitUIWindow>>,
+        queued_gpu_redraws: HashSet<Retained<WinitUIWindow>>,
        active_control_flow: ControlFlow,
    },
    // special state to deal with reentrancy and prevent mutable aliasing.
    InUserCallback {
        queued_events: Vec<EventWrapper>,
-        queued_gpu_redraws: HashSet<Id<WinitUIWindow>>,
+        queued_gpu_redraws: HashSet<Retained<WinitUIWindow>>,
    },
    ProcessingRedraws {
        handler: EventLoopHandler,
@@ -227,7 +225,9 @@ impl AppState {
        });
    }

-    fn did_finish_launching_transition(&mut self) -> (Vec<Id<WinitUIWindow>>, Vec<EventWrapper>) {
+    fn did_finish_launching_transition(
+        &mut self,
+    ) -> (Vec<Retained<WinitUIWindow>>, Vec<EventWrapper>) {
        let (windows, events, handler, queued_gpu_redraws) = match self.take_state() {
            AppStateImpl::Launching {
                queued_windows,
@@ -343,7 +343,7 @@ impl AppState {
        UserCallbackTransitionResult::Success { handler, active_control_flow, processing_redraws }
    }

-    fn main_events_cleared_transition(&mut self) -> HashSet<Id<WinitUIWindow>> {
+    fn main_events_cleared_transition(&mut self) -> HashSet<Retained<WinitUIWindow>> {
        let (handler, queued_gpu_redraws, active_control_flow) = match self.take_state() {
            AppStateImpl::ProcessingEvents { handler, queued_gpu_redraws, active_control_flow } => {
                (handler, queued_gpu_redraws, active_control_flow)
@@ -411,7 +411,7 @@ impl AppState {
    }
 }

-pub(crate) fn set_key_window(mtm: MainThreadMarker, window: &Id<WinitUIWindow>) {
+pub(crate) fn set_key_window(mtm: MainThreadMarker, window: &Retained<WinitUIWindow>) {
    let mut this = AppState::get_mut(mtm);
    match this.state_mut() {
        &mut AppStateImpl::NotLaunched { ref mut queued_windows, .. } => {
@@ -431,7 +431,7 @@ pub(crate) fn set_key_window(mtm: MainThreadMarker, window: &Id<WinitUIWindow>)
    window.makeKeyAndVisible();
 }

-pub(crate) fn queue_gl_or_metal_redraw(mtm: MainThreadMarker, window: Id<WinitUIWindow>) {
+pub(crate) fn queue_gl_or_metal_redraw(mtm: MainThreadMarker, window: Retained<WinitUIWindow>) {
    let mut this = AppState::get_mut(mtm);
    match this.state_mut() {
        &mut AppStateImpl::NotLaunched { ref mut queued_gpu_redraws, .. }
@@ -622,7 +622,7 @@ fn handle_user_events(mtm: MainThreadMarker) {
    }
    drop(this);

-    handler.handle_event(Event::UserEvent(HandlePendingUserEvents));
+    handler.handle_event(Event::UserWakeUp);

    loop {
        let mut this = AppState::get_mut(mtm);
@@ -655,10 +655,32 @@ fn handle_user_events(mtm: MainThreadMarker) {
            }
        }

-        handler.handle_event(Event::UserEvent(HandlePendingUserEvents));
+        handler.handle_event(Event::UserWakeUp);
    }
 }

+pub(crate) fn send_occluded_event_for_all_windows(application: &UIApplication, occluded: bool) {
+    let mtm = MainThreadMarker::from(application);
+
+    let mut events = Vec::new();
+    #[allow(deprecated)]
+    for window in application.windows().iter() {
+        if window.is_kind_of::<WinitUIWindow>() {
+            // SAFETY: We just checked that the window is a `winit` window
+            let window = unsafe {
+                let ptr: *const UIWindow = window;
+                let ptr: *const WinitUIWindow = ptr.cast();
+                &*ptr
+            };
+            events.push(EventWrapper::StaticEvent(Event::WindowEvent {
+                window_id: RootWindowId(window.id()),
+                event: WindowEvent::Occluded(occluded),
+            }));
+        }
+    }
+    handle_nonuser_events(mtm, events);
+}
+
 pub fn handle_main_events_cleared(mtm: MainThreadMarker) {
    let mut this = AppState::get_mut(mtm);
    if !this.has_launched() || this.has_terminated() {
@@ -693,7 +715,27 @@ pub fn handle_events_cleared(mtm: MainThreadMarker) {
    AppState::get_mut(mtm).events_cleared_transition();
 }

-pub fn terminated(mtm: MainThreadMarker) {
+pub(crate) fn terminated(application: &UIApplication) {
+    let mtm = MainThreadMarker::from(application);
+
+    let mut events = Vec::new();
+    #[allow(deprecated)]
+    for window in application.windows().iter() {
+        if window.is_kind_of::<WinitUIWindow>() {
+            // SAFETY: We just checked that the window is a `winit` window
+            let window = unsafe {
+                let ptr: *const UIWindow = window;
+                let ptr: *const WinitUIWindow = ptr.cast();
+                &*ptr
+            };
+            events.push(EventWrapper::StaticEvent(Event::WindowEvent {
+                window_id: RootWindowId(window.id()),
+                event: WindowEvent::Destroyed,
+            }));
+        }
+    }
+    handle_nonuser_events(mtm, events);
+
    let mut this = AppState::get_mut(mtm);
    let mut handler = this.terminated_transition();
    drop(this);
@@ -721,7 +763,7 @@ fn handle_hidpi_proxy(handler: &mut EventLoopHandler, event: ScaleFactorChanged)
    view.setFrame(new_frame);
 }

-fn get_view_and_screen_frame(window: &WinitUIWindow) -> (Id<UIView>, CGRect) {
+fn get_view_and_screen_frame(window: &WinitUIWindow) -> (Retained<UIView>, CGRect) {
    let view_controller = window.rootViewController().unwrap();
    let view = view_controller.view().unwrap();
    let bounds = window.bounds();
@@ -753,25 +795,25 @@ impl EventLoopWaker {
            // future, but that gets changed to fire immediately in did_finish_launching
            let timer = CFRunLoopTimerCreate(
                ptr::null_mut(),
-                std::f64::MAX,
+                f64::MAX,
                0.000_000_1,
                0,
                0,
                wakeup_main_loop,
                ptr::null_mut(),
            );
-            CFRunLoopAddTimer(rl, timer, kCFRunLoopCommonModes);
+            CFRunLoopAddTimer(rl, timer, kCFRunLoopDefaultMode);

            EventLoopWaker { timer }
        }
    }

    fn stop(&mut self) {
-        unsafe { CFRunLoopTimerSetNextFireDate(self.timer, std::f64::MAX) }
+        unsafe { CFRunLoopTimerSetNextFireDate(self.timer, f64::MAX) }
    }

    fn start(&mut self) {
-        unsafe { CFRunLoopTimerSetNextFireDate(self.timer, std::f64::MIN) }
+        unsafe { CFRunLoopTimerSetNextFireDate(self.timer, f64::MIN) }
    }

    fn start_at(&mut self, instant: Instant) {
@@ -857,23 +899,17 @@ fn meets_requirements(
 }

 fn get_version() -> NSOperatingSystemVersion {
-    unsafe {
-        let process_info = NSProcessInfo::processInfo();
-        let atleast_ios_8: bool = msg_send![
-            &process_info,
-            respondsToSelector: sel!(operatingSystemVersion)
-        ];
-        // winit requires atleast iOS 8 because no one has put the time into supporting earlier os
-        // versions. Older iOS versions are increasingly difficult to test. For example,
-        // Xcode 11 does not support debugging on devices with an iOS version of less than
-        // 8. Another example, in order to use an iOS simulator older than iOS 8, you must
-        // download an older version of Xcode (<9), and at least Xcode 7 has been tested to
-        // not even run on macOS 10.15 - Xcode 8 might?
-        //
-        // The minimum required iOS version is likely to grow in the future.
-        assert!(atleast_ios_8, "`winit` requires iOS version 8 or greater");
-        process_info.operatingSystemVersion()
-    }
+    let process_info = NSProcessInfo::processInfo();
+    let atleast_ios_8 = process_info.respondsToSelector(sel!(operatingSystemVersion));
+    // Winit requires atleast iOS 8 because no one has put the time into supporting earlier os
+    // versions. Older iOS versions are increasingly difficult to test. For example, Xcode 11 does
+    // not support debugging on devices with an iOS version of less than 8. Another example, in
+    // order to use an iOS simulator older than iOS 8, you must download an older version of Xcode
+    // (<9), and at least Xcode 7 has been tested to not even run on macOS 10.15 - Xcode 8 might?
+    //
+    // The minimum required iOS version is likely to grow in the future.
+    assert!(atleast_ios_8, "`winit` requires iOS version 8 or greater");
+    process_info.operatingSystemVersion()
 }

 pub fn os_capabilities() -> OSCapabilities {
--- a/src/platform_impl/apple/uikit/event_loop.rs
+++ b/src/platform_impl/apple/uikit/event_loop.rs
@@ -1,31 +1,31 @@
 use std::collections::VecDeque;
-use std::ffi::c_void;
+use std::ffi::{c_char, c_int, c_void};
 use std::marker::PhantomData;
-use std::ptr;
-use std::sync::mpsc::{self, Receiver, Sender};
+use std::ptr::{self, NonNull};
+use std::sync::atomic::{AtomicBool, Ordering as AtomicOrdering};
+use std::sync::Arc;

 use core_foundation::base::{CFIndex, CFRelease};
 use core_foundation::runloop::{
-    kCFRunLoopAfterWaiting, kCFRunLoopBeforeWaiting, kCFRunLoopCommonModes, kCFRunLoopDefaultMode,
-    kCFRunLoopExit, CFRunLoopActivity, CFRunLoopAddObserver, CFRunLoopAddSource, CFRunLoopGetMain,
+    kCFRunLoopAfterWaiting, kCFRunLoopBeforeWaiting, kCFRunLoopDefaultMode, kCFRunLoopExit,
+    CFRunLoopActivity, CFRunLoopAddObserver, CFRunLoopAddSource, CFRunLoopGetMain,
    CFRunLoopObserverCreate, CFRunLoopObserverRef, CFRunLoopSourceContext, CFRunLoopSourceCreate,
    CFRunLoopSourceInvalidate, CFRunLoopSourceRef, CFRunLoopSourceSignal, CFRunLoopWakeUp,
 };
-use objc2::ClassType;
+use objc2::rc::Retained;
+use objc2::{msg_send_id, ClassType};
 use objc2_foundation::{MainThreadMarker, NSString};
+use objc2_ui_kit::{UIApplication, UIApplicationMain, UIScreen};

+use super::app_state::EventLoopHandler;
+use crate::application::ApplicationHandler;
 use crate::error::EventLoopError;
 use crate::event::Event;
-use crate::event_loop::{
-    ActiveEventLoop as RootActiveEventLoop, ControlFlow, DeviceEvents, EventLoopClosed,
-};
-use crate::platform::ios::Idiom;
-use crate::platform_impl::platform::app_state::{EventLoopHandler, HandlePendingUserEvents};
+use crate::event_loop::{ActiveEventLoop as RootActiveEventLoop, ControlFlow, DeviceEvents};
 use crate::window::{CustomCursor, CustomCursorSource};

 use super::app_delegate::AppDelegate;
 use super::app_state::AppState;
-use super::uikit::{UIApplication, UIApplicationMain, UIDevice, UIScreen, UIUserInterfaceIdiom};
 use super::{app_state, monitor, MonitorHandle};

 #[derive(Debug)]
@@ -44,7 +44,8 @@ impl ActiveEventLoop {
    }

    pub fn primary_monitor(&self) -> Option<MonitorHandle> {
-        Some(MonitorHandle::new(UIScreen::main(self.mtm)))
+        #[allow(deprecated)]
+        Some(MonitorHandle::new(UIScreen::mainScreen(self.mtm)))
    }

    #[inline]
@@ -106,34 +107,44 @@ impl OwnedDisplayHandle {
    }
 }

-fn map_user_event<T: 'static>(
-    mut handler: impl FnMut(Event<T>, &RootActiveEventLoop),
-    receiver: mpsc::Receiver<T>,
-) -> impl FnMut(Event<HandlePendingUserEvents>, &RootActiveEventLoop) {
-    move |event, window_target| match event.map_nonuser_event() {
-        Ok(event) => (handler)(event, window_target),
-        Err(_) => {
-            for event in receiver.try_iter() {
-                (handler)(Event::UserEvent(event), window_target);
+fn map_user_event<A: ApplicationHandler>(
+    app: &mut A,
+    proxy_wake_up: Arc<AtomicBool>,
+) -> impl FnMut(Event, &RootActiveEventLoop) + '_ {
+    move |event, window_target| match event {
+        Event::NewEvents(cause) => app.new_events(window_target, cause),
+        Event::WindowEvent { window_id, event } => {
+            app.window_event(window_target, window_id, event)
+        },
+        Event::DeviceEvent { device_id, event } => {
+            app.device_event(window_target, device_id, event)
+        },
+        Event::UserWakeUp => {
+            if proxy_wake_up.swap(false, AtomicOrdering::Relaxed) {
+                app.proxy_wake_up(window_target);
            }
        },
+        Event::Suspended => app.suspended(window_target),
+        Event::Resumed => app.resumed(window_target),
+        Event::AboutToWait => app.about_to_wait(window_target),
+        Event::LoopExiting => app.exiting(window_target),
+        Event::MemoryWarning => app.memory_warning(window_target),
    }
 }

-pub struct EventLoop<T: 'static> {
+pub struct EventLoop {
    mtm: MainThreadMarker,
-    sender: Sender<T>,
-    receiver: Receiver<T>,
+    proxy_wake_up: Arc<AtomicBool>,
    window_target: RootActiveEventLoop,
 }

 #[derive(Default, Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub(crate) struct PlatformSpecificEventLoopAttributes {}

-impl<T: 'static> EventLoop<T> {
+impl EventLoop {
    pub(crate) fn new(
        _: &PlatformSpecificEventLoopAttributes,
-    ) -> Result<EventLoop<T>, EventLoopError> {
+    ) -> Result<EventLoop, EventLoopError> {
        let mtm = MainThreadMarker::new()
            .expect("On iOS, `EventLoop` must be created on the main thread");

@@ -146,24 +157,21 @@ impl<T: 'static> EventLoop<T> {
            SINGLETON_INIT = true;
        }

-        let (sender, receiver) = mpsc::channel();
-
        // this line sets up the main run loop before `UIApplicationMain`
        setup_control_flow_observers();

+        let proxy_wake_up = Arc::new(AtomicBool::new(false));
+
        Ok(EventLoop {
            mtm,
-            sender,
-            receiver,
+            proxy_wake_up,
            window_target: RootActiveEventLoop { p: ActiveEventLoop { mtm }, _marker: PhantomData },
        })
    }

-    pub fn run<F>(self, handler: F) -> !
-    where
-        F: FnMut(Event<T>, &RootActiveEventLoop),
-    {
-        let application = UIApplication::shared(self.mtm);
+    pub fn run_app<A: ApplicationHandler>(self, app: &mut A) -> ! {
+        let application: Option<Retained<UIApplication>> =
+            unsafe { msg_send_id![UIApplication::class(), sharedApplication] };
        assert!(
            application.is_none(),
            "\
@@ -171,12 +179,12 @@ impl<T: 'static> EventLoop<T> {
             `EventLoop::run_app` calls `UIApplicationMain` on iOS",
        );

-        let handler = map_user_event(handler, self.receiver);
+        let handler = map_user_event(app, self.proxy_wake_up.clone());

        let handler = unsafe {
            std::mem::transmute::<
-                Box<dyn FnMut(Event<HandlePendingUserEvents>, &RootActiveEventLoop)>,
-                Box<dyn FnMut(Event<HandlePendingUserEvents>, &RootActiveEventLoop)>,
+                Box<dyn FnMut(Event, &RootActiveEventLoop)>,
+                Box<dyn FnMut(Event, &RootActiveEventLoop)>,
            >(Box::new(handler))
        };

@@ -187,14 +195,25 @@ impl<T: 'static> EventLoop<T> {
        // Ensure application delegate is initialized
        let _ = AppDelegate::class();

+        extern "C" {
+            // These functions are in crt_externs.h.
+            fn _NSGetArgc() -> *mut c_int;
+            fn _NSGetArgv() -> *mut *mut *mut c_char;
+        }
+
        unsafe {
-            UIApplicationMain(0, ptr::null(), None, Some(&NSString::from_str(AppDelegate::NAME)))
+            UIApplicationMain(
+                *_NSGetArgc(),
+                NonNull::new(*_NSGetArgv()).unwrap(),
+                None,
+                Some(&NSString::from_str(AppDelegate::NAME)),
+            )
        };
        unreachable!()
    }

-    pub fn create_proxy(&self) -> EventLoopProxy<T> {
-        EventLoopProxy::new(self.sender.clone())
+    pub fn create_proxy(&self) -> EventLoopProxy {
+        EventLoopProxy::new(self.proxy_wake_up.clone())
    }

    pub fn window_target(&self) -> &RootActiveEventLoop {
@@ -202,35 +221,21 @@ impl<T: 'static> EventLoop<T> {
    }
 }

-// EventLoopExtIOS
-impl<T: 'static> EventLoop<T> {
-    pub fn idiom(&self) -> Idiom {
-        match UIDevice::current(self.mtm).userInterfaceIdiom() {
-            UIUserInterfaceIdiom::Unspecified => Idiom::Unspecified,
-            UIUserInterfaceIdiom::Phone => Idiom::Phone,
-            UIUserInterfaceIdiom::Pad => Idiom::Pad,
-            UIUserInterfaceIdiom::TV => Idiom::TV,
-            UIUserInterfaceIdiom::CarPlay => Idiom::CarPlay,
-            _ => Idiom::Unspecified,
-        }
-    }
-}
-
-pub struct EventLoopProxy<T> {
-    sender: Sender<T>,
+pub struct EventLoopProxy {
+    proxy_wake_up: Arc<AtomicBool>,
    source: CFRunLoopSourceRef,
 }

-unsafe impl<T: Send> Send for EventLoopProxy<T> {}
-unsafe impl<T: Send> Sync for EventLoopProxy<T> {}
+unsafe impl Send for EventLoopProxy {}
+unsafe impl Sync for EventLoopProxy {}

-impl<T> Clone for EventLoopProxy<T> {
-    fn clone(&self) -> EventLoopProxy<T> {
-        EventLoopProxy::new(self.sender.clone())
+impl Clone for EventLoopProxy {
+    fn clone(&self) -> EventLoopProxy {
+        EventLoopProxy::new(self.proxy_wake_up.clone())
    }
 }

-impl<T> Drop for EventLoopProxy<T> {
+impl Drop for EventLoopProxy {
    fn drop(&mut self) {
        unsafe {
            CFRunLoopSourceInvalidate(self.source);
@@ -239,8 +244,8 @@ impl<T> Drop for EventLoopProxy<T> {
    }
 }

-impl<T> EventLoopProxy<T> {
-    fn new(sender: Sender<T>) -> EventLoopProxy<T> {
+impl EventLoopProxy {
+    fn new(proxy_wake_up: Arc<AtomicBool>) -> EventLoopProxy {
        unsafe {
            // just wake up the eventloop
            extern "C" fn event_loop_proxy_handler(_: *const c_void) {}
@@ -260,24 +265,22 @@ impl<T> EventLoopProxy<T> {
                cancel: None,
                perform: event_loop_proxy_handler,
            };
-            let source =
-                CFRunLoopSourceCreate(ptr::null_mut(), CFIndex::max_value() - 1, &mut context);
-            CFRunLoopAddSource(rl, source, kCFRunLoopCommonModes);
+            let source = CFRunLoopSourceCreate(ptr::null_mut(), CFIndex::MAX - 1, &mut context);
+            CFRunLoopAddSource(rl, source, kCFRunLoopDefaultMode);
            CFRunLoopWakeUp(rl);

-            EventLoopProxy { sender, source }
+            EventLoopProxy { proxy_wake_up, source }
        }
    }

-    pub fn send_event(&self, event: T) -> Result<(), EventLoopClosed<T>> {
-        self.sender.send(event).map_err(|::std::sync::mpsc::SendError(x)| EventLoopClosed(x))?;
+    pub fn wake_up(&self) {
+        self.proxy_wake_up.store(true, AtomicOrdering::Relaxed);
        unsafe {
            // let the main thread know there's a new event
            CFRunLoopSourceSignal(self.source);
            let rl = CFRunLoopGetMain();
            CFRunLoopWakeUp(rl);
        }
-        Ok(())
    }
 }

@@ -344,7 +347,7 @@ fn setup_control_flow_observers() {
            ptr::null_mut(),
            kCFRunLoopAfterWaiting,
            1, // repeat = true
-            CFIndex::min_value(),
+            CFIndex::MIN,
            control_flow_begin_handler,
            ptr::null_mut(),
        );
@@ -364,7 +367,7 @@ fn setup_control_flow_observers() {
            ptr::null_mut(),
            kCFRunLoopExit | kCFRunLoopBeforeWaiting,
            1, // repeat = true
-            CFIndex::max_value(),
+            CFIndex::MAX,
            control_flow_end_handler,
            ptr::null_mut(),
        );
--- a/src/platform_impl/apple/uikit/mod.rs
+++ b/src/platform_impl/apple/uikit/mod.rs
@@ -1,11 +1,9 @@
-#![cfg(ios_platform)]
 #![allow(clippy::let_unit_value)]

 mod app_delegate;
 mod app_state;
 mod event_loop;
 mod monitor;
-mod uikit;
 mod view;
 mod view_controller;
 mod window;
--- a/src/platform_impl/apple/uikit/monitor.rs
+++ b/src/platform_impl/apple/uikit/monitor.rs
@@ -4,22 +4,22 @@ use std::collections::{BTreeSet, VecDeque};
 use std::{fmt, hash, ptr};

 use objc2::mutability::IsRetainable;
-use objc2::rc::Id;
+use objc2::rc::Retained;
 use objc2::Message;
 use objc2_foundation::{run_on_main, MainThreadBound, MainThreadMarker, NSInteger};
+use objc2_ui_kit::{UIScreen, UIScreenMode};

-use super::uikit::{UIScreen, UIScreenMode};
+use super::app_state;
 use crate::dpi::{PhysicalPosition, PhysicalSize};
 use crate::monitor::VideoModeHandle as RootVideoModeHandle;
-use crate::platform_impl::platform::app_state;

 // Workaround for `MainThreadBound` implementing almost no traits
 #[derive(Debug)]
-struct MainThreadBoundDelegateImpls<T>(MainThreadBound<Id<T>>);
+struct MainThreadBoundDelegateImpls<T>(MainThreadBound<Retained<T>>);

 impl<T: IsRetainable + Message> Clone for MainThreadBoundDelegateImpls<T> {
    fn clone(&self) -> Self {
-        Self(run_on_main(|mtm| MainThreadBound::new(Id::clone(self.0.get(mtm)), mtm)))
+        Self(run_on_main(|mtm| MainThreadBound::new(Retained::clone(self.0.get(mtm)), mtm)))
    }
 }

@@ -27,7 +27,7 @@ impl<T: IsRetainable + Message> hash::Hash for MainThreadBoundDelegateImpls<T> {
    fn hash<H: hash::Hasher>(&self, state: &mut H) {
        // SAFETY: Marker only used to get the pointer
        let mtm = unsafe { MainThreadMarker::new_unchecked() };
-        Id::as_ptr(self.0.get(mtm)).hash(state);
+        Retained::as_ptr(self.0.get(mtm)).hash(state);
    }
 }

@@ -35,7 +35,7 @@ impl<T: IsRetainable + Message> PartialEq for MainThreadBoundDelegateImpls<T> {
    fn eq(&self, other: &Self) -> bool {
        // SAFETY: Marker only used to get the pointer
        let mtm = unsafe { MainThreadMarker::new_unchecked() };
-        Id::as_ptr(self.0.get(mtm)) == Id::as_ptr(other.0.get(mtm))
+        Retained::as_ptr(self.0.get(mtm)) == Retained::as_ptr(other.0.get(mtm))
    }
 }

@@ -52,8 +52,8 @@ pub struct VideoModeHandle {

 impl VideoModeHandle {
    fn new(
-        uiscreen: Id<UIScreen>,
-        screen_mode: Id<UIScreenMode>,
+        uiscreen: Retained<UIScreen>,
+        screen_mode: Retained<UIScreenMode>,
        mtm: MainThreadMarker,
    ) -> VideoModeHandle {
        let refresh_rate_millihertz = refresh_rate_millihertz(&uiscreen);
@@ -83,13 +83,13 @@ impl VideoModeHandle {
        self.monitor.clone()
    }

-    pub(super) fn screen_mode(&self, mtm: MainThreadMarker) -> &Id<UIScreenMode> {
+    pub(super) fn screen_mode(&self, mtm: MainThreadMarker) -> &Retained<UIScreenMode> {
        self.screen_mode.0.get(mtm)
    }
 }

 pub struct MonitorHandle {
-    ui_screen: MainThreadBound<Id<UIScreen>>,
+    ui_screen: MainThreadBound<Retained<UIScreen>>,
 }

 impl Clone for MonitorHandle {
@@ -140,20 +140,22 @@ impl fmt::Debug for MonitorHandle {
 }

 impl MonitorHandle {
-    pub(crate) fn new(ui_screen: Id<UIScreen>) -> Self {
-        // Holding `Id<UIScreen>` implies we're on the main thread.
+    pub(crate) fn new(ui_screen: Retained<UIScreen>) -> Self {
+        // Holding `Retained<UIScreen>` implies we're on the main thread.
        let mtm = MainThreadMarker::new().unwrap();
        Self { ui_screen: MainThreadBound::new(ui_screen, mtm) }
    }

    pub fn name(&self) -> Option<String> {
        run_on_main(|mtm| {
-            let main = UIScreen::main(mtm);
+            #[allow(deprecated)]
+            let main = UIScreen::mainScreen(mtm);
            if *self.ui_screen(mtm) == main {
                Some("Primary".to_string())
-            } else if *self.ui_screen(mtm) == main.mirroredScreen() {
+            } else if Some(self.ui_screen(mtm)) == main.mirroredScreen().as_ref() {
                Some("Mirrored".to_string())
            } else {
+                #[allow(deprecated)]
                UIScreen::screens(mtm)
                    .iter()
                    .position(|rhs| rhs == &**self.ui_screen(mtm))
@@ -197,7 +199,7 @@ impl MonitorHandle {
        })
    }

-    pub(crate) fn ui_screen(&self, mtm: MainThreadMarker) -> &Id<UIScreen> {
+    pub(crate) fn ui_screen(&self, mtm: MainThreadMarker) -> &Retained<UIScreen> {
        self.ui_screen.get(mtm)
    }

@@ -237,5 +239,6 @@ fn refresh_rate_millihertz(uiscreen: &UIScreen) -> u32 {
 }

 pub fn uiscreens(mtm: MainThreadMarker) -> VecDeque<MonitorHandle> {
+    #[allow(deprecated)]
    UIScreen::screens(mtm).into_iter().map(MonitorHandle::new).collect()
 }
--- a/src/platform_impl/apple/uikit/view.rs
+++ b/src/platform_impl/apple/uikit/view.rs
@@ -1,31 +1,29 @@
 #![allow(clippy::unnecessary_cast)]
 use std::cell::{Cell, RefCell};

-use objc2::rc::Id;
-use objc2::runtime::{AnyClass, NSObjectProtocol, ProtocolObject};
-use objc2::{
-    declare_class, extern_methods, msg_send, msg_send_id, mutability, sel, ClassType, DeclaredClass,
-};
+use objc2::rc::Retained;
+use objc2::runtime::{NSObjectProtocol, ProtocolObject};
+use objc2::{declare_class, msg_send, msg_send_id, mutability, sel, ClassType, DeclaredClass};
 use objc2_foundation::{CGFloat, CGPoint, CGRect, MainThreadMarker, NSObject, NSSet};
+use objc2_ui_kit::{
+    UICoordinateSpace, UIEvent, UIForceTouchCapability, UIGestureRecognizer,
+    UIGestureRecognizerDelegate, UIGestureRecognizerState, UIPanGestureRecognizer,
+    UIPinchGestureRecognizer, UIResponder, UIRotationGestureRecognizer, UITapGestureRecognizer,
+    UITouch, UITouchPhase, UITouchType, UITraitEnvironment, UIView,
+};

 use super::app_state::{self, EventWrapper};
-use super::uikit::{
-    UIEvent, UIForceTouchCapability, UIGestureRecognizer, UIGestureRecognizerDelegate,
-    UIGestureRecognizerState, UIPanGestureRecognizer, UIPinchGestureRecognizer, UIResponder,
-    UIRotationGestureRecognizer, UITapGestureRecognizer, UITouch, UITouchPhase, UITouchType,
-    UITraitCollection, UIView,
-};
 use super::window::WinitUIWindow;
+use super::DEVICE_ID;
 use crate::dpi::PhysicalPosition;
 use crate::event::{Event, Force, Touch, TouchPhase, WindowEvent};
-use crate::platform_impl::platform::DEVICE_ID;
 use crate::window::{WindowAttributes, WindowId as RootWindowId};

 pub struct WinitViewState {
-    pinch_gesture_recognizer: RefCell<Option<Id<UIPinchGestureRecognizer>>>,
-    doubletap_gesture_recognizer: RefCell<Option<Id<UITapGestureRecognizer>>>,
-    rotation_gesture_recognizer: RefCell<Option<Id<UIRotationGestureRecognizer>>>,
-    pan_gesture_recognizer: RefCell<Option<Id<UIPanGestureRecognizer>>>,
+    pinch_gesture_recognizer: RefCell<Option<Retained<UIPinchGestureRecognizer>>>,
+    doubletap_gesture_recognizer: RefCell<Option<Retained<UITapGestureRecognizer>>>,
+    rotation_gesture_recognizer: RefCell<Option<Retained<UIRotationGestureRecognizer>>>,
+    pan_gesture_recognizer: RefCell<Option<Retained<UIPanGestureRecognizer>>>,

    // for iOS delta references the start of the Gesture
    rotation_last_delta: Cell<CGFloat>,
@@ -39,7 +37,7 @@ declare_class!(
    unsafe impl ClassType for WinitView {
        #[inherits(UIResponder, NSObject)]
        type Super = UIView;
-        type Mutability = mutability::InteriorMutable;
+        type Mutability = mutability::MainThreadOnly;
        const NAME: &'static str = "WinitUIView";
    }

@@ -270,7 +268,7 @@ declare_class!(
        fn pan_gesture(&self, recognizer: &UIPanGestureRecognizer) {
            let window = self.window().unwrap();

-            let translation = recognizer.translationInView(self);
+            let translation = recognizer.translationInView(Some(self));

            let (phase, dx, dy) = match recognizer.state() {
                UIGestureRecognizerState::Began => {
@@ -328,30 +326,13 @@ declare_class!(
    }
 );

-extern_methods!(
-    #[allow(non_snake_case)]
-    unsafe impl WinitView {
-        fn window(&self) -> Option<Id<WinitUIWindow>> {
-            unsafe { msg_send_id![self, window] }
-        }
-
-        unsafe fn traitCollection(&self) -> Id<UITraitCollection> {
-            msg_send_id![self, traitCollection]
-        }
-
-        // TODO: Allow the user to customize this
-        #[method(layerClass)]
-        pub(crate) fn layerClass() -> &'static AnyClass;
-    }
-);
-
 impl WinitView {
    pub(crate) fn new(
-        _mtm: MainThreadMarker,
+        mtm: MainThreadMarker,
        window_attributes: &WindowAttributes,
        frame: CGRect,
-    ) -> Id<Self> {
-        let this = Self::alloc().set_ivars(WinitViewState {
+    ) -> Retained<Self> {
+        let this = mtm.alloc().set_ivars(WinitViewState {
            pinch_gesture_recognizer: RefCell::new(None),
            doubletap_gesture_recognizer: RefCell::new(None),
            rotation_gesture_recognizer: RefCell::new(None),
@@ -361,7 +342,7 @@ impl WinitView {
            pinch_last_delta: Cell::new(0.0),
            pan_last_delta: Cell::new(CGPoint { x: 0.0, y: 0.0 }),
        });
-        let this: Id<Self> = unsafe { msg_send_id![super(this), initWithFrame: frame] };
+        let this: Retained<Self> = unsafe { msg_send_id![super(this), initWithFrame: frame] };

        this.setMultipleTouchEnabled(true);

@@ -372,13 +353,23 @@ impl WinitView {
        this
    }

+    fn window(&self) -> Option<Retained<WinitUIWindow>> {
+        // SAFETY: `WinitView`s are always installed in a `WinitUIWindow`
+        (**self).window().map(|window| unsafe { Retained::cast(window) })
+    }
+
    pub(crate) fn recognize_pinch_gesture(&self, should_recognize: bool) {
+        let mtm = MainThreadMarker::from(self);
        if should_recognize {
            if self.ivars().pinch_gesture_recognizer.borrow().is_none() {
-                let pinch: Id<UIPinchGestureRecognizer> = unsafe {
-                    msg_send_id![UIPinchGestureRecognizer::alloc(), initWithTarget: self, action: sel!(pinchGesture:)]
+                let pinch = unsafe {
+                    UIPinchGestureRecognizer::initWithTarget_action(
+                        mtm.alloc(),
+                        Some(self),
+                        Some(sel!(pinchGesture:)),
+                    )
                };
-                pinch.setDelegate(ProtocolObject::from_ref(self));
+                pinch.setDelegate(Some(ProtocolObject::from_ref(self)));
                self.addGestureRecognizer(&pinch);
                self.ivars().pinch_gesture_recognizer.replace(Some(pinch));
            }
@@ -393,12 +384,17 @@ impl WinitView {
        minimum_number_of_touches: u8,
        maximum_number_of_touches: u8,
    ) {
+        let mtm = MainThreadMarker::from(self);
        if should_recognize {
            if self.ivars().pan_gesture_recognizer.borrow().is_none() {
-                let pan: Id<UIPanGestureRecognizer> = unsafe {
-                    msg_send_id![UIPanGestureRecognizer::alloc(), initWithTarget: self, action: sel!(panGesture:)]
+                let pan = unsafe {
+                    UIPanGestureRecognizer::initWithTarget_action(
+                        mtm.alloc(),
+                        Some(self),
+                        Some(sel!(panGesture:)),
+                    )
                };
-                pan.setDelegate(ProtocolObject::from_ref(self));
+                pan.setDelegate(Some(ProtocolObject::from_ref(self)));
                pan.setMinimumNumberOfTouches(minimum_number_of_touches as _);
                pan.setMaximumNumberOfTouches(maximum_number_of_touches as _);
                self.addGestureRecognizer(&pan);
@@ -410,12 +406,17 @@ impl WinitView {
    }

    pub(crate) fn recognize_doubletap_gesture(&self, should_recognize: bool) {
+        let mtm = MainThreadMarker::from(self);
        if should_recognize {
            if self.ivars().doubletap_gesture_recognizer.borrow().is_none() {
-                let tap: Id<UITapGestureRecognizer> = unsafe {
-                    msg_send_id![UITapGestureRecognizer::alloc(), initWithTarget: self, action: sel!(doubleTapGesture:)]
+                let tap = unsafe {
+                    UITapGestureRecognizer::initWithTarget_action(
+                        mtm.alloc(),
+                        Some(self),
+                        Some(sel!(doubleTapGesture:)),
+                    )
                };
-                tap.setDelegate(ProtocolObject::from_ref(self));
+                tap.setDelegate(Some(ProtocolObject::from_ref(self)));
                tap.setNumberOfTapsRequired(2);
                tap.setNumberOfTouchesRequired(1);
                self.addGestureRecognizer(&tap);
@@ -427,12 +428,17 @@ impl WinitView {
    }

    pub(crate) fn recognize_rotation_gesture(&self, should_recognize: bool) {
+        let mtm = MainThreadMarker::from(self);
        if should_recognize {
            if self.ivars().rotation_gesture_recognizer.borrow().is_none() {
-                let rotation: Id<UIRotationGestureRecognizer> = unsafe {
-                    msg_send_id![UIRotationGestureRecognizer::alloc(), initWithTarget: self, action: sel!(rotationGesture:)]
+                let rotation = unsafe {
+                    UIRotationGestureRecognizer::initWithTarget_action(
+                        mtm.alloc(),
+                        Some(self),
+                        Some(sel!(rotationGesture:)),
+                    )
                };
-                rotation.setDelegate(ProtocolObject::from_ref(self));
+                rotation.setDelegate(Some(ProtocolObject::from_ref(self)));
                self.addGestureRecognizer(&rotation);
                self.ivars().rotation_gesture_recognizer.replace(Some(rotation));
            }
@@ -447,9 +453,9 @@ impl WinitView {
        let os_supports_force = app_state::os_capabilities().force_touch;
        for touch in touches {
            let logical_location = touch.locationInView(None);
-            let touch_type = touch.type_();
+            let touch_type = touch.r#type();
            let force = if os_supports_force {
-                let trait_collection = unsafe { self.traitCollection() };
+                let trait_collection = self.traitCollection();
                let touch_capability = trait_collection.forceTouchCapability();
                // Both the OS _and_ the device need to be checked for force touch support.
                if touch_capability == UIForceTouchCapability::Available
@@ -482,7 +488,7 @@ impl WinitView {
                // 2 is UITouchPhase::Stationary and is not expected here
                UITouchPhase::Ended => TouchPhase::Ended,
                UITouchPhase::Cancelled => TouchPhase::Cancelled,
-                _ => panic!("unexpected touch phase: {:?}", phase as i32),
+                _ => panic!("unexpected touch phase: {phase:?}"),
            };

            let physical_location = {
--- a/src/platform_impl/apple/uikit/view_controller.rs
+++ b/src/platform_impl/apple/uikit/view_controller.rs
@@ -1,14 +1,14 @@
 use std::cell::Cell;

-use objc2::rc::Id;
+use objc2::rc::Retained;
 use objc2::{declare_class, msg_send_id, mutability, ClassType, DeclaredClass};
 use objc2_foundation::{MainThreadMarker, NSObject};
-
-use super::app_state::{self};
-use super::uikit::{
+use objc2_ui_kit::{
    UIDevice, UIInterfaceOrientationMask, UIRectEdge, UIResponder, UIStatusBarStyle,
    UIUserInterfaceIdiom, UIView, UIViewController,
 };
+
+use super::app_state::{self};
 use crate::platform::ios::{ScreenEdge, StatusBarStyle, ValidOrientations};
 use crate::window::WindowAttributes;

@@ -26,7 +26,7 @@ declare_class!(
    unsafe impl ClassType for WinitViewController {
        #[inherits(UIResponder, NSObject)]
        type Super = UIViewController;
-        type Mutability = mutability::InteriorMutable;
+        type Mutability = mutability::MainThreadOnly;
        const NAME: &'static str = "WinitUIViewController";
    }

@@ -114,7 +114,7 @@ impl WinitViewController {
        mtm: MainThreadMarker,
        valid_orientations: ValidOrientations,
    ) {
-        let mask = match (valid_orientations, UIDevice::current(mtm).userInterfaceIdiom()) {
+        let mask = match (valid_orientations, UIDevice::currentDevice(mtm).userInterfaceIdiom()) {
            (ValidOrientations::LandscapeAndPortrait, UIUserInterfaceIdiom::Phone) => {
                UIInterfaceOrientationMask::AllButUpsideDown
            },
@@ -129,23 +129,24 @@ impl WinitViewController {
            },
        };
        self.ivars().supported_orientations.set(mask);
-        UIViewController::attemptRotationToDeviceOrientation();
+        #[allow(deprecated)]
+        UIViewController::attemptRotationToDeviceOrientation(mtm);
    }

    pub(crate) fn new(
        mtm: MainThreadMarker,
        window_attributes: &WindowAttributes,
        view: &UIView,
-    ) -> Id<Self> {
+    ) -> Retained<Self> {
        // These are set properly below, we just to set them to something in the meantime.
-        let this = Self::alloc().set_ivars(ViewControllerState {
+        let this = mtm.alloc().set_ivars(ViewControllerState {
            prefers_status_bar_hidden: Cell::new(false),
            preferred_status_bar_style: Cell::new(UIStatusBarStyle::Default),
            prefers_home_indicator_auto_hidden: Cell::new(false),
            supported_orientations: Cell::new(UIInterfaceOrientationMask::All),
-            preferred_screen_edges_deferring_system_gestures: Cell::new(UIRectEdge::NONE),
+            preferred_screen_edges_deferring_system_gestures: Cell::new(UIRectEdge::empty()),
        });
-        let this: Id<Self> = unsafe { msg_send_id![super(this), init] };
+        let this: Retained<Self> = unsafe { msg_send_id![super(this), init] };

        this.set_prefers_status_bar_hidden(
            window_attributes.platform_specific.prefers_status_bar_hidden,
--- a/src/platform_impl/apple/uikit/window.rs
+++ b/src/platform_impl/apple/uikit/window.rs
@@ -2,27 +2,28 @@

 use std::collections::VecDeque;

-use objc2::rc::Id;
+use objc2::rc::Retained;
 use objc2::runtime::{AnyObject, NSObject};
 use objc2::{class, declare_class, msg_send, msg_send_id, mutability, ClassType, DeclaredClass};
-use objc2_foundation::{CGFloat, CGPoint, CGRect, CGSize, MainThreadBound, MainThreadMarker};
+use objc2_foundation::{
+    CGFloat, CGPoint, CGRect, CGSize, MainThreadBound, MainThreadMarker, NSObjectProtocol,
+};
+use objc2_ui_kit::{
+    UIApplication, UICoordinateSpace, UIResponder, UIScreen, UIScreenOverscanCompensation,
+    UIViewController, UIWindow,
+};
 use tracing::{debug, warn};

 use super::app_state::EventWrapper;
-use super::uikit::{
-    UIApplication, UIResponder, UIScreen, UIScreenOverscanCompensation, UIViewController, UIWindow,
-};
 use super::view::WinitView;
 use super::view_controller::WinitViewController;
+use super::{app_state, monitor, ActiveEventLoop, Fullscreen, MonitorHandle};
 use crate::cursor::Cursor;
 use crate::dpi::{LogicalPosition, LogicalSize, PhysicalPosition, PhysicalSize, Position, Size};
 use crate::error::{ExternalError, NotSupportedError, OsError as RootOsError};
 use crate::event::{Event, WindowEvent};
 use crate::icon::Icon;
 use crate::platform::ios::{ScreenEdge, StatusBarStyle, ValidOrientations};
-use crate::platform_impl::platform::{
-    app_state, monitor, ActiveEventLoop, Fullscreen, MonitorHandle,
-};
 use crate::window::{
    CursorGrabMode, ImePurpose, ResizeDirection, Theme, UserAttentionType, WindowAttributes,
    WindowButtons, WindowId as RootWindowId, WindowLevel,
@@ -35,7 +36,7 @@ declare_class!(
    unsafe impl ClassType for WinitUIWindow {
        #[inherits(UIResponder, NSObject)]
        type Super = UIWindow;
-        type Mutability = mutability::InteriorMutable;
+        type Mutability = mutability::MainThreadOnly;
        const NAME: &'static str = "WinitUIWindow";
    }

@@ -76,8 +77,8 @@ impl WinitUIWindow {
        window_attributes: &WindowAttributes,
        frame: CGRect,
        view_controller: &UIViewController,
-    ) -> Id<Self> {
-        let this: Id<Self> = unsafe { msg_send_id![Self::alloc(), initWithFrame: frame] };
+    ) -> Retained<Self> {
+        let this: Retained<Self> = unsafe { msg_send_id![mtm.alloc(), initWithFrame: frame] };

        this.setRootViewController(Some(view_controller));

@@ -104,9 +105,9 @@ impl WinitUIWindow {
 }

 pub struct Inner {
-    window: Id<WinitUIWindow>,
-    view_controller: Id<WinitViewController>,
-    view: Id<WinitView>,
+    window: Retained<WinitUIWindow>,
+    view_controller: Retained<WinitViewController>,
+    view: Retained<WinitView>,
    gl_or_metal_backed: bool,
 }

@@ -394,7 +395,8 @@ impl Inner {
    }

    pub fn primary_monitor(&self) -> Option<MonitorHandle> {
-        Some(MonitorHandle::new(UIScreen::main(MainThreadMarker::new().unwrap())))
+        #[allow(deprecated)]
+        Some(MonitorHandle::new(UIScreen::mainScreen(MainThreadMarker::new().unwrap())))
    }

    pub fn id(&self) -> WindowId {
@@ -404,18 +406,18 @@ impl Inner {
    #[cfg(feature = "rwh_04")]
    pub fn raw_window_handle_rwh_04(&self) -> rwh_04::RawWindowHandle {
        let mut window_handle = rwh_04::UiKitHandle::empty();
-        window_handle.ui_window = Id::as_ptr(&self.window) as _;
-        window_handle.ui_view = Id::as_ptr(&self.view) as _;
-        window_handle.ui_view_controller = Id::as_ptr(&self.view_controller) as _;
+        window_handle.ui_window = Retained::as_ptr(&self.window) as _;
+        window_handle.ui_view = Retained::as_ptr(&self.view) as _;
+        window_handle.ui_view_controller = Retained::as_ptr(&self.view_controller) as _;
        rwh_04::RawWindowHandle::UiKit(window_handle)
    }

    #[cfg(feature = "rwh_05")]
    pub fn raw_window_handle_rwh_05(&self) -> rwh_05::RawWindowHandle {
        let mut window_handle = rwh_05::UiKitWindowHandle::empty();
-        window_handle.ui_window = Id::as_ptr(&self.window) as _;
-        window_handle.ui_view = Id::as_ptr(&self.view) as _;
-        window_handle.ui_view_controller = Id::as_ptr(&self.view_controller) as _;
+        window_handle.ui_window = Retained::as_ptr(&self.window) as _;
+        window_handle.ui_view = Retained::as_ptr(&self.view) as _;
+        window_handle.ui_view_controller = Retained::as_ptr(&self.view_controller) as _;
        rwh_05::RawWindowHandle::UiKit(window_handle)
    }

@@ -427,11 +429,11 @@ impl Inner {
    #[cfg(feature = "rwh_06")]
    pub fn raw_window_handle_rwh_06(&self) -> rwh_06::RawWindowHandle {
        let mut window_handle = rwh_06::UiKitWindowHandle::new({
-            let ui_view = Id::as_ptr(&self.view) as _;
-            std::ptr::NonNull::new(ui_view).expect("Id<T> should never be null")
+            let ui_view = Retained::as_ptr(&self.view) as _;
+            std::ptr::NonNull::new(ui_view).expect("Retained<T> should never be null")
        });
        window_handle.ui_view_controller =
-            std::ptr::NonNull::new(Id::as_ptr(&self.view_controller) as _);
+            std::ptr::NonNull::new(Retained::as_ptr(&self.view_controller) as _);
        rwh_06::RawWindowHandle::UiKit(window_handle)
    }

@@ -481,7 +483,8 @@ impl Window {

        // TODO: transparency, visible

-        let main_screen = UIScreen::main(mtm);
+        #[allow(deprecated)]
+        let main_screen = UIScreen::mainScreen(mtm);
        let fullscreen = window_attributes.fullscreen.clone().map(Into::into);
        let screen = match fullscreen {
            Some(Fullscreen::Exclusive(ref video_mode)) => video_mode.monitor.ui_screen(mtm),
@@ -505,12 +508,8 @@ impl Window {

        let view = WinitView::new(mtm, &window_attributes, frame);

-        let gl_or_metal_backed = unsafe {
-            let layer_class = WinitView::layerClass();
-            let is_metal = msg_send![layer_class, isSubclassOfClass: class!(CAMetalLayer)];
-            let is_gl = msg_send![layer_class, isSubclassOfClass: class!(CAEAGLLayer)];
-            is_metal || is_gl
-        };
+        let gl_or_metal_backed =
+            view.isKindOfClass(class!(CAMetalLayer)) || view.isKindOfClass(class!(CAEAGLLayer));

        let view_controller = WinitViewController::new(mtm, &window_attributes, &view);
        let window = WinitUIWindow::new(mtm, &window_attributes, frame, &view_controller);
@@ -674,10 +673,8 @@ impl Inner {
        } else {
            let screen_frame = self.rect_to_screen_space(bounds);
            let status_bar_frame = {
-                let app = UIApplication::shared(MainThreadMarker::new().unwrap()).expect(
-                    "`Window::get_inner_position` cannot be called before `EventLoop::run_app` on \
-                     iOS",
-                );
+                let app = UIApplication::sharedApplication(MainThreadMarker::new().unwrap());
+                #[allow(deprecated)]
                app.statusBarFrame()
            };
            let (y, height) = if screen_frame.origin.y > status_bar_frame.size.height {
--- a/src/platform_impl/ios/app_delegate.rs
+++ b/src/platform_impl/ios/app_delegate.rs
@@ -1,101 +0,0 @@
-use objc2::{declare_class, mutability, ClassType, DeclaredClass};
-use objc2_foundation::{MainThreadMarker, NSObject, NSObjectProtocol};
-
-use super::app_state::{self, EventWrapper};
-use super::uikit::{UIApplication, UIWindow};
-use super::window::WinitUIWindow;
-use crate::event::{Event, WindowEvent};
-use crate::window::WindowId as RootWindowId;
-
-declare_class!(
-    pub struct AppDelegate;
-
-    unsafe impl ClassType for AppDelegate {
-        type Super = NSObject;
-        type Mutability = mutability::InteriorMutable;
-        const NAME: &'static str = "WinitApplicationDelegate";
-    }
-
-    impl DeclaredClass for AppDelegate {}
-
-    // UIApplicationDelegate protocol
-    unsafe impl AppDelegate {
-        #[method(application:didFinishLaunchingWithOptions:)]
-        fn did_finish_launching(&self, _application: &UIApplication, _: *mut NSObject) -> bool {
-            app_state::did_finish_launching(MainThreadMarker::new().unwrap());
-            true
-        }
-
-        #[method(applicationDidBecomeActive:)]
-        fn did_become_active(&self, _application: &UIApplication) {
-            let mtm = MainThreadMarker::new().unwrap();
-            app_state::handle_nonuser_event(mtm, EventWrapper::StaticEvent(Event::Resumed))
-        }
-
-        #[method(applicationWillResignActive:)]
-        fn will_resign_active(&self, _application: &UIApplication) {
-            let mtm = MainThreadMarker::new().unwrap();
-            app_state::handle_nonuser_event(mtm, EventWrapper::StaticEvent(Event::Suspended))
-        }
-
-        #[method(applicationWillEnterForeground:)]
-        fn will_enter_foreground(&self, application: &UIApplication) {
-            self.send_occluded_event_for_all_windows(application, false);
-        }
-
-        #[method(applicationDidEnterBackground:)]
-        fn did_enter_background(&self, application: &UIApplication) {
-            self.send_occluded_event_for_all_windows(application, true);
-        }
-
-        #[method(applicationWillTerminate:)]
-        fn will_terminate(&self, application: &UIApplication) {
-            let mut events = Vec::new();
-            for window in application.windows().iter() {
-                if window.is_kind_of::<WinitUIWindow>() {
-                    // SAFETY: We just checked that the window is a `winit` window
-                    let window = unsafe {
-                        let ptr: *const UIWindow = window;
-                        let ptr: *const WinitUIWindow = ptr.cast();
-                        &*ptr
-                    };
-                    events.push(EventWrapper::StaticEvent(Event::WindowEvent {
-                        window_id: RootWindowId(window.id()),
-                        event: WindowEvent::Destroyed,
-                    }));
-                }
-            }
-            let mtm = MainThreadMarker::new().unwrap();
-            app_state::handle_nonuser_events(mtm, events);
-            app_state::terminated(mtm);
-        }
-
-        #[method(applicationDidReceiveMemoryWarning:)]
-        fn did_receive_memory_warning(&self, _application: &UIApplication) {
-            let mtm = MainThreadMarker::new().unwrap();
-            app_state::handle_nonuser_event(mtm, EventWrapper::StaticEvent(Event::MemoryWarning))
-        }
-    }
-);
-
-impl AppDelegate {
-    fn send_occluded_event_for_all_windows(&self, application: &UIApplication, occluded: bool) {
-        let mut events = Vec::new();
-        for window in application.windows().iter() {
-            if window.is_kind_of::<WinitUIWindow>() {
-                // SAFETY: We just checked that the window is a `winit` window
-                let window = unsafe {
-                    let ptr: *const UIWindow = window;
-                    let ptr: *const WinitUIWindow = ptr.cast();
-                    &*ptr
-                };
-                events.push(EventWrapper::StaticEvent(Event::WindowEvent {
-                    window_id: RootWindowId(window.id()),
-                    event: WindowEvent::Occluded(occluded),
-                }));
-            }
-        }
-        let mtm = MainThreadMarker::new().unwrap();
-        app_state::handle_nonuser_events(mtm, events);
-    }
-}
--- a/src/platform_impl/ios/uikit/application.rs
+++ b/src/platform_impl/ios/uikit/application.rs
@@ -1,31 +0,0 @@
-use objc2::rc::Id;
-use objc2::{extern_class, extern_methods, msg_send_id, mutability, ClassType};
-use objc2_foundation::{CGRect, MainThreadMarker, NSArray, NSObject};
-
-use super::{UIResponder, UIWindow};
-
-extern_class!(
-    #[derive(Debug, PartialEq, Eq, Hash)]
-    pub(crate) struct UIApplication;
-
-    unsafe impl ClassType for UIApplication {
-        #[inherits(NSObject)]
-        type Super = UIResponder;
-        type Mutability = mutability::InteriorMutable;
-    }
-);
-
-extern_methods!(
-    unsafe impl UIApplication {
-        pub fn shared(_mtm: MainThreadMarker) -> Option<Id<Self>> {
-            unsafe { msg_send_id![Self::class(), sharedApplication] }
-        }
-
-        pub fn windows(&self) -> Id<NSArray<UIWindow>> {
-            unsafe { msg_send_id![self, windows] }
-        }
-
-        #[method(statusBarFrame)]
-        pub fn statusBarFrame(&self) -> CGRect;
-    }
-);
--- a/src/platform_impl/ios/uikit/coordinate_space.rs
+++ b/src/platform_impl/ios/uikit/coordinate_space.rs
@@ -1,12 +0,0 @@
-use objc2::{extern_class, mutability, ClassType};
-use objc2_foundation::NSObject;
-
-extern_class!(
-    #[derive(Debug, PartialEq, Eq, Hash)]
-    pub(crate) struct UICoordinateSpace;
-
-    unsafe impl ClassType for UICoordinateSpace {
-        type Super = NSObject;
-        type Mutability = mutability::InteriorMutable;
-    }
-);
--- a/src/platform_impl/ios/uikit/device.rs
+++ b/src/platform_impl/ios/uikit/device.rs
@@ -1,41 +0,0 @@
-use objc2::encode::{Encode, Encoding};
-use objc2::rc::Id;
-use objc2::{extern_class, extern_methods, msg_send_id, mutability, ClassType};
-use objc2_foundation::{MainThreadMarker, NSInteger, NSObject};
-
-extern_class!(
-    #[derive(Debug, PartialEq, Eq, Hash)]
-    pub(crate) struct UIDevice;
-
-    unsafe impl ClassType for UIDevice {
-        type Super = NSObject;
-        type Mutability = mutability::InteriorMutable;
-    }
-);
-
-extern_methods!(
-    unsafe impl UIDevice {
-        pub fn current(_mtm: MainThreadMarker) -> Id<Self> {
-            unsafe { msg_send_id![Self::class(), currentDevice] }
-        }
-
-        #[method(userInterfaceIdiom)]
-        pub fn userInterfaceIdiom(&self) -> UIUserInterfaceIdiom;
-    }
-);
-
-#[repr(transparent)]
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct UIUserInterfaceIdiom(NSInteger);
-
-unsafe impl Encode for UIUserInterfaceIdiom {
-    const ENCODING: Encoding = NSInteger::ENCODING;
-}
-
-impl UIUserInterfaceIdiom {
-    pub const Unspecified: UIUserInterfaceIdiom = UIUserInterfaceIdiom(-1);
-    pub const Phone: UIUserInterfaceIdiom = UIUserInterfaceIdiom(0);
-    pub const Pad: UIUserInterfaceIdiom = UIUserInterfaceIdiom(1);
-    pub const TV: UIUserInterfaceIdiom = UIUserInterfaceIdiom(2);
-    pub const CarPlay: UIUserInterfaceIdiom = UIUserInterfaceIdiom(3);
-}
--- a/src/platform_impl/ios/uikit/event.rs
+++ b/src/platform_impl/ios/uikit/event.rs
@@ -1,12 +0,0 @@
-use objc2::{extern_class, mutability, ClassType};
-use objc2_foundation::NSObject;
-
-extern_class!(
-    #[derive(Debug, PartialEq, Eq, Hash)]
-    pub(crate) struct UIEvent;
-
-    unsafe impl ClassType for UIEvent {
-        type Super = NSObject;
-        type Mutability = mutability::InteriorMutable;
-    }
-);
--- a/src/platform_impl/ios/uikit/geometry.rs
+++ b/src/platform_impl/ios/uikit/geometry.rs
@@ -1,14 +0,0 @@
-use objc2::encode::{Encode, Encoding};
-use objc2_foundation::NSUInteger;
-
-#[repr(transparent)]
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct UIRectEdge(pub NSUInteger);
-
-impl UIRectEdge {
-    pub const NONE: Self = Self(0);
-}
-
-unsafe impl Encode for UIRectEdge {
-    const ENCODING: Encoding = NSUInteger::ENCODING;
-}
--- a/src/platform_impl/ios/uikit/gesture_recognizer.rs
+++ b/src/platform_impl/ios/uikit/gesture_recognizer.rs
@@ -1,176 +0,0 @@
-use objc2::encode::{Encode, Encoding};
-use objc2::rc::Id;
-use objc2::runtime::ProtocolObject;
-use objc2::{extern_class, extern_methods, extern_protocol, mutability, ClassType, ProtocolType};
-use objc2_foundation::{CGFloat, CGPoint, NSInteger, NSObject, NSObjectProtocol, NSUInteger};
-
-use super::UIView;
-
-extern_class!(
-    /// [`UIGestureRecognizer`](https://developer.apple.com/documentation/uikit/uigesturerecognizer)
-    #[derive(Debug, PartialEq, Eq, Hash)]
-    pub(crate) struct UIGestureRecognizer;
-
-    unsafe impl ClassType for UIGestureRecognizer {
-        type Super = NSObject;
-        type Mutability = mutability::InteriorMutable;
-    }
-);
-
-extern_methods!(
-    unsafe impl UIGestureRecognizer {
-        #[method(state)]
-        pub fn state(&self) -> UIGestureRecognizerState;
-
-        /// [`delegate`](https://developer.apple.com/documentation/uikit/uigesturerecognizer/1624207-delegate?language=objc)
-        /// @property(nullable, nonatomic, weak) id<UIGestureRecognizerDelegate> delegate;
-        #[method(setDelegate:)]
-        pub fn setDelegate(&self, delegate: &ProtocolObject<dyn UIGestureRecognizerDelegate>);
-
-        #[method_id(delegate)]
-        pub fn delegate(&self) -> Id<ProtocolObject<dyn UIGestureRecognizerDelegate>>;
-    }
-);
-
-unsafe impl Encode for UIGestureRecognizer {
-    const ENCODING: Encoding = Encoding::Object;
-}
-
-// [`UIGestureRecognizerState`](https://developer.apple.com/documentation/uikit/uigesturerecognizer/state)
-#[repr(transparent)]
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct UIGestureRecognizerState(NSInteger);
-
-unsafe impl Encode for UIGestureRecognizerState {
-    const ENCODING: Encoding = NSInteger::ENCODING;
-}
-
-#[allow(dead_code)]
-impl UIGestureRecognizerState {
-    pub const Possible: Self = Self(0);
-    pub const Began: Self = Self(1);
-    pub const Changed: Self = Self(2);
-    pub const Ended: Self = Self(3);
-    pub const Cancelled: Self = Self(4);
-    pub const Failed: Self = Self(5);
-}
-
-// [`UIPinchGestureRecognizer`](https://developer.apple.com/documentation/uikit/uipinchgesturerecognizer)
-extern_class!(
-    #[derive(Debug, PartialEq, Eq, Hash)]
-    pub(crate) struct UIPinchGestureRecognizer;
-
-    unsafe impl ClassType for UIPinchGestureRecognizer {
-        type Super = UIGestureRecognizer;
-        type Mutability = mutability::InteriorMutable;
-    }
-);
-
-extern_methods!(
-    unsafe impl UIPinchGestureRecognizer {
-        #[method(scale)]
-        pub fn scale(&self) -> CGFloat;
-
-        #[method(velocity)]
-        pub fn velocity(&self) -> CGFloat;
-    }
-);
-
-unsafe impl Encode for UIPinchGestureRecognizer {
-    const ENCODING: Encoding = Encoding::Object;
-}
-
-extern_class!(
-    /// [`UIRotationGestureRecognizer`](https://developer.apple.com/documentation/uikit/uirotationgesturerecognizer)
-    #[derive(Debug, PartialEq, Eq, Hash)]
-    pub(crate) struct UIRotationGestureRecognizer;
-
-    unsafe impl ClassType for UIRotationGestureRecognizer {
-        type Super = UIGestureRecognizer;
-        type Mutability = mutability::InteriorMutable;
-    }
-);
-
-extern_methods!(
-    unsafe impl UIRotationGestureRecognizer {
-        #[method(rotation)]
-        pub fn rotation(&self) -> CGFloat;
-
-        #[method(velocity)]
-        pub fn velocity(&self) -> CGFloat;
-    }
-);
-
-unsafe impl Encode for UIRotationGestureRecognizer {
-    const ENCODING: Encoding = Encoding::Object;
-}
-
-extern_class!(
-    /// [`UITapGestureRecognizer`](https://developer.apple.com/documentation/uikit/uitapgesturerecognizer)
-    #[derive(Debug, PartialEq, Eq, Hash)]
-    pub(crate) struct UITapGestureRecognizer;
-
-    unsafe impl ClassType for UITapGestureRecognizer {
-        type Super = UIGestureRecognizer;
-        type Mutability = mutability::InteriorMutable;
-    }
-);
-
-extern_methods!(
-    unsafe impl UITapGestureRecognizer {
-        #[method(setNumberOfTapsRequired:)]
-        pub fn setNumberOfTapsRequired(&self, number_of_taps_required: NSUInteger);
-
-        #[method(setNumberOfTouchesRequired:)]
-        pub fn setNumberOfTouchesRequired(&self, number_of_touches_required: NSUInteger);
-    }
-);
-
-unsafe impl Encode for UITapGestureRecognizer {
-    const ENCODING: Encoding = Encoding::Object;
-}
-
-extern_class!(
-    /// [`UIPanGestureRecognizer`](https://developer.apple.com/documentation/uikit/uipangesturerecognizer)
-    #[derive(Debug, PartialEq, Eq, Hash)]
-    pub(crate) struct UIPanGestureRecognizer;
-
-    unsafe impl ClassType for UIPanGestureRecognizer {
-        type Super = UIGestureRecognizer;
-        type Mutability = mutability::InteriorMutable;
-    }
-);
-
-extern_methods!(
-    unsafe impl UIPanGestureRecognizer {
-        #[method(translationInView:)]
-        pub fn translationInView(&self, view: &UIView) -> CGPoint;
-
-        #[method(setTranslation:inView:)]
-        pub fn setTranslationInView(&self, translation: CGPoint, view: &UIView);
-
-        #[method(velocityInView:)]
-        pub fn velocityInView(&self, view: &UIView) -> CGPoint;
-
-        #[method(setMinimumNumberOfTouches:)]
-        pub fn setMinimumNumberOfTouches(&self, minimum_number_of_touches: NSUInteger);
-
-        #[method(minimumNumberOfTouches)]
-        pub fn minimumNumberOfTouches(&self) -> NSUInteger;
-
-        #[method(setMaximumNumberOfTouches:)]
-        pub fn setMaximumNumberOfTouches(&self, maximum_number_of_touches: NSUInteger);
-
-        #[method(maximumNumberOfTouches)]
-        pub fn maximumNumberOfTouches(&self) -> NSUInteger;
-    }
-);
-
-extern_protocol!(
-    /// (@protocol UIGestureRecognizerDelegate)[https://developer.apple.com/documentation/uikit/uigesturerecognizerdelegate?language=objc]
-    pub(crate) unsafe trait UIGestureRecognizerDelegate: NSObjectProtocol {}
-
-    unsafe impl ProtocolType for dyn UIGestureRecognizerDelegate {
-        const NAME: &'static str = "UIGestureRecognizerDelegate";
-    }
-);
--- a/src/platform_impl/ios/uikit/mod.rs
+++ b/src/platform_impl/ios/uikit/mod.rs
@@ -1,53 +0,0 @@
-#![allow(non_snake_case)]
-#![allow(non_upper_case_globals)]
-
-use std::os::raw::{c_char, c_int};
-
-use objc2_foundation::NSString;
-
-mod application;
-mod coordinate_space;
-mod device;
-mod event;
-mod geometry;
-mod gesture_recognizer;
-mod responder;
-mod screen;
-mod screen_mode;
-mod status_bar_style;
-mod touch;
-mod trait_collection;
-mod view;
-mod view_controller;
-mod window;
-
-pub(crate) use self::application::UIApplication;
-pub(crate) use self::coordinate_space::UICoordinateSpace;
-pub(crate) use self::device::{UIDevice, UIUserInterfaceIdiom};
-pub(crate) use self::event::UIEvent;
-pub(crate) use self::geometry::UIRectEdge;
-pub(crate) use self::gesture_recognizer::{
-    UIGestureRecognizer, UIGestureRecognizerDelegate, UIGestureRecognizerState,
-    UIPanGestureRecognizer, UIPinchGestureRecognizer, UIRotationGestureRecognizer,
-    UITapGestureRecognizer,
-};
-pub(crate) use self::responder::UIResponder;
-pub(crate) use self::screen::{UIScreen, UIScreenOverscanCompensation};
-pub(crate) use self::screen_mode::UIScreenMode;
-pub(crate) use self::status_bar_style::UIStatusBarStyle;
-pub(crate) use self::touch::{UITouch, UITouchPhase, UITouchType};
-pub(crate) use self::trait_collection::{UIForceTouchCapability, UITraitCollection};
-#[allow(unused_imports)]
-pub(crate) use self::view::{UIEdgeInsets, UIView};
-pub(crate) use self::view_controller::{UIInterfaceOrientationMask, UIViewController};
-pub(crate) use self::window::UIWindow;
-
-#[link(name = "UIKit", kind = "framework")]
-extern "C" {
-    pub fn UIApplicationMain(
-        argc: c_int,
-        argv: *const c_char,
-        principalClassName: Option<&NSString>,
-        delegateClassName: Option<&NSString>,
-    ) -> c_int;
-}
--- a/src/platform_impl/ios/uikit/responder.rs
+++ b/src/platform_impl/ios/uikit/responder.rs
@@ -1,12 +0,0 @@
-use objc2::{extern_class, mutability, ClassType};
-use objc2_foundation::NSObject;
-
-extern_class!(
-    #[derive(Debug, PartialEq, Eq, Hash)]
-    pub(crate) struct UIResponder;
-
-    unsafe impl ClassType for UIResponder {
-        type Super = NSObject;
-        type Mutability = mutability::InteriorMutable;
-    }
-);
--- a/src/platform_impl/ios/uikit/screen.rs
+++ b/src/platform_impl/ios/uikit/screen.rs
@@ -1,80 +0,0 @@
-use objc2::encode::{Encode, Encoding};
-use objc2::rc::Id;
-use objc2::{extern_class, extern_methods, msg_send_id, mutability, ClassType};
-use objc2_foundation::{CGFloat, CGRect, MainThreadMarker, NSArray, NSInteger, NSObject};
-
-use super::{UICoordinateSpace, UIScreenMode};
-
-extern_class!(
-    #[derive(Debug, PartialEq, Eq, Hash)]
-    pub(crate) struct UIScreen;
-
-    unsafe impl ClassType for UIScreen {
-        type Super = NSObject;
-        type Mutability = mutability::InteriorMutable;
-    }
-);
-
-extern_methods!(
-    unsafe impl UIScreen {
-        pub fn main(_mtm: MainThreadMarker) -> Id<Self> {
-            unsafe { msg_send_id![Self::class(), mainScreen] }
-        }
-
-        pub fn screens(_mtm: MainThreadMarker) -> Id<NSArray<Self>> {
-            unsafe { msg_send_id![Self::class(), screens] }
-        }
-
-        #[method(bounds)]
-        pub fn bounds(&self) -> CGRect;
-
-        #[method(scale)]
-        pub fn scale(&self) -> CGFloat;
-
-        #[method(nativeBounds)]
-        pub fn nativeBounds(&self) -> CGRect;
-
-        #[method(nativeScale)]
-        pub fn nativeScale(&self) -> CGFloat;
-
-        #[method(maximumFramesPerSecond)]
-        pub fn maximumFramesPerSecond(&self) -> NSInteger;
-
-        pub fn mirroredScreen(&self) -> Id<Self> {
-            unsafe { msg_send_id![Self::class(), mirroredScreen] }
-        }
-
-        pub fn preferredMode(&self) -> Option<Id<UIScreenMode>> {
-            unsafe { msg_send_id![self, preferredMode] }
-        }
-
-        #[method(setCurrentMode:)]
-        pub fn setCurrentMode(&self, mode: Option<&UIScreenMode>);
-
-        pub fn availableModes(&self) -> Id<NSArray<UIScreenMode>> {
-            unsafe { msg_send_id![self, availableModes] }
-        }
-
-        #[method(setOverscanCompensation:)]
-        pub fn setOverscanCompensation(&self, overscanCompensation: UIScreenOverscanCompensation);
-
-        pub fn coordinateSpace(&self) -> Id<UICoordinateSpace> {
-            unsafe { msg_send_id![self, coordinateSpace] }
-        }
-    }
-);
-
-#[repr(transparent)]
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct UIScreenOverscanCompensation(NSInteger);
-
-unsafe impl Encode for UIScreenOverscanCompensation {
-    const ENCODING: Encoding = NSInteger::ENCODING;
-}
-
-#[allow(dead_code)]
-impl UIScreenOverscanCompensation {
-    pub const Scale: Self = Self(0);
-    pub const InsetBounds: Self = Self(1);
-    pub const None: Self = Self(2);
-}
--- a/src/platform_impl/ios/uikit/screen_mode.rs
+++ b/src/platform_impl/ios/uikit/screen_mode.rs
@@ -1,19 +0,0 @@
-use objc2::{extern_class, extern_methods, mutability, ClassType};
-use objc2_foundation::{CGSize, NSObject};
-
-extern_class!(
-    #[derive(Debug, PartialEq, Eq, Hash)]
-    pub(crate) struct UIScreenMode;
-
-    unsafe impl ClassType for UIScreenMode {
-        type Super = NSObject;
-        type Mutability = mutability::InteriorMutable;
-    }
-);
-
-extern_methods!(
-    unsafe impl UIScreenMode {
-        #[method(size)]
-        pub fn size(&self) -> CGSize;
-    }
-);
--- a/src/platform_impl/ios/uikit/status_bar_style.rs
+++ b/src/platform_impl/ios/uikit/status_bar_style.rs
@@ -1,16 +0,0 @@
-use objc2::encode::{Encode, Encoding};
-use objc2_foundation::NSInteger;
-
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
-#[allow(dead_code)]
-#[repr(isize)]
-pub enum UIStatusBarStyle {
-    #[default]
-    Default = 0,
-    LightContent = 1,
-    DarkContent = 3,
-}
-
-unsafe impl Encode for UIStatusBarStyle {
-    const ENCODING: Encoding = NSInteger::ENCODING;
-}
--- a/src/platform_impl/ios/uikit/touch.rs
+++ b/src/platform_impl/ios/uikit/touch.rs
@@ -1,65 +0,0 @@
-use objc2::encode::{Encode, Encoding};
-use objc2::{extern_class, extern_methods, mutability, ClassType};
-use objc2_foundation::{CGFloat, CGPoint, NSInteger, NSObject};
-
-use super::UIView;
-
-extern_class!(
-    #[derive(Debug, PartialEq, Eq, Hash)]
-    pub(crate) struct UITouch;
-
-    unsafe impl ClassType for UITouch {
-        type Super = NSObject;
-        type Mutability = mutability::InteriorMutable;
-    }
-);
-
-extern_methods!(
-    unsafe impl UITouch {
-        #[method(locationInView:)]
-        pub fn locationInView(&self, view: Option<&UIView>) -> CGPoint;
-
-        #[method(type)]
-        pub fn type_(&self) -> UITouchType;
-
-        #[method(force)]
-        pub fn force(&self) -> CGFloat;
-
-        #[method(maximumPossibleForce)]
-        pub fn maximumPossibleForce(&self) -> CGFloat;
-
-        #[method(altitudeAngle)]
-        pub fn altitudeAngle(&self) -> CGFloat;
-
-        #[method(phase)]
-        pub fn phase(&self) -> UITouchPhase;
-    }
-);
-
-#[derive(Debug, PartialEq, Eq)]
-#[allow(dead_code)]
-#[repr(isize)]
-pub enum UITouchType {
-    Direct = 0,
-    Indirect,
-    Pencil,
-}
-
-unsafe impl Encode for UITouchType {
-    const ENCODING: Encoding = NSInteger::ENCODING;
-}
-
-#[derive(Debug)]
-#[allow(dead_code)]
-#[repr(isize)]
-pub enum UITouchPhase {
-    Began = 0,
-    Moved,
-    Stationary,
-    Ended,
-    Cancelled,
-}
-
-unsafe impl Encode for UITouchPhase {
-    const ENCODING: Encoding = NSInteger::ENCODING;
-}
--- a/src/platform_impl/ios/uikit/trait_collection.rs
+++ b/src/platform_impl/ios/uikit/trait_collection.rs
@@ -1,33 +0,0 @@
-use objc2::encode::{Encode, Encoding};
-use objc2::{extern_class, extern_methods, mutability, ClassType};
-use objc2_foundation::{NSInteger, NSObject};
-
-extern_class!(
-    #[derive(Debug, PartialEq, Eq, Hash)]
-    pub(crate) struct UITraitCollection;
-
-    unsafe impl ClassType for UITraitCollection {
-        type Super = NSObject;
-        type Mutability = mutability::InteriorMutable;
-    }
-);
-
-extern_methods!(
-    unsafe impl UITraitCollection {
-        #[method(forceTouchCapability)]
-        pub fn forceTouchCapability(&self) -> UIForceTouchCapability;
-    }
-);
-
-#[derive(Debug, PartialEq, Eq)]
-#[allow(dead_code)]
-#[repr(isize)]
-pub enum UIForceTouchCapability {
-    Unknown = 0,
-    Unavailable,
-    Available,
-}
-
-unsafe impl Encode for UIForceTouchCapability {
-    const ENCODING: Encoding = NSInteger::ENCODING;
-}
--- a/src/platform_impl/ios/uikit/view.rs
+++ b/src/platform_impl/ios/uikit/view.rs
@@ -1,93 +0,0 @@
-use objc2::encode::{Encode, Encoding};
-use objc2::rc::Id;
-use objc2::{extern_class, extern_methods, msg_send_id, mutability, ClassType};
-use objc2_foundation::{CGFloat, CGRect, NSObject};
-
-use super::{UICoordinateSpace, UIGestureRecognizer, UIResponder, UIViewController};
-
-extern_class!(
-    #[derive(Debug, PartialEq, Eq, Hash)]
-    pub(crate) struct UIView;
-
-    unsafe impl ClassType for UIView {
-        #[inherits(NSObject)]
-        type Super = UIResponder;
-        type Mutability = mutability::InteriorMutable;
-    }
-);
-
-extern_methods!(
-    unsafe impl UIView {
-        #[method(bounds)]
-        pub fn bounds(&self) -> CGRect;
-
-        #[method(setBounds:)]
-        pub fn setBounds(&self, value: CGRect);
-
-        #[method(frame)]
-        pub fn frame(&self) -> CGRect;
-
-        #[method(setFrame:)]
-        pub fn setFrame(&self, value: CGRect);
-
-        #[method(contentScaleFactor)]
-        pub fn contentScaleFactor(&self) -> CGFloat;
-
-        #[method(setContentScaleFactor:)]
-        pub fn setContentScaleFactor(&self, val: CGFloat);
-
-        #[method(setMultipleTouchEnabled:)]
-        pub fn setMultipleTouchEnabled(&self, val: bool);
-
-        pub fn rootViewController(&self) -> Option<Id<UIViewController>> {
-            unsafe { msg_send_id![self, rootViewController] }
-        }
-
-        #[method(setRootViewController:)]
-        pub fn setRootViewController(&self, rootViewController: Option<&UIViewController>);
-
-        #[method(convertRect:toCoordinateSpace:)]
-        pub fn convertRect_toCoordinateSpace(
-            &self,
-            rect: CGRect,
-            coordinateSpace: &UICoordinateSpace,
-        ) -> CGRect;
-
-        #[method(convertRect:fromCoordinateSpace:)]
-        pub fn convertRect_fromCoordinateSpace(
-            &self,
-            rect: CGRect,
-            coordinateSpace: &UICoordinateSpace,
-        ) -> CGRect;
-
-        #[method(safeAreaInsets)]
-        pub fn safeAreaInsets(&self) -> UIEdgeInsets;
-
-        #[method(setNeedsDisplay)]
-        pub fn setNeedsDisplay(&self);
-
-        #[method(addGestureRecognizer:)]
-        pub fn addGestureRecognizer(&self, gestureRecognizer: &UIGestureRecognizer);
-
-        #[method(removeGestureRecognizer:)]
-        pub fn removeGestureRecognizer(&self, gestureRecognizer: &UIGestureRecognizer);
-    }
-);
-
-#[repr(C)]
-#[derive(Debug, Clone)]
-pub struct UIEdgeInsets {
-    pub top: CGFloat,
-    pub left: CGFloat,
-    pub bottom: CGFloat,
-    pub right: CGFloat,
-}
-
-unsafe impl Encode for UIEdgeInsets {
-    const ENCODING: Encoding = Encoding::Struct("UIEdgeInsets", &[
-        CGFloat::ENCODING,
-        CGFloat::ENCODING,
-        CGFloat::ENCODING,
-        CGFloat::ENCODING,
-    ]);
-}
--- a/src/platform_impl/ios/uikit/view_controller.rs
+++ b/src/platform_impl/ios/uikit/view_controller.rs
@@ -1,57 +0,0 @@
-use objc2::encode::{Encode, Encoding};
-use objc2::rc::Id;
-use objc2::{extern_class, extern_methods, msg_send_id, mutability, ClassType};
-use objc2_foundation::{NSObject, NSUInteger};
-
-use super::{UIResponder, UIView};
-
-extern_class!(
-    #[derive(Debug, PartialEq, Eq, Hash)]
-    pub(crate) struct UIViewController;
-
-    unsafe impl ClassType for UIViewController {
-        #[inherits(NSObject)]
-        type Super = UIResponder;
-        type Mutability = mutability::InteriorMutable;
-    }
-);
-
-extern_methods!(
-    unsafe impl UIViewController {
-        #[method(attemptRotationToDeviceOrientation)]
-        pub fn attemptRotationToDeviceOrientation();
-
-        #[method(setNeedsStatusBarAppearanceUpdate)]
-        pub fn setNeedsStatusBarAppearanceUpdate(&self);
-
-        #[method(setNeedsUpdateOfHomeIndicatorAutoHidden)]
-        pub fn setNeedsUpdateOfHomeIndicatorAutoHidden(&self);
-
-        #[method(setNeedsUpdateOfScreenEdgesDeferringSystemGestures)]
-        pub fn setNeedsUpdateOfScreenEdgesDeferringSystemGestures(&self);
-
-        pub fn view(&self) -> Option<Id<UIView>> {
-            unsafe { msg_send_id![self, view] }
-        }
-
-        #[method(setView:)]
-        pub fn setView(&self, view: Option<&UIView>);
-    }
-);
-
-bitflags::bitflags! {
-    #[derive(Clone, Copy)]
-    pub struct UIInterfaceOrientationMask: NSUInteger {
-        const Portrait = 1 << 1;
-        const PortraitUpsideDown = 1 << 2;
-        const LandscapeRight = 1 << 3;
-        const LandscapeLeft = 1 << 4;
-        const Landscape = Self::LandscapeLeft.bits() | Self::LandscapeRight.bits();
-        const AllButUpsideDown = Self::Landscape.bits() | Self::Portrait.bits();
-        const All = Self::AllButUpsideDown.bits() | Self::PortraitUpsideDown.bits();
-    }
-}
-
-unsafe impl Encode for UIInterfaceOrientationMask {
-    const ENCODING: Encoding = NSUInteger::ENCODING;
-}
--- a/src/platform_impl/ios/uikit/window.rs
+++ b/src/platform_impl/ios/uikit/window.rs
@@ -1,36 +0,0 @@
-use objc2::rc::Id;
-use objc2::{extern_class, extern_methods, msg_send_id, mutability, ClassType};
-use objc2_foundation::NSObject;
-
-use super::{UIResponder, UIScreen, UIView};
-
-extern_class!(
-    #[derive(Debug, PartialEq, Eq, Hash)]
-    pub(crate) struct UIWindow;
-
-    unsafe impl ClassType for UIWindow {
-        #[inherits(UIResponder, NSObject)]
-        type Super = UIView;
-        type Mutability = mutability::InteriorMutable;
-    }
-);
-
-extern_methods!(
-    unsafe impl UIWindow {
-        pub fn screen(&self) -> Id<UIScreen> {
-            unsafe { msg_send_id![self, screen] }
-        }
-
-        #[method(setScreen:)]
-        pub fn setScreen(&self, screen: &UIScreen);
-
-        #[method(setHidden:)]
-        pub fn setHidden(&self, flag: bool);
-
-        #[method(makeKeyAndVisible)]
-        pub fn makeKeyAndVisible(&self);
-
-        #[method(isKeyWindow)]
-        pub fn isKeyWindow(&self) -> bool;
-    }
-);
--- a/src/platform_impl/linux/mod.rs
+++ b/src/platform_impl/linux/mod.rs
@@ -11,6 +11,8 @@ use std::{env, fmt};
 #[cfg(x11_platform)]
 use std::{ffi::CStr, mem::MaybeUninit, os::raw::*, sync::Mutex};

+use crate::application::ApplicationHandler;
+use crate::platform::pump_events::PumpStatus;
 #[cfg(x11_platform)]
 use crate::utils::Lazy;
 use smol_str::SmolStr;
@@ -19,12 +21,9 @@ use smol_str::SmolStr;
 use self::x11::{X11Error, XConnection, XError, XNotSupported};
 use crate::dpi::{PhysicalPosition, PhysicalSize, Position, Size};
 use crate::error::{EventLoopError, ExternalError, NotSupportedError, OsError as RootOsError};
-use crate::event_loop::{
-    ActiveEventLoop as RootELW, AsyncRequestSerial, ControlFlow, DeviceEvents, EventLoopClosed,
-};
+use crate::event_loop::{AsyncRequestSerial, ControlFlow, DeviceEvents};
 use crate::icon::Icon;
 use crate::keyboard::Key;
-use crate::platform::pump_events::PumpStatus;
 #[cfg(x11_platform)]
 use crate::platform::x11::{WindowType as XWindowType, XlibErrorHook};
 use crate::window::{
@@ -692,27 +691,22 @@ unsafe extern "C" fn x_error_callback(
    0
 }

-pub enum EventLoop<T: 'static> {
+pub enum EventLoop {
    #[cfg(wayland_platform)]
-    Wayland(Box<wayland::EventLoop<T>>),
+    Wayland(Box<wayland::EventLoop>),
    #[cfg(x11_platform)]
-    X(x11::EventLoop<T>),
+    X(x11::EventLoop),
 }

-pub enum EventLoopProxy<T: 'static> {
+#[derive(Clone)]
+pub enum EventLoopProxy {
    #[cfg(x11_platform)]
-    X(x11::EventLoopProxy<T>),
+    X(x11::EventLoopProxy),
    #[cfg(wayland_platform)]
-    Wayland(wayland::EventLoopProxy<T>),
+    Wayland(wayland::EventLoopProxy),
 }

-impl<T: 'static> Clone for EventLoopProxy<T> {
-    fn clone(&self) -> Self {
-        x11_or_wayland!(match self; EventLoopProxy(proxy) => proxy.clone(); as EventLoopProxy)
-    }
-}
-
-impl<T: 'static> EventLoop<T> {
+impl EventLoop {
    pub(crate) fn new(
        attributes: &PlatformSpecificEventLoopAttributes,
    ) -> Result<Self, EventLoopError> {
@@ -771,12 +765,12 @@ impl<T: 'static> EventLoop<T> {
    }

    #[cfg(wayland_platform)]
-    fn new_wayland_any_thread() -> Result<EventLoop<T>, EventLoopError> {
+    fn new_wayland_any_thread() -> Result<EventLoop, EventLoopError> {
        wayland::EventLoop::new().map(|evlp| EventLoop::Wayland(Box::new(evlp)))
    }

    #[cfg(x11_platform)]
-    fn new_x11_any_thread() -> Result<EventLoop<T>, EventLoopError> {
+    fn new_x11_any_thread() -> Result<EventLoop, EventLoopError> {
        let xconn = match X11_BACKEND.lock().unwrap().as_ref() {
            Ok(xconn) => xconn.clone(),
            Err(_) => return Err(EventLoopError::NotSupported(NotSupportedError::new())),
@@ -785,29 +779,37 @@ impl<T: 'static> EventLoop<T> {
        Ok(EventLoop::X(x11::EventLoop::new(xconn)))
    }

-    pub fn create_proxy(&self) -> EventLoopProxy<T> {
+    #[inline]
+    pub fn is_wayland(&self) -> bool {
+        match *self {
+            #[cfg(wayland_platform)]
+            EventLoop::Wayland(_) => true,
+            #[cfg(x11_platform)]
+            _ => false,
+        }
+    }
+
+    pub fn create_proxy(&self) -> EventLoopProxy {
        x11_or_wayland!(match self; EventLoop(evlp) => evlp.create_proxy(); as EventLoopProxy)
    }

-    pub fn run<F>(mut self, callback: F) -> Result<(), EventLoopError>
-    where
-        F: FnMut(crate::event::Event<T>, &RootELW),
-    {
-        self.run_on_demand(callback)
+    pub fn run_app<A: ApplicationHandler>(self, app: &mut A) -> Result<(), EventLoopError> {
+        x11_or_wayland!(match self; EventLoop(evlp) => evlp.run_app(app))
    }

-    pub fn run_on_demand<F>(&mut self, callback: F) -> Result<(), EventLoopError>
-    where
-        F: FnMut(crate::event::Event<T>, &RootELW),
-    {
-        x11_or_wayland!(match self; EventLoop(evlp) => evlp.run_on_demand(callback))
+    pub fn run_app_on_demand<A: ApplicationHandler>(
+        &mut self,
+        app: &mut A,
+    ) -> Result<(), EventLoopError> {
+        x11_or_wayland!(match self; EventLoop(evlp) => evlp.run_app_on_demand(app))
    }

-    pub fn pump_events<F>(&mut self, timeout: Option<Duration>, callback: F) -> PumpStatus
-    where
-        F: FnMut(crate::event::Event<T>, &RootELW),
-    {
-        x11_or_wayland!(match self; EventLoop(evlp) => evlp.pump_events(timeout, callback))
+    pub fn pump_app_events<A: ApplicationHandler>(
+        &mut self,
+        timeout: Option<Duration>,
+        app: &mut A,
+    ) -> PumpStatus {
+        x11_or_wayland!(match self; EventLoop(evlp) => evlp.pump_app_events(timeout, app))
    }

    pub fn window_target(&self) -> &crate::event_loop::ActiveEventLoop {
@@ -815,21 +817,21 @@ impl<T: 'static> EventLoop<T> {
    }
 }

-impl<T> AsFd for EventLoop<T> {
+impl AsFd for EventLoop {
    fn as_fd(&self) -> BorrowedFd<'_> {
        x11_or_wayland!(match self; EventLoop(evlp) => evlp.as_fd())
    }
 }

-impl<T> AsRawFd for EventLoop<T> {
+impl AsRawFd for EventLoop {
    fn as_raw_fd(&self) -> RawFd {
        x11_or_wayland!(match self; EventLoop(evlp) => evlp.as_raw_fd())
    }
 }

-impl<T: 'static> EventLoopProxy<T> {
-    pub fn send_event(&self, event: T) -> Result<(), EventLoopClosed<T>> {
-        x11_or_wayland!(match self; EventLoopProxy(proxy) => proxy.send_event(event))
+impl EventLoopProxy {
+    pub fn wake_up(&self) {
+        x11_or_wayland!(match self; EventLoopProxy(proxy) => proxy.wake_up())
    }
 }

--- a/src/platform_impl/linux/wayland/event_loop/mod.rs
+++ b/src/platform_impl/linux/wayland/event_loop/mod.rs
@@ -5,7 +5,6 @@ use std::io::Result as IOResult;
 use std::marker::PhantomData;
 use std::mem;
 use std::os::unix::io::{AsFd, AsRawFd, BorrowedFd, RawFd};
-use std::rc::Rc;
 use std::sync::atomic::Ordering;
 use std::sync::{Arc, Mutex};
 use std::time::{Duration, Instant};
@@ -14,6 +13,7 @@ use sctk::reexports::calloop::Error as CalloopError;
 use sctk::reexports::calloop_wayland_source::WaylandSource;
 use sctk::reexports::client::{globals, Connection, QueueHandle};

+use crate::application::ApplicationHandler;
 use crate::cursor::OnlyCursorImage;
 use crate::dpi::LogicalSize;
 use crate::error::{EventLoopError, OsError as RootOsError};
@@ -39,7 +39,7 @@ use super::{logical_to_physical_rounded, DeviceId, WaylandError, WindowId};
 type WaylandDispatcher = calloop::Dispatcher<'static, WaylandSource<WinitState>, WinitState>;

 /// The Wayland event loop.
-pub struct EventLoop<T: 'static> {
+pub struct EventLoop {
    /// Has `run` or `run_on_demand` been called or a call to `pump_events` that starts the loop
    loop_running: bool,

@@ -47,13 +47,8 @@ pub struct EventLoop<T: 'static> {
    compositor_updates: Vec<WindowCompositorUpdate>,
    window_ids: Vec<WindowId>,

-    /// Sender of user events.
-    user_events_sender: calloop::channel::Sender<T>,
-
-    // XXX can't remove RefCell out of here, unless we can plumb generics into the `Window`, which
-    // we don't really want, since it'll break public API by a lot.
-    /// Pending events from the user.
-    pending_user_events: Rc<RefCell<Vec<T>>>,
+    /// Event loop proxy
+    event_loop_proxy: EventLoopProxy,

    /// The Wayland dispatcher to has raw access to the queue when needed, such as
    /// when creating a new window.
@@ -70,8 +65,8 @@ pub struct EventLoop<T: 'static> {
    event_loop: calloop::EventLoop<'static, WinitState>,
 }

-impl<T: 'static> EventLoop<T> {
-    pub fn new() -> Result<EventLoop<T>, EventLoopError> {
+impl EventLoop {
+    pub fn new() -> Result<EventLoop, EventLoopError> {
        macro_rules! map_err {
            ($e:expr, $err:expr) => {
                $e.map_err(|error| os_error!($err(error).into()))
@@ -114,16 +109,12 @@ impl<T: 'static> EventLoop<T> {
        )?;

        // Setup the user proxy.
-        let pending_user_events = Rc::new(RefCell::new(Vec::new()));
-        let pending_user_events_clone = pending_user_events.clone();
-        let (user_events_sender, user_events_channel) = calloop::channel::channel();
+        let (ping, ping_source) = calloop::ping::make_ping().unwrap();
        let result = event_loop
            .handle()
-            .insert_source(user_events_channel, move |event, _, winit_state: &mut WinitState| {
-                if let calloop::channel::Event::Msg(msg) = event {
-                    winit_state.dispatched_events = true;
-                    pending_user_events_clone.borrow_mut().push(msg);
-                }
+            .insert_source(ping_source, move |_, _, winit_state: &mut WinitState| {
+                winit_state.dispatched_events = true;
+                winit_state.proxy_wake_up = true;
            })
            .map_err(|error| error.error);
        map_err!(result, WaylandError::Calloop)?;
@@ -161,8 +152,7 @@ impl<T: 'static> EventLoop<T> {
            window_ids: Vec::new(),
            connection,
            wayland_dispatcher,
-            user_events_sender,
-            pending_user_events,
+            event_loop_proxy: EventLoopProxy::new(ping),
            event_loop,
            window_target: RootActiveEventLoop {
                p: PlatformActiveEventLoop::Wayland(window_target),
@@ -173,12 +163,16 @@ impl<T: 'static> EventLoop<T> {
        Ok(event_loop)
    }

-    pub fn run_on_demand<F>(&mut self, mut event_handler: F) -> Result<(), EventLoopError>
-    where
-        F: FnMut(Event<T>, &RootActiveEventLoop),
-    {
+    pub fn run_app<A: ApplicationHandler>(mut self, app: &mut A) -> Result<(), EventLoopError> {
+        self.run_app_on_demand(app)
+    }
+
+    pub fn run_app_on_demand<A: ApplicationHandler>(
+        &mut self,
+        app: &mut A,
+    ) -> Result<(), EventLoopError> {
        let exit = loop {
-            match self.pump_events(None, &mut event_handler) {
+            match self.pump_app_events(None, app) {
                PumpStatus::Exit(0) => {
                    break Ok(());
                },
@@ -200,26 +194,27 @@ impl<T: 'static> EventLoop<T> {
        exit
    }

-    pub fn pump_events<F>(&mut self, timeout: Option<Duration>, mut callback: F) -> PumpStatus
-    where
-        F: FnMut(Event<T>, &RootActiveEventLoop),
-    {
+    pub fn pump_app_events<A: ApplicationHandler>(
+        &mut self,
+        timeout: Option<Duration>,
+        app: &mut A,
+    ) -> PumpStatus {
        if !self.loop_running {
            self.loop_running = true;

            // Run the initial loop iteration.
-            self.single_iteration(&mut callback, StartCause::Init);
+            self.single_iteration(app, StartCause::Init);
        }

        // Consider the possibility that the `StartCause::Init` iteration could
        // request to Exit.
        if !self.exiting() {
-            self.poll_events_with_timeout(timeout, &mut callback);
+            self.poll_events_with_timeout(timeout, app);
        }
        if let Some(code) = self.exit_code() {
            self.loop_running = false;

-            callback(Event::LoopExiting, self.window_target());
+            app.exiting(&self.window_target);

            PumpStatus::Exit(code)
        } else {
@@ -227,10 +222,11 @@ impl<T: 'static> EventLoop<T> {
        }
    }

-    pub fn poll_events_with_timeout<F>(&mut self, mut timeout: Option<Duration>, mut callback: F)
-    where
-        F: FnMut(Event<T>, &RootActiveEventLoop),
-    {
+    pub fn poll_events_with_timeout<A: ApplicationHandler>(
+        &mut self,
+        mut timeout: Option<Duration>,
+        app: &mut A,
+    ) {
        let cause = loop {
            let start = Instant::now();

@@ -292,13 +288,10 @@ impl<T: 'static> EventLoop<T> {
            break cause;
        };

-        self.single_iteration(&mut callback, cause);
+        self.single_iteration(app, cause);
    }

-    fn single_iteration<F>(&mut self, callback: &mut F, cause: StartCause)
-    where
-        F: FnMut(Event<T>, &RootActiveEventLoop),
-    {
+    fn single_iteration<A: ApplicationHandler>(&mut self, app: &mut A, cause: StartCause) {
        // NOTE currently just indented to simplify the diff

        // We retain these grow-only scratch buffers as part of the EventLoop
@@ -309,18 +302,17 @@ impl<T: 'static> EventLoop<T> {
        let mut buffer_sink = std::mem::take(&mut self.buffer_sink);
        let mut window_ids = std::mem::take(&mut self.window_ids);

-        callback(Event::NewEvents(cause), &self.window_target);
+        app.new_events(&self.window_target, cause);

        // NB: For consistency all platforms must emit a 'resumed' event even though Wayland
        // applications don't themselves have a formal suspend/resume lifecycle.
        if cause == StartCause::Init {
-            callback(Event::Resumed, &self.window_target);
+            app.resumed(&self.window_target);
        }

-        // Handle pending user events. We don't need back buffer, since we can't dispatch
-        // user events indirectly via callback to the user.
-        for user_event in self.pending_user_events.borrow_mut().drain(..) {
-            callback(Event::UserEvent(user_event), &self.window_target);
+        // Indicate user wake up.
+        if self.with_state(|state| mem::take(&mut state.proxy_wake_up)) {
+            app.proxy_wake_up(&self.window_target);
        }

        // Drain the pending compositor updates.
@@ -341,18 +333,13 @@ impl<T: 'static> EventLoop<T> {
                let old_physical_size = physical_size;

                let new_inner_size = Arc::new(Mutex::new(physical_size));
-                callback(
-                    Event::WindowEvent {
-                        window_id: crate::window::WindowId(window_id),
-                        event: WindowEvent::ScaleFactorChanged {
-                            scale_factor,
-                            inner_size_writer: InnerSizeWriter::new(Arc::downgrade(
-                                &new_inner_size,
-                            )),
-                        },
-                    },
-                    &self.window_target,
-                );
+                let root_window_id = crate::window::WindowId(window_id);
+                let event = WindowEvent::ScaleFactorChanged {
+                    scale_factor,
+                    inner_size_writer: InnerSizeWriter::new(Arc::downgrade(&new_inner_size)),
+                };
+
+                app.window_event(&self.window_target, root_window_id, event);

                let physical_size = *new_inner_size.lock().unwrap();
                drop(new_inner_size);
@@ -395,23 +382,14 @@ impl<T: 'static> EventLoop<T> {
                    size
                });

-                callback(
-                    Event::WindowEvent {
-                        window_id: crate::window::WindowId(window_id),
-                        event: WindowEvent::Resized(physical_size),
-                    },
-                    &self.window_target,
-                );
+                let window_id = crate::window::WindowId(window_id);
+                let event = WindowEvent::Resized(physical_size);
+                app.window_event(&self.window_target, window_id, event);
            }

            if compositor_update.close_window {
-                callback(
-                    Event::WindowEvent {
-                        window_id: crate::window::WindowId(window_id),
-                        event: WindowEvent::CloseRequested,
-                    },
-                    &self.window_target,
-                );
+                let window_id = crate::window::WindowId(window_id);
+                app.window_event(&self.window_target, window_id, WindowEvent::CloseRequested);
            }
        }

@@ -420,8 +398,15 @@ impl<T: 'static> EventLoop<T> {
            buffer_sink.append(&mut state.window_events_sink.lock().unwrap());
        });
        for event in buffer_sink.drain() {
-            let event = event.map_nonuser_event().unwrap();
-            callback(event, &self.window_target);
+            match event {
+                Event::WindowEvent { window_id, event } => {
+                    app.window_event(&self.window_target, window_id, event)
+                },
+                Event::DeviceEvent { device_id, event } => {
+                    app.device_event(&self.window_target, device_id, event)
+                },
+                _ => unreachable!("event which is neither device nor window event."),
+            }
        }

        // Handle non-synthetic events.
@@ -429,8 +414,15 @@ impl<T: 'static> EventLoop<T> {
            buffer_sink.append(&mut state.events_sink);
        });
        for event in buffer_sink.drain() {
-            let event = event.map_nonuser_event().unwrap();
-            callback(event, &self.window_target);
+            match event {
+                Event::WindowEvent { window_id, event } => {
+                    app.window_event(&self.window_target, window_id, event)
+                },
+                Event::DeviceEvent { device_id, event } => {
+                    app.device_event(&self.window_target, device_id, event)
+                },
+                _ => unreachable!("event which is neither device nor window event."),
+            }
        }

        // Collect the window ids
@@ -466,10 +458,8 @@ impl<T: 'static> EventLoop<T> {
            });

            if let Some(event) = event {
-                callback(
-                    Event::WindowEvent { window_id: crate::window::WindowId(*window_id), event },
-                    &self.window_target,
-                );
+                let window_id = crate::window::WindowId(*window_id);
+                app.window_event(&self.window_target, window_id, event);
            }
        }

@@ -479,7 +469,7 @@ impl<T: 'static> EventLoop<T> {
        });

        // This is always the last event we dispatch before poll again
-        callback(Event::AboutToWait, &self.window_target);
+        app.about_to_wait(&self.window_target);

        // Update the window frames and schedule redraws.
        let mut wake_up = false;
@@ -523,8 +513,8 @@ impl<T: 'static> EventLoop<T> {
    }

    #[inline]
-    pub fn create_proxy(&self) -> EventLoopProxy<T> {
-        EventLoopProxy::new(self.user_events_sender.clone())
+    pub fn create_proxy(&self) -> EventLoopProxy {
+        self.event_loop_proxy.clone()
    }

    #[inline]
@@ -586,13 +576,13 @@ impl<T: 'static> EventLoop<T> {
    }
 }

-impl<T> AsFd for EventLoop<T> {
+impl AsFd for EventLoop {
    fn as_fd(&self) -> BorrowedFd<'_> {
        self.event_loop.as_fd()
    }
 }

-impl<T> AsRawFd for EventLoop<T> {
+impl AsRawFd for EventLoop {
    fn as_raw_fd(&self) -> RawFd {
        self.event_loop.as_raw_fd()
    }
--- a/src/platform_impl/linux/wayland/event_loop/proxy.rs
+++ b/src/platform_impl/linux/wayland/event_loop/proxy.rs
@@ -1,28 +1,19 @@
 //! An event loop proxy.

-use std::sync::mpsc::SendError;
-
-use sctk::reexports::calloop::channel::Sender;
-
-use crate::event_loop::EventLoopClosed;
+use sctk::reexports::calloop::ping::Ping;

 /// A handle that can be sent across the threads and used to wake up the `EventLoop`.
-pub struct EventLoopProxy<T: 'static> {
-    user_events_sender: Sender<T>,
+#[derive(Clone)]
+pub struct EventLoopProxy {
+    ping: Ping,
 }

-impl<T: 'static> Clone for EventLoopProxy<T> {
-    fn clone(&self) -> Self {
-        EventLoopProxy { user_events_sender: self.user_events_sender.clone() }
-    }
-}
-
-impl<T: 'static> EventLoopProxy<T> {
-    pub fn new(user_events_sender: Sender<T>) -> Self {
-        Self { user_events_sender }
+impl EventLoopProxy {
+    pub fn new(ping: Ping) -> Self {
+        Self { ping }
    }

-    pub fn send_event(&self, event: T) -> Result<(), EventLoopClosed<T>> {
-        self.user_events_sender.send(event).map_err(|SendError(error)| EventLoopClosed(error))
+    pub fn wake_up(&self) {
+        self.ping.ping();
    }
 }
--- a/src/platform_impl/linux/wayland/event_loop/sink.rs
+++ b/src/platform_impl/linux/wayland/event_loop/sink.rs
@@ -12,7 +12,7 @@ use super::{DeviceId, WindowId};
 /// to the winit's user.
 #[derive(Default)]
 pub struct EventSink {
-    pub window_events: Vec<Event<()>>,
+    pub(crate) window_events: Vec<Event>,
 }

 impl EventSink {
@@ -47,7 +47,7 @@ impl EventSink {
    }

    #[inline]
-    pub fn drain(&mut self) -> Drain<'_, Event<()>> {
+    pub(crate) fn drain(&mut self) -> Drain<'_, Event> {
        self.window_events.drain(..)
    }
 }
--- a/src/platform_impl/linux/wayland/mod.rs
+++ b/src/platform_impl/linux/wayland/mod.rs
@@ -1,5 +1,3 @@
-#![cfg(wayland_platform)]
-
 //! Winit's Wayland backend.

 use std::fmt::Display;
--- a/src/platform_impl/linux/wayland/state.rs
+++ b/src/platform_impl/linux/wayland/state.rs
@@ -115,6 +115,9 @@ pub struct WinitState {
    /// Whether we have dispatched events to the user thus we want to
    /// send `AboutToWait` and normally wakeup the user.
    pub dispatched_events: bool,
+
+    /// Whether the user initiated a wake up.
+    pub proxy_wake_up: bool,
 }

 impl WinitState {
@@ -192,6 +195,7 @@ impl WinitState {
            loop_handle,
            // Make it true by default.
            dispatched_events: true,
+            proxy_wake_up: false,
        })
    }

--- a/src/platform_impl/linux/x11/event_processor.rs
+++ b/src/platform_impl/linux/x11/event_processor.rs
@@ -72,9 +72,9 @@ pub struct EventProcessor {
 }

 impl EventProcessor {
-    pub fn process_event<T: 'static, F>(&mut self, xev: &mut XEvent, mut callback: F)
+    pub(crate) fn process_event<F>(&mut self, xev: &mut XEvent, mut callback: F)
    where
-        F: FnMut(&RootAEL, Event<T>),
+        F: FnMut(&RootAEL, Event),
    {
        self.process_xevent(xev, &mut callback);

@@ -139,9 +139,9 @@ impl EventProcessor {
        }
    }

-    fn process_xevent<T: 'static, F>(&mut self, xev: &mut XEvent, mut callback: F)
+    fn process_xevent<F>(&mut self, xev: &mut XEvent, mut callback: F)
    where
-        F: FnMut(&RootAEL, Event<T>),
+        F: FnMut(&RootAEL, Event),
    {
        let event_type = xev.get_type();

@@ -387,9 +387,9 @@ impl EventProcessor {
        }
    }

-    fn client_message<T: 'static, F>(&mut self, xev: &XClientMessageEvent, mut callback: F)
+    fn client_message<F>(&mut self, xev: &XClientMessageEvent, mut callback: F)
    where
-        F: FnMut(&RootAEL, Event<T>),
+        F: FnMut(&RootAEL, Event),
    {
        let wt = Self::window_target(&self.target);
        let atoms = wt.xconn.atoms();
@@ -434,7 +434,7 @@ impl EventProcessor {
            let flags = xev.data.get_long(1);
            let version = flags >> 24;
            self.dnd.version = Some(version);
-            let has_more_types = flags - (flags & (c_long::max_value() - 1)) == 1;
+            let has_more_types = flags - (flags & (c_long::MAX - 1)) == 1;
            if !has_more_types {
                let type_list = vec![
                    xev.data.get_long(2) as xproto::Atom,
@@ -552,9 +552,9 @@ impl EventProcessor {
        }
    }

-    fn selection_notify<T: 'static, F>(&mut self, xev: &XSelectionEvent, mut callback: F)
+    fn selection_notify<F>(&mut self, xev: &XSelectionEvent, mut callback: F)
    where
-        F: FnMut(&RootAEL, Event<T>),
+        F: FnMut(&RootAEL, Event),
    {
        let wt = Self::window_target(&self.target);
        let atoms = wt.xconn.atoms();
@@ -586,9 +586,9 @@ impl EventProcessor {
        }
    }

-    fn configure_notify<T: 'static, F>(&self, xev: &XConfigureEvent, mut callback: F)
+    fn configure_notify<F>(&self, xev: &XConfigureEvent, mut callback: F)
    where
-        F: FnMut(&RootAEL, Event<T>),
+        F: FnMut(&RootAEL, Event),
    {
        let wt = Self::window_target(&self.target);

@@ -781,9 +781,9 @@ impl EventProcessor {
        });
    }

-    fn map_notify<T: 'static, F>(&self, xev: &XMapEvent, mut callback: F)
+    fn map_notify<F>(&self, xev: &XMapEvent, mut callback: F)
    where
-        F: FnMut(&RootAEL, Event<T>),
+        F: FnMut(&RootAEL, Event),
    {
        let window = xev.window as xproto::Window;
        let window_id = mkwid(window);
@@ -799,9 +799,9 @@ impl EventProcessor {
        callback(&self.target, event);
    }

-    fn destroy_notify<T: 'static, F>(&self, xev: &XDestroyWindowEvent, mut callback: F)
+    fn destroy_notify<F>(&self, xev: &XDestroyWindowEvent, mut callback: F)
    where
-        F: FnMut(&RootAEL, Event<T>),
+        F: FnMut(&RootAEL, Event),
    {
        let wt = Self::window_target(&self.target);

@@ -823,9 +823,9 @@ impl EventProcessor {
        callback(&self.target, Event::WindowEvent { window_id, event: WindowEvent::Destroyed });
    }

-    fn property_notify<T: 'static, F>(&mut self, xev: &XPropertyEvent, mut callback: F)
+    fn property_notify<F>(&mut self, xev: &XPropertyEvent, mut callback: F)
    where
-        F: FnMut(&RootAEL, Event<T>),
+        F: FnMut(&RootAEL, Event),
    {
        let wt = Self::window_target(&self.target);
        let atoms = wt.x_connection().atoms();
@@ -838,9 +838,9 @@ impl EventProcessor {
        }
    }

-    fn visibility_notify<T: 'static, F>(&self, xev: &XVisibilityEvent, mut callback: F)
+    fn visibility_notify<F>(&self, xev: &XVisibilityEvent, mut callback: F)
    where
-        F: FnMut(&RootAEL, Event<T>),
+        F: FnMut(&RootAEL, Event),
    {
        let xwindow = xev.window as xproto::Window;

@@ -855,9 +855,9 @@ impl EventProcessor {
        });
    }

-    fn expose<T: 'static, F>(&self, xev: &XExposeEvent, mut callback: F)
+    fn expose<F>(&self, xev: &XExposeEvent, mut callback: F)
    where
-        F: FnMut(&RootAEL, Event<T>),
+        F: FnMut(&RootAEL, Event),
    {
        // Multiple Expose events may be received for subareas of a window.
        // We issue `RedrawRequested` only for the last event of such a series.
@@ -871,13 +871,9 @@ impl EventProcessor {
        }
    }

-    fn xinput_key_input<T: 'static, F>(
-        &mut self,
-        xev: &mut XKeyEvent,
-        state: ElementState,
-        mut callback: F,
-    ) where
-        F: FnMut(&RootAEL, Event<T>),
+    fn xinput_key_input<F>(&mut self, xev: &mut XKeyEvent, state: ElementState, mut callback: F)
+    where
+        F: FnMut(&RootAEL, Event),
    {
        let wt = Self::window_target(&self.target);

@@ -989,13 +985,13 @@ impl EventProcessor {
        }
    }

-    fn send_synthic_modifier_from_core<T: 'static, F>(
+    fn send_synthic_modifier_from_core<F>(
        &mut self,
        window_id: crate::window::WindowId,
        state: u16,
        mut callback: F,
    ) where
-        F: FnMut(&RootAEL, Event<T>),
+        F: FnMut(&RootAEL, Event),
    {
        let keymap = match self.xkb_context.keymap_mut() {
            Some(keymap) => keymap,
@@ -1022,13 +1018,9 @@ impl EventProcessor {
        callback(&self.target, event);
    }

-    fn xinput2_button_input<T: 'static, F>(
-        &self,
-        event: &XIDeviceEvent,
-        state: ElementState,
-        mut callback: F,
-    ) where
-        F: FnMut(&RootAEL, Event<T>),
+    fn xinput2_button_input<F>(&self, event: &XIDeviceEvent, state: ElementState, mut callback: F)
+    where
+        F: FnMut(&RootAEL, Event),
    {
        let wt = Self::window_target(&self.target);
        let window_id = mkwid(event.event as xproto::Window);
@@ -1079,9 +1071,9 @@ impl EventProcessor {
        callback(&self.target, event);
    }

-    fn xinput2_mouse_motion<T: 'static, F>(&self, event: &XIDeviceEvent, mut callback: F)
+    fn xinput2_mouse_motion<F>(&self, event: &XIDeviceEvent, mut callback: F)
    where
-        F: FnMut(&RootAEL, Event<T>),
+        F: FnMut(&RootAEL, Event),
    {
        let wt = Self::window_target(&self.target);

@@ -1157,9 +1149,9 @@ impl EventProcessor {
        }
    }

-    fn xinput2_mouse_enter<T: 'static, F>(&self, event: &XIEnterEvent, mut callback: F)
+    fn xinput2_mouse_enter<F>(&self, event: &XIEnterEvent, mut callback: F)
    where
-        F: FnMut(&RootAEL, Event<T>),
+        F: FnMut(&RootAEL, Event),
    {
        let wt = Self::window_target(&self.target);

@@ -1202,9 +1194,9 @@ impl EventProcessor {
        }
    }

-    fn xinput2_mouse_left<T: 'static, F>(&self, event: &XILeaveEvent, mut callback: F)
+    fn xinput2_mouse_left<F>(&self, event: &XILeaveEvent, mut callback: F)
    where
-        F: FnMut(&RootAEL, Event<T>),
+        F: FnMut(&RootAEL, Event),
    {
        let wt = Self::window_target(&self.target);
        let window = event.event as xproto::Window;
@@ -1225,9 +1217,9 @@ impl EventProcessor {
        }
    }

-    fn xinput2_focused<T: 'static, F>(&mut self, xev: &XIFocusInEvent, mut callback: F)
+    fn xinput2_focused<F>(&mut self, xev: &XIFocusInEvent, mut callback: F)
    where
-        F: FnMut(&RootAEL, Event<T>),
+        F: FnMut(&RootAEL, Event),
    {
        let wt = Self::window_target(&self.target);
        let window = xev.event as xproto::Window;
@@ -1284,9 +1276,9 @@ impl EventProcessor {
        callback(&self.target, event);
    }

-    fn xinput2_unfocused<T: 'static, F>(&mut self, xev: &XIFocusOutEvent, mut callback: F)
+    fn xinput2_unfocused<F>(&mut self, xev: &XIFocusOutEvent, mut callback: F)
    where
-        F: FnMut(&RootAEL, Event<T>),
+        F: FnMut(&RootAEL, Event),
    {
        let wt = Self::window_target(&self.target);
        let window = xev.event as xproto::Window;
@@ -1336,13 +1328,9 @@ impl EventProcessor {
        }
    }

-    fn xinput2_touch<T: 'static, F>(
-        &mut self,
-        xev: &XIDeviceEvent,
-        phase: TouchPhase,
-        mut callback: F,
-    ) where
-        F: FnMut(&RootAEL, Event<T>),
+    fn xinput2_touch<F>(&mut self, xev: &XIDeviceEvent, phase: TouchPhase, mut callback: F)
+    where
+        F: FnMut(&RootAEL, Event),
    {
        let wt = Self::window_target(&self.target);

@@ -1382,13 +1370,9 @@ impl EventProcessor {
        }
    }

-    fn xinput2_raw_button_input<T: 'static, F>(
-        &self,
-        xev: &XIRawEvent,
-        state: ElementState,
-        mut callback: F,
-    ) where
-        F: FnMut(&RootAEL, Event<T>),
+    fn xinput2_raw_button_input<F>(&self, xev: &XIRawEvent, state: ElementState, mut callback: F)
+    where
+        F: FnMut(&RootAEL, Event),
    {
        let wt = Self::window_target(&self.target);

@@ -1404,9 +1388,9 @@ impl EventProcessor {
        }
    }

-    fn xinput2_raw_mouse_motion<T: 'static, F>(&self, xev: &XIRawEvent, mut callback: F)
+    fn xinput2_raw_mouse_motion<F>(&self, xev: &XIRawEvent, mut callback: F)
    where
-        F: FnMut(&RootAEL, Event<T>),
+        F: FnMut(&RootAEL, Event),
    {
        let wt = Self::window_target(&self.target);

@@ -1424,7 +1408,7 @@ impl EventProcessor {
            if !xinput2::XIMaskIsSet(mask, i) {
                continue;
            }
-            let x = unsafe { *value };
+            let x = unsafe { value.read_unaligned() };

            // We assume that every XInput2 device with analog axes is a pointing device emitting
            // relative coordinates.
@@ -1464,13 +1448,9 @@ impl EventProcessor {
        }
    }

-    fn xinput2_raw_key_input<T: 'static, F>(
-        &mut self,
-        xev: &XIRawEvent,
-        state: ElementState,
-        mut callback: F,
-    ) where
-        F: FnMut(&RootAEL, Event<T>),
+    fn xinput2_raw_key_input<F>(&mut self, xev: &XIRawEvent, state: ElementState, mut callback: F)
+    where
+        F: FnMut(&RootAEL, Event),
    {
        let wt = Self::window_target(&self.target);

@@ -1490,9 +1470,9 @@ impl EventProcessor {
        });
    }

-    fn xinput2_hierarchy_changed<T: 'static, F>(&mut self, xev: &XIHierarchyEvent, mut callback: F)
+    fn xinput2_hierarchy_changed<F>(&mut self, xev: &XIHierarchyEvent, mut callback: F)
    where
-        F: FnMut(&RootAEL, Event<T>),
+        F: FnMut(&RootAEL, Event),
    {
        let wt = Self::window_target(&self.target);

@@ -1517,9 +1497,9 @@ impl EventProcessor {
        }
    }

-    fn xkb_event<T: 'static, F>(&mut self, xev: &XkbAnyEvent, mut callback: F)
+    fn xkb_event<F>(&mut self, xev: &XkbAnyEvent, mut callback: F)
    where
-        F: FnMut(&RootAEL, Event<T>),
+        F: FnMut(&RootAEL, Event),
    {
        let wt = Self::window_target(&self.target);
        match xev.xkb_type {
@@ -1596,14 +1576,14 @@ impl EventProcessor {
        }
    }

-    pub fn update_mods_from_xinput2_event<T: 'static, F>(
+    pub(crate) fn update_mods_from_xinput2_event<F>(
        &mut self,
        mods: &XIModifierState,
        group: &XIModifierState,
        force: bool,
        mut callback: F,
    ) where
-        F: FnMut(&RootAEL, Event<T>),
+        F: FnMut(&RootAEL, Event),
    {
        if let Some(state) = self.xkb_context.state_mut() {
            state.update_modifiers(
@@ -1627,12 +1607,9 @@ impl EventProcessor {
        }
    }

-    fn update_mods_from_query<T: 'static, F>(
-        &mut self,
-        window_id: crate::window::WindowId,
-        mut callback: F,
-    ) where
-        F: FnMut(&RootAEL, Event<T>),
+    fn update_mods_from_query<F>(&mut self, window_id: crate::window::WindowId, mut callback: F)
+    where
+        F: FnMut(&RootAEL, Event),
    {
        let wt = Self::window_target(&self.target);

@@ -1661,13 +1638,13 @@ impl EventProcessor {
        self.send_modifiers(window_id, mods.into(), true, &mut callback)
    }

-    pub fn update_mods_from_core_event<T: 'static, F>(
+    pub(crate) fn update_mods_from_core_event<F>(
        &mut self,
        window_id: crate::window::WindowId,
        state: u16,
        mut callback: F,
    ) where
-        F: FnMut(&RootAEL, Event<T>),
+        F: FnMut(&RootAEL, Event),
    {
        let xkb_mask = self.xkb_mod_mask_from_core(state);
        let xkb_state = match self.xkb_context.state_mut() {
@@ -1740,7 +1717,7 @@ impl EventProcessor {
    ///
    /// The event won't be sent when the `modifiers` match the previously `sent` modifiers value,
    /// unless `force` is passed. The `force` should be passed when the active window changes.
-    fn send_modifiers<T: 'static, F: FnMut(&RootAEL, Event<T>)>(
+    fn send_modifiers<F: FnMut(&RootAEL, Event)>(
        &self,
        window_id: crate::window::WindowId,
        modifiers: ModifiersState,
@@ -1758,14 +1735,14 @@ impl EventProcessor {
        }
    }

-    fn handle_pressed_keys<T: 'static, F>(
+    fn handle_pressed_keys<F>(
        target: &RootAEL,
        window_id: crate::window::WindowId,
        state: ElementState,
        xkb_context: &mut Context,
        callback: &mut F,
    ) where
-        F: FnMut(&RootAEL, Event<T>),
+        F: FnMut(&RootAEL, Event),
    {
        let device_id = mkdid(util::VIRTUAL_CORE_KEYBOARD);

@@ -1800,9 +1777,9 @@ impl EventProcessor {
        }
    }

-    fn process_dpi_change<T: 'static, F>(&self, callback: &mut F)
+    fn process_dpi_change<F>(&self, callback: &mut F)
    where
-        F: FnMut(&RootAEL, Event<T>),
+        F: FnMut(&RootAEL, Event),
    {
        let wt = Self::window_target(&self.target);
        wt.xconn.reload_database().expect("failed to reload Xft database");
--- a/src/platform_impl/linux/x11/ime/context.rs
+++ b/src/platform_impl/linux/x11/ime/context.rs
@@ -158,7 +158,9 @@ struct PreeditCallbacks {
 impl PreeditCallbacks {
    pub fn new(client_data: ffi::XPointer) -> PreeditCallbacks {
        let start_callback = create_xim_callback(client_data, unsafe {
-            mem::transmute(preedit_start_callback as usize)
+            mem::transmute::<usize, unsafe extern "C" fn(ffi::XIM, ffi::XPointer, ffi::XPointer)>(
+                preedit_start_callback as usize,
+            )
        });
        let done_callback = create_xim_callback(client_data, preedit_done_callback);
        let caret_callback = create_xim_callback(client_data, preedit_caret_callback);
--- a/src/platform_impl/linux/x11/mod.rs
+++ b/src/platform_impl/linux/x11/mod.rs
@@ -1,5 +1,3 @@
-#![cfg(x11_platform)]
-
 use std::cell::{Cell, RefCell};
 use std::collections::{HashMap, HashSet, VecDeque};
 use std::ffi::CStr;
@@ -11,7 +9,7 @@ use std::os::unix::io::{AsFd, AsRawFd, BorrowedFd, RawFd};
 use std::sync::mpsc::{self, Receiver, Sender, TryRecvError};
 use std::sync::{Arc, Weak};
 use std::time::{Duration, Instant};
-use std::{fmt, ptr, slice, str};
+use std::{fmt, mem, ptr, slice, str};

 use calloop::generic::Generic;
 use calloop::ping::Ping;
@@ -27,9 +25,10 @@ use x11rb::protocol::xproto::{self, ConnectionExt as _};
 use x11rb::x11_utils::X11Error as LogicalError;
 use x11rb::xcb_ffi::ReplyOrIdError;

+use crate::application::ApplicationHandler;
 use crate::error::{EventLoopError, OsError as RootOsError};
 use crate::event::{Event, StartCause, WindowEvent};
-use crate::event_loop::{ActiveEventLoop as RootAEL, ControlFlow, DeviceEvents, EventLoopClosed};
+use crate::event_loop::{ActiveEventLoop as RootAEL, ControlFlow, DeviceEvents};
 use crate::platform::pump_events::PumpStatus;
 use crate::platform_impl::common::xkb::Context;
 use crate::platform_impl::platform::{min_timeout, WindowId};
@@ -82,12 +81,11 @@ impl<T> Clone for WakeSender<T> {
 }

 impl<T> WakeSender<T> {
-    pub fn send(&self, t: T) -> Result<(), EventLoopClosed<T>> {
-        let res = self.sender.send(t).map_err(|e| EventLoopClosed(e.0));
+    pub fn send(&self, t: T) {
+        let res = self.sender.send(t);
        if res.is_ok() {
            self.waker.ping();
        }
-        res
    }
 }

@@ -142,15 +140,13 @@ pub struct ActiveEventLoop {
    device_events: Cell<DeviceEvents>,
 }

-pub struct EventLoop<T: 'static> {
+pub struct EventLoop {
    loop_running: bool,
    event_loop: Loop<'static, EventLoopState>,
-    waker: calloop::ping::Ping,
    event_processor: EventProcessor,
    redraw_receiver: PeekableReceiver<WindowId>,
-    user_receiver: PeekableReceiver<T>,
    activation_receiver: PeekableReceiver<ActivationToken>,
-    user_sender: Sender<T>,
+    event_loop_proxy: EventLoopProxy,

    /// The current state of the event loop.
    state: EventLoopState,
@@ -161,20 +157,13 @@ type ActivationToken = (WindowId, crate::event_loop::AsyncRequestSerial);
 struct EventLoopState {
    /// The latest readiness state for the x11 file descriptor
    x11_readiness: Readiness,
+
+    /// User requested a wake up.
+    proxy_wake_up: bool,
 }

-pub struct EventLoopProxy<T: 'static> {
-    user_sender: WakeSender<T>,
-}
-
-impl<T: 'static> Clone for EventLoopProxy<T> {
-    fn clone(&self) -> Self {
-        EventLoopProxy { user_sender: self.user_sender.clone() }
-    }
-}
-
-impl<T: 'static> EventLoop<T> {
-    pub(crate) fn new(xconn: Arc<XConnection>) -> EventLoop<T> {
+impl EventLoop {
+    pub(crate) fn new(xconn: Arc<XConnection>) -> EventLoop {
        let root = xconn.default_root().root;
        let atoms = xconn.atoms();

@@ -278,7 +267,16 @@ impl<T: 'static> EventLoop<T> {
        let (activation_token_sender, activation_token_channel) = mpsc::channel();

        // Create a channel for sending user events.
-        let (user_sender, user_channel) = mpsc::channel();
+        let (user_waker, user_waker_source) =
+            calloop::ping::make_ping().expect("Failed to create user event loop waker.");
+        event_loop
+            .handle()
+            .insert_source(user_waker_source, move |_, _, state| {
+                // No extra handling is required, we just need to wake-up.
+                state.proxy_wake_up = true;
+            })
+            .expect("Failed to register the event loop waker source");
+        let event_loop_proxy = EventLoopProxy::new(user_waker);

        let xkb_context =
            Context::from_x11_xkb(xconn.xcb_connection().get_raw_xcb_connection()).unwrap();
@@ -359,32 +357,32 @@ impl<T: 'static> EventLoop<T> {
        EventLoop {
            loop_running: false,
            event_loop,
-            waker,
            event_processor,
            redraw_receiver: PeekableReceiver::from_recv(redraw_channel),
            activation_receiver: PeekableReceiver::from_recv(activation_token_channel),
-            user_receiver: PeekableReceiver::from_recv(user_channel),
-            user_sender,
-            state: EventLoopState { x11_readiness: Readiness::EMPTY },
+            event_loop_proxy,
+            state: EventLoopState { x11_readiness: Readiness::EMPTY, proxy_wake_up: false },
        }
    }

-    pub fn create_proxy(&self) -> EventLoopProxy<T> {
-        EventLoopProxy {
-            user_sender: WakeSender { sender: self.user_sender.clone(), waker: self.waker.clone() },
-        }
+    pub fn create_proxy(&self) -> EventLoopProxy {
+        self.event_loop_proxy.clone()
    }

    pub(crate) fn window_target(&self) -> &RootAEL {
        &self.event_processor.target
    }

-    pub fn run_on_demand<F>(&mut self, mut event_handler: F) -> Result<(), EventLoopError>
-    where
-        F: FnMut(Event<T>, &RootAEL),
-    {
+    pub fn run_app<A: ApplicationHandler>(mut self, app: &mut A) -> Result<(), EventLoopError> {
+        self.run_app_on_demand(app)
+    }
+
+    pub fn run_app_on_demand<A: ApplicationHandler>(
+        &mut self,
+        app: &mut A,
+    ) -> Result<(), EventLoopError> {
        let exit = loop {
-            match self.pump_events(None, &mut event_handler) {
+            match self.pump_app_events(None, app) {
                PumpStatus::Exit(0) => {
                    break Ok(());
                },
@@ -409,26 +407,27 @@ impl<T: 'static> EventLoop<T> {
        exit
    }

-    pub fn pump_events<F>(&mut self, timeout: Option<Duration>, mut callback: F) -> PumpStatus
-    where
-        F: FnMut(Event<T>, &RootAEL),
-    {
+    pub fn pump_app_events<A: ApplicationHandler>(
+        &mut self,
+        timeout: Option<Duration>,
+        app: &mut A,
+    ) -> PumpStatus {
        if !self.loop_running {
            self.loop_running = true;

            // run the initial loop iteration
-            self.single_iteration(&mut callback, StartCause::Init);
+            self.single_iteration(app, StartCause::Init);
        }

        // Consider the possibility that the `StartCause::Init` iteration could
        // request to Exit.
        if !self.exiting() {
-            self.poll_events_with_timeout(timeout, &mut callback);
+            self.poll_events_with_timeout(timeout, app);
        }
        if let Some(code) = self.exit_code() {
            self.loop_running = false;

-            callback(Event::LoopExiting, self.window_target());
+            app.exiting(self.window_target());

            PumpStatus::Exit(code)
        } else {
@@ -438,14 +437,15 @@ impl<T: 'static> EventLoop<T> {

    fn has_pending(&mut self) -> bool {
        self.event_processor.poll()
-            || self.user_receiver.has_incoming()
+            || self.state.proxy_wake_up
            || self.redraw_receiver.has_incoming()
    }

-    pub fn poll_events_with_timeout<F>(&mut self, mut timeout: Option<Duration>, mut callback: F)
-    where
-        F: FnMut(Event<T>, &RootAEL),
-    {
+    pub fn poll_events_with_timeout<A: ApplicationHandler>(
+        &mut self,
+        mut timeout: Option<Duration>,
+        app: &mut A,
+    ) {
        let start = Instant::now();

        let has_pending = self.has_pending();
@@ -503,23 +503,20 @@ impl<T: 'static> EventLoop<T> {
            return;
        }

-        self.single_iteration(&mut callback, cause);
+        self.single_iteration(app, cause);
    }

-    fn single_iteration<F>(&mut self, callback: &mut F, cause: StartCause)
-    where
-        F: FnMut(Event<T>, &RootAEL),
-    {
-        callback(Event::NewEvents(cause), &self.event_processor.target);
+    fn single_iteration<A: ApplicationHandler>(&mut self, app: &mut A, cause: StartCause) {
+        app.new_events(&self.event_processor.target, cause);

        // NB: For consistency all platforms must emit a 'resumed' event even though X11
        // applications don't themselves have a formal suspend/resume lifecycle.
        if cause == StartCause::Init {
-            callback(Event::Resumed, &self.event_processor.target);
+            app.resumed(&self.event_processor.target)
        }

        // Process all pending events
-        self.drain_events(callback);
+        self.drain_events(app);

        // Empty activation tokens.
        while let Ok((window_id, serial)) = self.activation_receiver.try_recv() {
@@ -529,14 +526,12 @@ impl<T: 'static> EventLoop<T> {

            match token {
                Some(Ok(token)) => {
-                    let event = Event::WindowEvent {
-                        window_id: crate::window::WindowId(window_id),
-                        event: WindowEvent::ActivationTokenDone {
-                            serial,
-                            token: crate::window::ActivationToken::_new(token),
-                        },
+                    let window_id = crate::window::WindowId(window_id);
+                    let event = WindowEvent::ActivationTokenDone {
+                        serial,
+                        token: crate::window::ActivationToken::_new(token),
                    };
-                    callback(event, &self.event_processor.target)
+                    app.window_event(&self.event_processor.target, window_id, event);
                },
                Some(Err(e)) => {
                    tracing::error!("Failed to get activation token: {}", e);
@@ -546,10 +541,8 @@ impl<T: 'static> EventLoop<T> {
        }

        // Empty the user event buffer
-        {
-            while let Ok(event) = self.user_receiver.try_recv() {
-                callback(Event::UserEvent(event), &self.event_processor.target);
-            }
+        if mem::take(&mut self.state.proxy_wake_up) {
+            app.proxy_wake_up(&self.event_processor.target);
        }

        // Empty the redraw requests
@@ -562,37 +555,41 @@ impl<T: 'static> EventLoop<T> {

            for window_id in windows {
                let window_id = crate::window::WindowId(window_id);
-                callback(
-                    Event::WindowEvent { window_id, event: WindowEvent::RedrawRequested },
+                app.window_event(
                    &self.event_processor.target,
+                    window_id,
+                    WindowEvent::RedrawRequested,
                );
            }
        }

        // This is always the last event we dispatch before poll again
-        {
-            callback(Event::AboutToWait, &self.event_processor.target);
-        }
+        app.about_to_wait(&self.event_processor.target);
    }

-    fn drain_events<F>(&mut self, callback: &mut F)
-    where
-        F: FnMut(Event<T>, &RootAEL),
-    {
+    fn drain_events<A: ApplicationHandler>(&mut self, app: &mut A) {
        let mut xev = MaybeUninit::uninit();

        while unsafe { self.event_processor.poll_one_event(xev.as_mut_ptr()) } {
            let mut xev = unsafe { xev.assume_init() };
-            self.event_processor.process_event(&mut xev, |window_target, event| {
+            self.event_processor.process_event(&mut xev, |window_target, event: Event| {
                if let Event::WindowEvent {
                    window_id: crate::window::WindowId(wid),
                    event: WindowEvent::RedrawRequested,
                } = event
                {
                    let window_target = EventProcessor::window_target(window_target);
-                    window_target.redraw_sender.send(wid).unwrap();
+                    window_target.redraw_sender.send(wid);
                } else {
-                    callback(event, window_target);
+                    match event {
+                        Event::WindowEvent { window_id, event } => {
+                            app.window_event(window_target, window_id, event)
+                        },
+                        Event::DeviceEvent { device_id, event } => {
+                            app.device_event(window_target, device_id, event)
+                        },
+                        _ => unreachable!("event which is neither device nor window event."),
+                    }
                }
            });
        }
@@ -619,13 +616,13 @@ impl<T: 'static> EventLoop<T> {
    }
 }

-impl<T> AsFd for EventLoop<T> {
+impl AsFd for EventLoop {
    fn as_fd(&self) -> BorrowedFd<'_> {
        self.event_loop.as_fd()
    }
 }

-impl<T> AsRawFd for EventLoop<T> {
+impl AsRawFd for EventLoop {
    fn as_raw_fd(&self) -> RawFd {
        self.event_loop.as_raw_fd()
    }
@@ -725,9 +722,9 @@ impl ActiveEventLoop {
    }
 }

-impl<T: 'static> EventLoopProxy<T> {
-    pub fn send_event(&self, event: T) -> Result<(), EventLoopClosed<T>> {
-        self.user_sender.send(event).map_err(|e| EventLoopClosed(e.0))
+impl EventLoopProxy {
+    pub fn wake_up(&self) {
+        self.ping.ping();
    }
 }

@@ -811,6 +808,17 @@ impl Drop for Window {
    }
 }

+#[derive(Clone)]
+pub struct EventLoopProxy {
+    ping: Ping,
+}
+
+impl EventLoopProxy {
+    fn new(ping: Ping) -> Self {
+        Self { ping }
+    }
+}
+
 /// Generic sum error type for X11 errors.
 #[derive(Debug)]
 pub enum X11Error {
--- a/src/platform_impl/linux/x11/window.rs
+++ b/src/platform_impl/linux/x11/window.rs
@@ -876,11 +876,11 @@ impl UnownedWindow {

    /// Refresh the API for the given monitor.
    #[inline]
-    pub(super) fn refresh_dpi_for_monitor<T: 'static>(
+    pub(super) fn refresh_dpi_for_monitor(
        &self,
        new_monitor: &X11MonitorHandle,
        maybe_prev_scale_factor: Option<f64>,
-        mut callback: impl FnMut(Event<T>),
+        mut callback: impl FnMut(Event),
    ) {
        // Check if the self is on this monitor
        let monitor = self.shared_state_lock().last_monitor.clone();
@@ -1805,9 +1805,7 @@ impl UnownedWindow {
    #[inline]
    pub fn request_activation_token(&self) -> Result<AsyncRequestSerial, NotSupportedError> {
        let serial = AsyncRequestSerial::get();
-        self.activation_sender
-            .send((self.id(), serial))
-            .expect("activation token channel should never be closed");
+        self.activation_sender.send((self.id(), serial));
        Ok(serial)
    }

@@ -1818,7 +1816,7 @@ impl UnownedWindow {

    #[inline]
    pub fn request_redraw(&self) {
-        self.redraw_sender.send(WindowId(self.xwindow as _)).unwrap();
+        self.redraw_sender.send(WindowId(self.xwindow as _));
    }

    #[inline]
--- a/src/platform_impl/mod.rs
+++ b/src/platform_impl/mod.rs
@@ -1,27 +1,31 @@
 use crate::monitor::{MonitorHandle as RootMonitorHandle, VideoModeHandle as RootVideoModeHandle};
 use crate::window::Fullscreen as RootFullscreen;

-#[cfg(windows_platform)]
-#[path = "windows/mod.rs"]
-mod platform;
-#[cfg(any(x11_platform, wayland_platform))]
-#[path = "linux/mod.rs"]
-mod platform;
-#[cfg(macos_platform)]
-#[path = "macos/mod.rs"]
-mod platform;
 #[cfg(android_platform)]
-#[path = "android/mod.rs"]
-mod platform;
-#[cfg(ios_platform)]
-#[path = "ios/mod.rs"]
-mod platform;
-#[cfg(web_platform)]
-#[path = "web/mod.rs"]
-mod platform;
+mod android;
+#[cfg(target_vendor = "apple")]
+mod apple;
+#[cfg(any(x11_platform, wayland_platform))]
+mod linux;
 #[cfg(orbital_platform)]
-#[path = "orbital/mod.rs"]
-mod platform;
+mod orbital;
+#[cfg(web_platform)]
+mod web;
+#[cfg(windows_platform)]
+mod windows;
+
+#[cfg(android_platform)]
+use self::android as platform;
+#[cfg(target_vendor = "apple")]
+use self::apple as platform;
+#[cfg(any(x11_platform, wayland_platform))]
+use self::linux as platform;
+#[cfg(orbital_platform)]
+use self::orbital as platform;
+#[cfg(web_platform)]
+use self::web as platform;
+#[cfg(windows_platform)]
+use self::windows as platform;

 pub use self::platform::*;

--- a/src/platform_impl/orbital/event_loop.rs
+++ b/src/platform_impl/orbital/event_loop.rs
@@ -12,6 +12,7 @@ use orbclient::{
 };
 use smol_str::SmolStr;

+use crate::application::ApplicationHandler;
 use crate::error::EventLoopError;
 use crate::event::{self, Ime, Modifiers, StartCause};
 use crate::event_loop::{self, ControlFlow, DeviceEvents};
@@ -271,16 +272,18 @@ impl EventState {
    }
 }

-pub struct EventLoop<T> {
+pub struct EventLoop {
    windows: Vec<(Arc<RedoxSocket>, EventState)>,
    window_target: event_loop::ActiveEventLoop,
-    user_events_sender: mpsc::Sender<T>,
-    user_events_receiver: mpsc::Receiver<T>,
+    user_events_sender: mpsc::SyncSender<()>,
+    user_events_receiver: mpsc::Receiver<()>,
 }

-impl<T: 'static> EventLoop<T> {
+impl EventLoop {
    pub(crate) fn new(_: &PlatformSpecificEventLoopAttributes) -> Result<Self, EventLoopError> {
-        let (user_events_sender, user_events_receiver) = mpsc::channel();
+        // NOTE: Create a channel which can hold only one event to automatically _squash_ user
+        // events.
+        let (user_events_sender, user_events_receiver) = mpsc::sync_channel(1);

        let event_socket = Arc::new(
            RedoxSocket::event()
@@ -322,14 +325,13 @@ impl<T: 'static> EventLoop<T> {
        })
    }

-    fn process_event<F>(
+    fn process_event<A: ApplicationHandler>(
        window_id: WindowId,
        event_option: EventOption,
        event_state: &mut EventState,
-        mut event_handler: F,
-    ) where
-        F: FnMut(event::Event<T>),
-    {
+        window_target: &event_loop::ActiveEventLoop,
+        app: &mut A,
+    ) {
        match event_option {
            EventOption::Key(KeyEvent { character, scancode, pressed }) => {
                // Convert scancode
@@ -371,125 +373,128 @@ impl<T: 'static> EventLoop<T> {
                    key_without_modifiers = logical_key.clone();
                }

-                event_handler(event::Event::WindowEvent {
-                    window_id: RootWindowId(window_id),
-                    event: event::WindowEvent::KeyboardInput {
-                        device_id: event::DeviceId(DeviceId),
-                        event: event::KeyEvent {
-                            logical_key,
-                            physical_key,
-                            location: KeyLocation::Standard,
-                            state: element_state(pressed),
-                            repeat: false,
-                            text,
-                            platform_specific: KeyEventExtra {
-                                key_without_modifiers,
-                                text_with_all_modifiers,
-                            },
+                let window_id = RootWindowId(window_id);
+                let event = event::WindowEvent::KeyboardInput {
+                    device_id: event::DeviceId(DeviceId),
+                    event: event::KeyEvent {
+                        logical_key,
+                        physical_key,
+                        location: KeyLocation::Standard,
+                        state: element_state(pressed),
+                        repeat: false,
+                        text,
+                        platform_specific: KeyEventExtra {
+                            key_without_modifiers,
+                            text_with_all_modifiers,
                        },
-                        is_synthetic: false,
                    },
-                });
+                    is_synthetic: false,
+                };
+
+                app.window_event(window_target, window_id, event);

                // If the state of the modifiers has changed, send the event.
                if modifiers_before != event_state.keyboard {
-                    event_handler(event::Event::WindowEvent {
-                        window_id: RootWindowId(window_id),
-                        event: event::WindowEvent::ModifiersChanged(event_state.modifiers()),
-                    })
+                    app.window_event(
+                        window_target,
+                        window_id,
+                        event::WindowEvent::ModifiersChanged(event_state.modifiers()),
+                    );
                }
            },
            EventOption::TextInput(TextInputEvent { character }) => {
-                event_handler(event::Event::WindowEvent {
-                    window_id: RootWindowId(window_id),
-                    event: event::WindowEvent::Ime(Ime::Preedit("".into(), None)),
-                });
-                event_handler(event::Event::WindowEvent {
-                    window_id: RootWindowId(window_id),
-                    event: event::WindowEvent::Ime(Ime::Commit(character.into())),
-                });
+                app.window_event(
+                    window_target,
+                    RootWindowId(window_id),
+                    event::WindowEvent::Ime(Ime::Preedit("".into(), None)),
+                );
+                app.window_event(
+                    window_target,
+                    RootWindowId(window_id),
+                    event::WindowEvent::Ime(Ime::Commit(character.into())),
+                );
            },
            EventOption::Mouse(MouseEvent { x, y }) => {
-                event_handler(event::Event::WindowEvent {
-                    window_id: RootWindowId(window_id),
-                    event: event::WindowEvent::CursorMoved {
+                app.window_event(
+                    window_target,
+                    RootWindowId(window_id),
+                    event::WindowEvent::CursorMoved {
                        device_id: event::DeviceId(DeviceId),
                        position: (x, y).into(),
                    },
-                });
+                );
            },
            EventOption::MouseRelative(MouseRelativeEvent { dx, dy }) => {
-                event_handler(event::Event::DeviceEvent {
-                    device_id: event::DeviceId(DeviceId),
-                    event: event::DeviceEvent::MouseMotion { delta: (dx as f64, dy as f64) },
-                });
+                app.device_event(
+                    window_target,
+                    event::DeviceId(DeviceId),
+                    event::DeviceEvent::MouseMotion { delta: (dx as f64, dy as f64) },
+                );
            },
            EventOption::Button(ButtonEvent { left, middle, right }) => {
                while let Some((button, state)) = event_state.mouse(left, middle, right) {
-                    event_handler(event::Event::WindowEvent {
-                        window_id: RootWindowId(window_id),
-                        event: event::WindowEvent::MouseInput {
+                    app.window_event(
+                        window_target,
+                        RootWindowId(window_id),
+                        event::WindowEvent::MouseInput {
                            device_id: event::DeviceId(DeviceId),
                            state,
                            button,
                        },
-                    });
+                    );
                }
            },
            EventOption::Scroll(ScrollEvent { x, y }) => {
-                event_handler(event::Event::WindowEvent {
-                    window_id: RootWindowId(window_id),
-                    event: event::WindowEvent::MouseWheel {
+                app.window_event(
+                    window_target,
+                    RootWindowId(window_id),
+                    event::WindowEvent::MouseWheel {
                        device_id: event::DeviceId(DeviceId),
                        delta: event::MouseScrollDelta::LineDelta(x as f32, y as f32),
                        phase: event::TouchPhase::Moved,
                    },
-                });
+                );
            },
            EventOption::Quit(QuitEvent {}) => {
-                event_handler(event::Event::WindowEvent {
-                    window_id: RootWindowId(window_id),
-                    event: event::WindowEvent::CloseRequested,
-                });
+                app.window_event(
+                    window_target,
+                    RootWindowId(window_id),
+                    event::WindowEvent::CloseRequested,
+                );
            },
            EventOption::Focus(FocusEvent { focused }) => {
-                event_handler(event::Event::WindowEvent {
-                    window_id: RootWindowId(window_id),
-                    event: event::WindowEvent::Focused(focused),
-                });
+                app.window_event(
+                    window_target,
+                    RootWindowId(window_id),
+                    event::WindowEvent::Focused(focused),
+                );
            },
            EventOption::Move(MoveEvent { x, y }) => {
-                event_handler(event::Event::WindowEvent {
-                    window_id: RootWindowId(window_id),
-                    event: event::WindowEvent::Moved((x, y).into()),
-                });
+                app.window_event(
+                    window_target,
+                    RootWindowId(window_id),
+                    event::WindowEvent::Moved((x, y).into()),
+                );
            },
            EventOption::Resize(ResizeEvent { width, height }) => {
-                event_handler(event::Event::WindowEvent {
-                    window_id: RootWindowId(window_id),
-                    event: event::WindowEvent::Resized((width, height).into()),
-                });
+                app.window_event(
+                    window_target,
+                    RootWindowId(window_id),
+                    event::WindowEvent::Resized((width, height).into()),
+                );

                // Acknowledge resize after event loop.
                event_state.resize_opt = Some((width, height));
            },
            // TODO: Screen, Clipboard, Drop
            EventOption::Hover(HoverEvent { entered }) => {
-                if entered {
-                    event_handler(event::Event::WindowEvent {
-                        window_id: RootWindowId(window_id),
-                        event: event::WindowEvent::CursorEntered {
-                            device_id: event::DeviceId(DeviceId),
-                        },
-                    });
+                let event = if entered {
+                    event::WindowEvent::CursorEntered { device_id: event::DeviceId(DeviceId) }
                } else {
-                    event_handler(event::Event::WindowEvent {
-                        window_id: RootWindowId(window_id),
-                        event: event::WindowEvent::CursorLeft {
-                            device_id: event::DeviceId(DeviceId),
-                        },
-                    });
-                }
+                    event::WindowEvent::CursorLeft { device_id: event::DeviceId(DeviceId) }
+                };
+
+                app.window_event(window_target, RootWindowId(window_id), event);
            },
            other => {
                tracing::warn!("unhandled event: {:?}", other);
@@ -497,22 +502,13 @@ impl<T: 'static> EventLoop<T> {
        }
    }

-    pub fn run<F>(mut self, mut event_handler_inner: F) -> Result<(), EventLoopError>
-    where
-        F: FnMut(event::Event<T>, &event_loop::ActiveEventLoop),
-    {
-        let mut event_handler =
-            move |event: event::Event<T>, window_target: &event_loop::ActiveEventLoop| {
-                event_handler_inner(event, window_target);
-            };
-
+    pub fn run_app<A: ApplicationHandler>(mut self, app: &mut A) -> Result<(), EventLoopError> {
        let mut start_cause = StartCause::Init;
-
        loop {
-            event_handler(event::Event::NewEvents(start_cause), &self.window_target);
+            app.new_events(&self.window_target, start_cause);

            if start_cause == StartCause::Init {
-                event_handler(event::Event::Resumed, &self.window_target);
+                app.resumed(&self.window_target);
            }

            // Handle window creates.
@@ -528,23 +524,15 @@ impl<T: 'static> EventLoop<T> {

                self.windows.push((window, EventState::default()));

-                // Send resize event on create to indicate first size.
-                event_handler(
-                    event::Event::WindowEvent {
-                        window_id: RootWindowId(window_id),
-                        event: event::WindowEvent::Resized((properties.w, properties.h).into()),
-                    },
-                    &self.window_target,
-                );
+                let window_id = RootWindowId(window_id);

-                // Send resize event on create to indicate first position.
-                event_handler(
-                    event::Event::WindowEvent {
-                        window_id: RootWindowId(window_id),
-                        event: event::WindowEvent::Moved((properties.x, properties.y).into()),
-                    },
-                    &self.window_target,
-                );
+                // Send resize event on create to indicate first size.
+                let event = event::WindowEvent::Resized((properties.w, properties.h).into());
+                app.window_event(&self.window_target, window_id, event);
+
+                // Send moved event on create to indicate first position.
+                let event = event::WindowEvent::Moved((properties.x, properties.y).into());
+                app.window_event(&self.window_target, window_id, event);
            }

            // Handle window destroys.
@@ -552,14 +540,8 @@ impl<T: 'static> EventLoop<T> {
                let mut destroys = self.window_target.p.destroys.lock().unwrap();
                destroys.pop_front()
            } {
-                event_handler(
-                    event::Event::WindowEvent {
-                        window_id: RootWindowId(destroy_id),
-                        event: event::WindowEvent::Destroyed,
-                    },
-                    &self.window_target,
-                );
-
+                let window_id = RootWindowId(destroy_id);
+                app.window_event(&self.window_target, window_id, event::WindowEvent::Destroyed);
                self.windows.retain(|(window, _event_state)| window.fd as u64 != destroy_id.fd);
            }

@@ -586,7 +568,8 @@ impl<T: 'static> EventLoop<T> {
                        window_id,
                        orbital_event.to_option(),
                        event_state,
-                        |event| event_handler(event, &self.window_target),
+                        &self.window_target,
+                        app,
                    );
                }

@@ -613,8 +596,8 @@ impl<T: 'static> EventLoop<T> {
                i += 1;
            }

-            while let Ok(event) = self.user_events_receiver.try_recv() {
-                event_handler(event::Event::UserEvent(event), &self.window_target);
+            while self.user_events_receiver.try_recv().is_ok() {
+                app.proxy_wake_up(&self.window_target);
            }

            // To avoid deadlocks the redraws lock is not held during event processing.
@@ -622,16 +605,14 @@ impl<T: 'static> EventLoop<T> {
                let mut redraws = self.window_target.p.redraws.lock().unwrap();
                redraws.pop_front()
            } {
-                event_handler(
-                    event::Event::WindowEvent {
-                        window_id: RootWindowId(window_id),
-                        event: event::WindowEvent::RedrawRequested,
-                    },
+                app.window_event(
                    &self.window_target,
+                    RootWindowId(window_id),
+                    event::WindowEvent::RedrawRequested,
                );
            }

-            event_handler(event::Event::AboutToWait, &self.window_target);
+            app.about_to_wait(&self.window_target);

            if self.window_target.p.exiting() {
                break;
@@ -695,7 +676,7 @@ impl<T: 'static> EventLoop<T> {
            }
        }

-        event_handler(event::Event::LoopExiting, &self.window_target);
+        app.exiting(&self.window_target);

        Ok(())
    }
@@ -704,7 +685,7 @@ impl<T: 'static> EventLoop<T> {
        &self.window_target
    }

-    pub fn create_proxy(&self) -> EventLoopProxy<T> {
+    pub fn create_proxy(&self) -> EventLoopProxy {
        EventLoopProxy {
            user_events_sender: self.user_events_sender.clone(),
            wake_socket: self.window_target.p.wake_socket.clone(),
@@ -712,24 +693,22 @@ impl<T: 'static> EventLoop<T> {
    }
 }

-pub struct EventLoopProxy<T: 'static> {
-    user_events_sender: mpsc::Sender<T>,
+pub struct EventLoopProxy {
+    user_events_sender: mpsc::SyncSender<()>,
    wake_socket: Arc<TimeSocket>,
 }

-impl<T> EventLoopProxy<T> {
-    pub fn send_event(&self, event: T) -> Result<(), event_loop::EventLoopClosed<T>> {
-        self.user_events_sender
-            .send(event)
-            .map_err(|mpsc::SendError(x)| event_loop::EventLoopClosed(x))?;
-
-        self.wake_socket.wake().unwrap();
-
-        Ok(())
+impl EventLoopProxy {
+    pub 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();
+        }
    }
 }

-impl<T> Clone for EventLoopProxy<T> {
+impl Clone for EventLoopProxy {
    fn clone(&self) -> Self {
        Self {
            user_events_sender: self.user_events_sender.clone(),
@@ -738,7 +717,7 @@ impl<T> Clone for EventLoopProxy<T> {
    }
 }

-impl<T> Unpin for EventLoopProxy<T> {}
+impl Unpin for EventLoopProxy {}

 pub struct ActiveEventLoop {
    control_flow: Cell<ControlFlow>,
--- a/src/platform_impl/orbital/mod.rs
+++ b/src/platform_impl/orbital/mod.rs
@@ -103,7 +103,7 @@ pub struct WindowId {

 impl WindowId {
    pub const fn dummy() -> Self {
-        WindowId { fd: u64::max_value() }
+        WindowId { fd: u64::MAX }
    }
 }

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

 use super::AtomicWaker;
@@ -11,54 +10,35 @@ pub fn channel<T>() -> (Sender<T>, Receiver<T>) {
    let (sender, receiver) = mpsc::channel();
    let shared = Arc::new(Shared { closed: AtomicBool::new(false), waker: AtomicWaker::new() });

-    let sender =
-        Sender(Arc::new(SenderInner { sender: Mutex::new(sender), shared: Arc::clone(&shared) }));
-    let receiver = Receiver { receiver: Rc::new(receiver), shared };
+    let sender = Sender { sender, shared: Arc::clone(&shared) };
+    let receiver = Receiver { receiver, shared };

    (sender, receiver)
 }

-pub struct Sender<T>(Arc<SenderInner<T>>);
-
-struct SenderInner<T> {
-    // We need to wrap it into a `Mutex` to make it `Sync`. So the sender can't
-    // be accessed on the main thread, as it could block. Additionally we need
-    // to wrap `Sender` in an `Arc` to make it clonable on the main thread without
-    // having to block.
-    sender: Mutex<mpsc::Sender<T>>,
+pub struct Sender<T> {
+    sender: mpsc::Sender<T>,
    shared: Arc<Shared>,
 }

 impl<T> Sender<T> {
    pub fn send(&self, event: T) -> Result<(), SendError<T>> {
-        self.0.sender.lock().unwrap().send(event)?;
-        self.0.shared.waker.wake();
+        self.sender.send(event)?;
+        self.shared.waker.wake();

        Ok(())
    }
 }

-impl<T> SenderInner<T> {
-    fn close(&self) {
+impl<T> Drop for Sender<T> {
+    fn drop(&mut self) {
        self.shared.closed.store(true, Ordering::Relaxed);
        self.shared.waker.wake();
    }
 }

-impl<T> Clone for Sender<T> {
-    fn clone(&self) -> Self {
-        Self(Arc::clone(&self.0))
-    }
-}
-
-impl<T> Drop for SenderInner<T> {
-    fn drop(&mut self) {
-        self.close();
-    }
-}
-
 pub struct Receiver<T> {
-    receiver: Rc<mpsc::Receiver<T>>,
+    receiver: mpsc::Receiver<T>,
    shared: Arc<Shared>,
 }

@@ -95,18 +75,6 @@ impl<T> Receiver<T> {
    }
 }

-impl<T> Clone for Receiver<T> {
-    fn clone(&self) -> Self {
-        Self { receiver: Rc::clone(&self.receiver), shared: Arc::clone(&self.shared) }
-    }
-}
-
-impl<T> Drop for Receiver<T> {
-    fn drop(&mut self) {
-        self.shared.closed.store(true, Ordering::Relaxed);
-    }
-}
-
 struct Shared {
    closed: AtomicBool,
    waker: AtomicWaker,
--- a/src/platform_impl/web/async/dispatcher.rs
+++ b/src/platform_impl/web/async/dispatcher.rs
@@ -1,9 +1,10 @@
 use super::super::main_thread::MainThreadMarker;
 use super::{channel, Receiver, Sender, Wrapper};
 use std::cell::Ref;
+use std::rc::Rc;
 use std::sync::{Arc, Condvar, Mutex};

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

 struct Closure<T>(Box<dyn FnOnce(&T) + Send>);

@@ -11,6 +12,8 @@ impl<T> Dispatcher<T> {
    #[track_caller]
    pub fn new(main_thread: MainThreadMarker, value: T) -> Option<(Self, DispatchRunner<T>)> {
        let (sender, receiver) = channel::<Closure<T>>();
+        let sender = Arc::new(sender);
+        let receiver = Rc::new(receiver);

        Wrapper::new(
            main_thread,
@@ -21,7 +24,7 @@ impl<T> Dispatcher<T> {
                closure(value.borrow().as_ref().unwrap())
            },
            {
-                let receiver = receiver.clone();
+                let receiver = Rc::clone(&receiver);
                move |value| async move {
                    while let Ok(Closure(closure)) = receiver.next().await {
                        // SAFETY: The given `Closure` here isn't really `'static`, so we shouldn't
@@ -68,7 +71,12 @@ impl<T> Dispatcher<T> {
            // SAFETY: The `transmute` is necessary because `Closure` requires `'static`. This is
            // safe because this function won't return until `f` has finished executing. See
            // `Self::new()`.
-            let closure = Closure(unsafe { std::mem::transmute(closure) });
+            let closure = Closure(unsafe {
+                std::mem::transmute::<
+                    Box<dyn FnOnce(&T) + Send>,
+                    Box<dyn FnOnce(&T) + Send + 'static>,
+                >(closure)
+            });

            self.0.send(closure);

@@ -84,8 +92,8 @@ impl<T> Dispatcher<T> {
 }

 pub struct DispatchRunner<T: 'static> {
-    wrapper: Wrapper<T, Sender<Closure<T>>, Closure<T>>,
-    receiver: Receiver<Closure<T>>,
+    wrapper: Wrapper<T, Arc<Sender<Closure<T>>>, Closure<T>>,
+    receiver: Rc<Receiver<Closure<T>>>,
 }

 impl<T> DispatchRunner<T> {
--- a/src/platform_impl/web/async/waker.rs
+++ b/src/platform_impl/web/async/waker.rs
@@ -1,18 +1,18 @@
 use std::future;
-use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
+use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
 use std::task::Poll;

 use super::super::main_thread::MainThreadMarker;
 use super::{AtomicWaker, Wrapper};

-pub struct WakerSpawner<T: 'static>(Wrapper<Handler<T>, Sender, usize>);
+pub struct WakerSpawner<T: 'static>(Wrapper<Handler<T>, Sender, ()>);

-pub struct Waker<T: 'static>(Wrapper<Handler<T>, Sender, usize>);
+pub struct Waker<T: 'static>(Wrapper<Handler<T>, Sender, ()>);

 struct Handler<T> {
    value: T,
-    handler: fn(&T, usize),
+    handler: fn(&T, bool),
 }

 #[derive(Clone)]
@@ -20,9 +20,9 @@ struct Sender(Arc<Inner>);

 impl<T> WakerSpawner<T> {
    #[track_caller]
-    pub fn new(main_thread: MainThreadMarker, value: T, handler: fn(&T, usize)) -> Option<Self> {
+    pub fn new(main_thread: MainThreadMarker, value: T, handler: fn(&T, bool)) -> Option<Self> {
        let inner = Arc::new(Inner {
-            counter: AtomicUsize::new(0),
+            awoken: AtomicBool::new(false),
            waker: AtomicWaker::new(),
            closed: AtomicBool::new(false),
        });
@@ -34,30 +34,26 @@ impl<T> WakerSpawner<T> {
        let wrapper = Wrapper::new(
            main_thread,
            handler,
-            |handler, count| {
+            |handler, _| {
                let handler = handler.borrow();
                let handler = handler.as_ref().unwrap();
-                (handler.handler)(&handler.value, count);
+                (handler.handler)(&handler.value, true);
            },
            {
                let inner = Arc::clone(&inner);

                move |handler| async move {
-                    while let Some(count) = future::poll_fn(|cx| {
-                        let count = inner.counter.swap(0, Ordering::Relaxed);
-
-                        if count > 0 {
-                            Poll::Ready(Some(count))
+                    while future::poll_fn(|cx| {
+                        if inner.awoken.swap(false, Ordering::Relaxed) {
+                            Poll::Ready(true)
                        } else {
                            inner.waker.register(cx.waker());

-                            let count = inner.counter.swap(0, Ordering::Relaxed);
-
-                            if count > 0 {
-                                Poll::Ready(Some(count))
+                            if inner.awoken.swap(false, Ordering::Relaxed) {
+                                Poll::Ready(true)
                            } else {
                                if inner.closed.load(Ordering::Relaxed) {
-                                    return Poll::Ready(None);
+                                    return Poll::Ready(false);
                                }

                                Poll::Pending
@@ -68,13 +64,13 @@ impl<T> WakerSpawner<T> {
                    {
                        let handler = handler.borrow();
                        let handler = handler.as_ref().unwrap();
-                        (handler.handler)(&handler.value, count);
+                        (handler.handler)(&handler.value, false);
                    }
                }
            },
            sender,
            |inner, _| {
-                inner.0.counter.fetch_add(1, Ordering::Relaxed);
+                inner.0.awoken.store(true, Ordering::Relaxed);
                inner.0.waker.wake();
            },
        )?;
@@ -86,13 +82,13 @@ impl<T> WakerSpawner<T> {
        Waker(self.0.clone())
    }

-    pub fn fetch(&self) -> usize {
+    pub fn take(&self) -> bool {
        debug_assert!(
            MainThreadMarker::new().is_some(),
            "this should only be called from the main thread"
        );

-        self.0.with_sender_data(|inner| inner.0.counter.swap(0, Ordering::Relaxed))
+        self.0.with_sender_data(|inner| inner.0.awoken.swap(false, Ordering::Relaxed))
    }
 }

@@ -107,7 +103,7 @@ impl<T> Drop for WakerSpawner<T> {

 impl<T> Waker<T> {
    pub fn wake(&self) {
-        self.0.send(1)
+        self.0.send(())
    }
 }

@@ -118,7 +114,7 @@ impl<T> Clone for Waker<T> {
 }

 struct Inner {
-    counter: AtomicUsize,
+    awoken: AtomicBool,
    waker: AtomicWaker,
    closed: AtomicBool,
 }
--- a/src/platform_impl/web/cursor.rs
+++ b/src/platform_impl/web/cursor.rs
@@ -324,7 +324,11 @@ impl Inner {
            match &self.cursor {
                SelectedCursor::Icon(icon)
                | SelectedCursor::Loading { previous: Previous::Icon(icon), .. } => {
-                    self.style.set("cursor", icon.name())
+                    if let CursorIcon::Default = icon {
+                        self.style.remove("cursor")
+                    } else {
+                        self.style.set("cursor", icon.name())
+                    }
                },
                SelectedCursor::Loading { previous: Previous::Image(cursor), .. }
                | SelectedCursor::Image(cursor) => {
--- a/src/platform_impl/web/event_loop/mod.rs
+++ b/src/platform_impl/web/event_loop/mod.rs
@@ -1,9 +1,10 @@
 use std::marker::PhantomData;
-use std::sync::mpsc::{self, Receiver, Sender};

+use crate::application::ApplicationHandler;
 use crate::error::EventLoopError;
 use crate::event::Event;
 use crate::event_loop::ActiveEventLoop as RootActiveEventLoop;
+use crate::platform::web::{ActiveEventLoopExtWebSys, PollStrategy, WaitUntilStrategy};

 use super::{backend, device, window};

@@ -15,45 +16,31 @@ mod window_target;
 pub(crate) use proxy::EventLoopProxy;
 pub(crate) use window_target::{ActiveEventLoop, OwnedDisplayHandle};

-pub struct EventLoop<T: 'static> {
+pub struct EventLoop {
    elw: RootActiveEventLoop,
-    user_event_sender: Sender<T>,
-    user_event_receiver: Receiver<T>,
 }

 #[derive(Default, Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub(crate) struct PlatformSpecificEventLoopAttributes {}

-impl<T> EventLoop<T> {
+impl EventLoop {
    pub(crate) fn new(_: &PlatformSpecificEventLoopAttributes) -> Result<Self, EventLoopError> {
-        let (user_event_sender, user_event_receiver) = mpsc::channel();
        let elw = RootActiveEventLoop { p: ActiveEventLoop::new(), _marker: PhantomData };
-        Ok(EventLoop { elw, user_event_sender, user_event_receiver })
+        Ok(EventLoop { elw })
    }

-    pub fn run<F>(self, mut event_handler: F) -> !
-    where
-        F: FnMut(Event<T>, &RootActiveEventLoop),
-    {
+    pub fn run_app<A: ApplicationHandler>(self, app: &mut A) -> ! {
        let target = RootActiveEventLoop { p: self.elw.p.clone(), _marker: PhantomData };

        // SAFETY: Don't use `move` to make sure we leak the `event_handler` and `target`.
-        let handler: Box<dyn FnMut(Event<()>)> = Box::new(|event| {
-            let event = match event.map_nonuser_event() {
-                Ok(event) => event,
-                Err(Event::UserEvent(())) => Event::UserEvent(
-                    self.user_event_receiver
-                        .try_recv()
-                        .expect("handler woken up without user event"),
-                ),
-                Err(_) => unreachable!(),
-            };
-            event_handler(event, &target)
-        });
+        let handler: Box<dyn FnMut(Event)> = Box::new(|event| handle_event(app, &target, event));
+
        // 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 handler = unsafe { std::mem::transmute(handler) };
+        let handler = unsafe {
+            std::mem::transmute::<Box<dyn FnMut(Event)>, Box<dyn FnMut(Event) + 'static>>(handler)
+        };
        self.elw.p.run(handler, false);

        // Throw an exception to break out of Rust execution and use unreachable to tell the
@@ -65,34 +52,47 @@ impl<T> EventLoop<T> {
        unreachable!();
    }

-    pub fn spawn<F>(self, mut event_handler: F)
-    where
-        F: 'static + FnMut(Event<T>, &RootActiveEventLoop),
-    {
+    pub fn spawn_app<A: ApplicationHandler + 'static>(self, mut app: A) {
        let target = RootActiveEventLoop { p: self.elw.p.clone(), _marker: PhantomData };

-        self.elw.p.run(
-            Box::new(move |event| {
-                let event = match event.map_nonuser_event() {
-                    Ok(event) => event,
-                    Err(Event::UserEvent(())) => Event::UserEvent(
-                        self.user_event_receiver
-                            .try_recv()
-                            .expect("handler woken up without user event"),
-                    ),
-                    Err(_) => unreachable!(),
-                };
-                event_handler(event, &target)
-            }),
-            true,
-        );
+        self.elw.p.run(Box::new(move |event| handle_event(&mut app, &target, event)), true);
    }

-    pub fn create_proxy(&self) -> EventLoopProxy<T> {
-        EventLoopProxy::new(self.elw.p.waker(), self.user_event_sender.clone())
+    pub fn create_proxy(&self) -> EventLoopProxy {
+        EventLoopProxy::new(self.elw.p.waker())
    }

    pub fn window_target(&self) -> &RootActiveEventLoop {
        &self.elw
    }
+
+    pub fn set_poll_strategy(&self, strategy: PollStrategy) {
+        self.elw.set_poll_strategy(strategy);
+    }
+
+    pub fn poll_strategy(&self) -> PollStrategy {
+        self.elw.poll_strategy()
+    }
+
+    pub fn set_wait_until_strategy(&self, strategy: WaitUntilStrategy) {
+        self.elw.set_wait_until_strategy(strategy);
+    }
+
+    pub fn wait_until_strategy(&self) -> WaitUntilStrategy {
+        self.elw.wait_until_strategy()
+    }
+}
+
+fn handle_event<A: ApplicationHandler>(app: &mut A, target: &RootActiveEventLoop, event: Event) {
+    match event {
+        Event::NewEvents(cause) => app.new_events(target, cause),
+        Event::WindowEvent { window_id, event } => app.window_event(target, window_id, event),
+        Event::DeviceEvent { device_id, event } => app.device_event(target, device_id, event),
+        Event::UserWakeUp => app.proxy_wake_up(target),
+        Event::Suspended => app.suspended(target),
+        Event::Resumed => app.resumed(target),
+        Event::AboutToWait => app.about_to_wait(target),
+        Event::LoopExiting => app.exiting(target),
+        Event::MemoryWarning => app.memory_warning(target),
+    }
 }
--- a/src/platform_impl/web/event_loop/proxy.rs
+++ b/src/platform_impl/web/event_loop/proxy.rs
@@ -1,29 +1,19 @@
 use std::rc::Weak;
-use std::sync::mpsc::{SendError, Sender};

 use super::runner::Execution;
-use crate::event_loop::EventLoopClosed;
 use crate::platform_impl::platform::r#async::Waker;

-pub struct EventLoopProxy<T: 'static> {
+#[derive(Clone)]
+pub struct EventLoopProxy {
    runner: Waker<Weak<Execution>>,
-    sender: Sender<T>,
 }

-impl<T: 'static> EventLoopProxy<T> {
-    pub fn new(runner: Waker<Weak<Execution>>, sender: Sender<T>) -> Self {
-        Self { runner, sender }
+impl EventLoopProxy {
+    pub fn new(runner: Waker<Weak<Execution>>) -> Self {
+        Self { runner }
    }

-    pub fn send_event(&self, event: T) -> Result<(), EventLoopClosed<T>> {
-        self.sender.send(event).map_err(|SendError(event)| EventLoopClosed(event))?;
+    pub fn wake_up(&self) {
        self.runner.wake();
-        Ok(())
-    }
-}
-
-impl<T: 'static> Clone for EventLoopProxy<T> {
-    fn clone(&self) -> Self {
-        Self { runner: self.runner.clone(), sender: self.sender.clone() }
    }
 }
--- a/src/platform_impl/web/event_loop/runner.rs
+++ b/src/platform_impl/web/event_loop/runner.rs
@@ -8,24 +8,26 @@ use crate::event::{
    WindowEvent,
 };
 use crate::event_loop::{ControlFlow, DeviceEvents};
-use crate::platform::web::PollStrategy;
+use crate::platform::web::{PollStrategy, WaitUntilStrategy};
 use crate::platform_impl::platform::backend::EventListenerHandle;
 use crate::platform_impl::platform::r#async::{DispatchRunner, Waker, WakerSpawner};
 use crate::platform_impl::platform::window::Inner;
 use crate::window::WindowId;

+use js_sys::Function;
 use std::cell::{Cell, RefCell};
 use std::collections::{HashSet, VecDeque};
 use std::iter;
 use std::ops::Deref;
 use std::rc::{Rc, Weak};
-use wasm_bindgen::prelude::Closure;
+use wasm_bindgen::prelude::{wasm_bindgen, Closure};
+use wasm_bindgen::JsCast;
 use web_sys::{Document, KeyboardEvent, PageTransitionEvent, PointerEvent, WheelEvent};
 use web_time::{Duration, Instant};

 pub struct Shared(Rc<Execution>);

-pub(super) type EventHandler = dyn FnMut(Event<()>);
+pub(super) type EventHandler = dyn FnMut(Event);

 impl Clone for Shared {
    fn clone(&self) -> Self {
@@ -40,6 +42,7 @@ pub struct Execution {
    proxy_spawner: WakerSpawner<Weak<Self>>,
    control_flow: Cell<ControlFlow>,
    poll_strategy: Cell<PollStrategy>,
+    wait_until_strategy: Cell<WaitUntilStrategy>,
    exit: Cell<bool>,
    runner: RefCell<RunnerEnum>,
    suspended: Cell<bool>,
@@ -133,9 +136,9 @@ impl Shared {
        let document = window.document().expect("Failed to obtain document");

        Shared(Rc::<Execution>::new_cyclic(|weak| {
-            let proxy_spawner = WakerSpawner::new(main_thread, weak.clone(), |runner, count| {
+            let proxy_spawner = WakerSpawner::new(main_thread, weak.clone(), |runner, local| {
                if let Some(runner) = runner.upgrade() {
-                    Shared(runner).send_events(iter::repeat(Event::UserEvent(())).take(count))
+                    Shared(runner).send_proxy_wake_up(local);
                }
            })
            .expect("`EventLoop` has to be created in the main thread");
@@ -145,6 +148,7 @@ impl Shared {
                proxy_spawner,
                control_flow: Cell::new(ControlFlow::default()),
                poll_strategy: Cell::new(PollStrategy::default()),
+                wait_until_strategy: Cell::new(WaitUntilStrategy::default()),
                exit: Cell::new(false),
                runner: RefCell::new(RunnerEnum::Pending),
                suspended: Cell::new(false),
@@ -197,7 +201,7 @@ impl Shared {
    // Set the event callback to use for the event loop runner
    // This the event callback is a fairly thin layer over the user-provided callback that closes
    // over a RootActiveEventLoop reference
-    pub fn set_listener(&self, event_handler: Box<EventHandler>) {
+    pub(crate) fn set_listener(&self, event_handler: Box<EventHandler>) {
        {
            let mut runner = self.0.runner.borrow_mut();
            assert!(matches!(*runner, RunnerEnum::Pending));
@@ -460,6 +464,46 @@ impl Shared {
        self.send_events(iter::once(event));
    }

+    // Add a user event to the event loop runner.
+    //
+    // This will schedule the event loop to wake up instead of waking it up immediately if its not
+    // running.
+    pub(crate) fn send_proxy_wake_up(&self, local: bool) {
+        // If the event loop is closed, it should discard any new events
+        if self.is_closed() {
+            return;
+        }
+
+        if local {
+            // If the loop is not running and triggered locally, queue on next microtick.
+            if let Ok(RunnerEnum::Running(_)) =
+                self.0.runner.try_borrow().as_ref().map(Deref::deref)
+            {
+                #[wasm_bindgen]
+                extern "C" {
+                    #[wasm_bindgen(js_name = queueMicrotask)]
+                    fn queue_microtask(task: Function);
+                }
+
+                queue_microtask(
+                    Closure::once_into_js({
+                        let this = Rc::downgrade(&self.0);
+                        move || {
+                            if let Some(shared) = this.upgrade() {
+                                Shared(shared).send_event(Event::UserWakeUp)
+                            }
+                        }
+                    })
+                    .unchecked_into(),
+                );
+
+                return;
+            }
+        }
+
+        self.send_event(Event::UserWakeUp);
+    }
+
    // Add a series of events to the event loop runner
    //
    // It will determine if the event should be immediately sent to the user or buffered for later
@@ -471,13 +515,8 @@ impl Shared {
        // If we can run the event processing right now, or need to queue this and wait for later
        let mut process_immediately = true;
        match self.0.runner.try_borrow().as_ref().map(Deref::deref) {
-            Ok(RunnerEnum::Running(ref runner)) => {
-                // If we're currently polling, queue this and wait for the poll() method to be
-                // called
-                if let State::Poll { .. } = runner.state {
-                    process_immediately = false;
-                }
-            },
+            // If the runner is attached but not running, we always wake it up.
+            Ok(RunnerEnum::Running(_)) => (),
            Ok(RunnerEnum::Pending) => {
                // The runner still hasn't been attached: queue this event and wait for it to be
                process_immediately = false;
@@ -605,8 +644,10 @@ impl Shared {

                // Pre-fetch `UserEvent`s to avoid having to wait until the next event loop cycle.
                events.extend(
-                    iter::repeat(Event::UserEvent(()))
-                        .take(self.0.proxy_spawner.fetch())
+                    self.0
+                        .proxy_spawner
+                        .take()
+                        .then_some(Event::UserWakeUp)
                        .map(EventWrapper::from),
                );

@@ -647,6 +688,7 @@ impl Shared {
                        start,
                        end,
                        _timeout: backend::Schedule::new_with_duration(
+                            self.wait_until_strategy(),
                            self.window(),
                            move || cloned.resume_time_reached(start, end),
                            delay,
@@ -693,7 +735,7 @@ impl Shared {
        //     * The `register_redraw_request` closure.
        //     * The `destroy_fn` closure.
        if self.0.event_loop_recreation.get() {
-            crate::event_loop::EventLoopBuilder::<()>::allow_event_loop_recreation();
+            crate::event_loop::EventLoopBuilder::allow_event_loop_recreation();
        }
    }

@@ -759,18 +801,26 @@ impl Shared {
        self.0.poll_strategy.get()
    }

+    pub(crate) fn set_wait_until_strategy(&self, strategy: WaitUntilStrategy) {
+        self.0.wait_until_strategy.set(strategy)
+    }
+
+    pub(crate) fn wait_until_strategy(&self) -> WaitUntilStrategy {
+        self.0.wait_until_strategy.get()
+    }
+
    pub(crate) fn waker(&self) -> Waker<Weak<Execution>> {
        self.0.proxy_spawner.waker()
    }
 }

 pub(crate) enum EventWrapper {
-    Event(Event<()>),
+    Event(Event),
    ScaleChange { canvas: Weak<RefCell<backend::Canvas>>, size: PhysicalSize<u32>, scale: f64 },
 }

-impl From<Event<()>> for EventWrapper {
-    fn from(value: Event<()>) -> Self {
+impl From<Event> for EventWrapper {
+    fn from(value: Event) -> Self {
        Self::Event(value)
    }
 }
--- a/src/platform_impl/web/event_loop/window_target.rs
+++ b/src/platform_impl/web/event_loop/window_target.rs
@@ -18,7 +18,7 @@ use crate::event::{
 };
 use crate::event_loop::{ControlFlow, DeviceEvents};
 use crate::keyboard::ModifiersState;
-use crate::platform::web::{CustomCursorFuture, PollStrategy};
+use crate::platform::web::{CustomCursorFuture, PollStrategy, WaitUntilStrategy};
 use crate::platform_impl::platform::cursor::CustomCursor;
 use crate::platform_impl::platform::r#async::Waker;
 use crate::window::{
@@ -55,7 +55,11 @@ impl ActiveEventLoop {
        Self { runner: runner::Shared::new(), modifiers: ModifiersShared::default() }
    }

-    pub fn run(&self, event_handler: Box<runner::EventHandler>, event_loop_recreation: bool) {
+    pub(crate) fn run(
+        &self,
+        event_handler: Box<runner::EventHandler>,
+        event_loop_recreation: bool,
+    ) {
        self.runner.event_loop_recreation(event_loop_recreation);
        self.runner.set_listener(event_handler);
    }
@@ -682,6 +686,14 @@ impl ActiveEventLoop {
        self.runner.poll_strategy()
    }

+    pub(crate) fn set_wait_until_strategy(&self, strategy: WaitUntilStrategy) {
+        self.runner.set_wait_until_strategy(strategy)
+    }
+
+    pub(crate) fn wait_until_strategy(&self) -> WaitUntilStrategy {
+        self.runner.wait_until_strategy()
+    }
+
    pub(crate) fn waker(&self) -> Waker<Weak<Execution>> {
        self.runner.waker()
    }
--- a/src/platform_impl/web/mod.rs
+++ b/src/platform_impl/web/mod.rs
@@ -17,8 +17,8 @@
 // incoming events (from the registered handlers) and ensuring they are passed to the user in a
 // compliant way.

-// TODO: FP, remove when <https://github.com/rust-lang/rust/issues/121621> is fixed.
-#![allow(unknown_lints, non_local_definitions)]
+// TODO: FP, remove when <https://github.com/rust-lang/rust-clippy/issues/12377> is fixed.
+#![allow(clippy::empty_docs)]

 mod r#async;
 mod cursor;
@@ -28,11 +28,9 @@ mod event_loop;
 mod keyboard;
 mod main_thread;
 mod monitor;
+mod web_sys;
 mod window;

-#[path = "web_sys/mod.rs"]
-mod backend;
-
 pub use self::device::DeviceId;
 pub use self::error::OsError;
 pub(crate) use self::event_loop::{
@@ -43,6 +41,7 @@ pub use self::monitor::{MonitorHandle, VideoModeHandle};
 pub use self::window::{PlatformSpecificWindowAttributes, Window, WindowId};

 pub(crate) use self::keyboard::KeyEventExtra;
+use self::web_sys as backend;
 pub(crate) use crate::icon::NoIcon as PlatformIcon;
 pub(crate) use crate::platform_impl::Fullscreen;
 pub(crate) use cursor::{
--- a/src/platform_impl/web/web_sys/canvas.rs
+++ b/src/platform_impl/web/web_sys/canvas.rs
@@ -427,8 +427,8 @@ impl Canvas {

    pub(crate) fn on_resize_scale<S, R>(&mut self, scale_handler: S, size_handler: R)
    where
-        S: 'static + FnMut(PhysicalSize<u32>, f64),
-        R: 'static + FnMut(PhysicalSize<u32>),
+        S: 'static + Fn(PhysicalSize<u32>, f64),
+        R: 'static + Fn(PhysicalSize<u32>),
    {
        self.on_resize_scale = Some(ResizeScaleHandle::new(
            self.window().clone(),
@@ -483,7 +483,7 @@ impl Canvas {
    pub(crate) fn handle_scale_change(
        &self,
        runner: &super::super::event_loop::runner::Shared,
-        event_handler: impl FnOnce(crate::event::Event<()>),
+        event_handler: impl FnOnce(crate::event::Event),
        current_size: PhysicalSize<u32>,
        scale: f64,
    ) {
--- a/src/platform_impl/web/web_sys/resize_scaling.rs
+++ b/src/platform_impl/web/web_sys/resize_scaling.rs
@@ -16,7 +16,7 @@ use super::media_query_handle::MediaQueryListHandle;
 use std::cell::{Cell, RefCell};
 use std::rc::Rc;

-pub struct ResizeScaleHandle(Rc<RefCell<ResizeScaleInternal>>);
+pub struct ResizeScaleHandle(Rc<ResizeScaleInternal>);

 impl ResizeScaleHandle {
    pub(crate) fn new<S, R>(
@@ -28,8 +28,8 @@ impl ResizeScaleHandle {
        resize_handler: R,
    ) -> Self
    where
-        S: 'static + FnMut(PhysicalSize<u32>, f64),
-        R: 'static + FnMut(PhysicalSize<u32>),
+        S: 'static + Fn(PhysicalSize<u32>, f64),
+        R: 'static + Fn(PhysicalSize<u32>),
    {
        Self(ResizeScaleInternal::new(
            window,
@@ -42,7 +42,7 @@ impl ResizeScaleHandle {
    }

    pub(crate) fn notify_resize(&self) {
-        self.0.borrow_mut().notify()
+        self.0.notify()
    }
 }

@@ -53,11 +53,11 @@ struct ResizeScaleInternal {
    document: Document,
    canvas: HtmlCanvasElement,
    style: Style,
-    mql: MediaQueryListHandle,
+    mql: RefCell<MediaQueryListHandle>,
    observer: ResizeObserver,
    _observer_closure: Closure<dyn FnMut(Array, ResizeObserver)>,
-    scale_handler: Box<dyn FnMut(PhysicalSize<u32>, f64)>,
-    resize_handler: Box<dyn FnMut(PhysicalSize<u32>)>,
+    scale_handler: Box<dyn Fn(PhysicalSize<u32>, f64)>,
+    resize_handler: Box<dyn Fn(PhysicalSize<u32>)>,
    notify_scale: Cell<bool>,
 }

@@ -69,12 +69,12 @@ impl ResizeScaleInternal {
        style: Style,
        scale_handler: S,
        resize_handler: R,
-    ) -> Rc<RefCell<Self>>
+    ) -> Rc<Self>
    where
-        S: 'static + FnMut(PhysicalSize<u32>, f64),
-        R: 'static + FnMut(PhysicalSize<u32>),
+        S: 'static + Fn(PhysicalSize<u32>, f64),
+        R: 'static + Fn(PhysicalSize<u32>),
    {
-        Rc::<RefCell<ResizeScaleInternal>>::new_cyclic(|weak_self| {
+        Rc::<ResizeScaleInternal>::new_cyclic(|weak_self| {
            let mql = Self::create_mql(&window, {
                let weak_self = weak_self.clone();
                move |mql| {
@@ -86,9 +86,7 @@ impl ResizeScaleInternal {

            let weak_self = weak_self.clone();
            let observer_closure = Closure::new(move |entries: Array, _| {
-                if let Some(rc_self) = weak_self.upgrade() {
-                    let mut this = rc_self.borrow_mut();
-
+                if let Some(this) = weak_self.upgrade() {
                    let size = this.process_entry(entries);

                    if this.notify_scale.replace(false) {
@@ -101,18 +99,18 @@ impl ResizeScaleInternal {
            });
            let observer = Self::create_observer(&canvas, observer_closure.as_ref());

-            RefCell::new(Self {
+            Self {
                window,
                document,
                canvas,
                style,
-                mql,
+                mql: RefCell::new(mql),
                observer,
                _observer_closure: observer_closure,
                scale_handler: Box::new(scale_handler),
                resize_handler: Box::new(resize_handler),
                notify_scale: Cell::new(false),
-            })
+            }
        })
    }

@@ -152,7 +150,7 @@ impl ResizeScaleInternal {
        observer
    }

-    fn notify(&mut self) {
+    fn notify(&self) {
        if !self.document.contains(Some(&self.canvas)) || self.style.get("display") == "none" {
            let size = PhysicalSize::new(0, 0);

@@ -200,10 +198,9 @@ impl ResizeScaleInternal {
        }
    }

-    fn handle_scale(this: Rc<RefCell<Self>>, mql: &MediaQueryList) {
-        let weak_self = Rc::downgrade(&this);
-        let mut this = this.borrow_mut();
-        let scale = super::scale_factor(&this.window);
+    fn handle_scale(self: Rc<Self>, mql: &MediaQueryList) {
+        let weak_self = Rc::downgrade(&self);
+        let scale = super::scale_factor(&self.window);

        // TODO: confirm/reproduce this problem, see:
        // <https://github.com/rust-windowing/winit/issues/2597>.
@@ -217,15 +214,15 @@ impl ResizeScaleInternal {
            return;
        }

-        let new_mql = Self::create_mql(&this.window, move |mql| {
+        let new_mql = Self::create_mql(&self.window, move |mql| {
            if let Some(rc_self) = weak_self.upgrade() {
                Self::handle_scale(rc_self, mql);
            }
        });
-        this.mql = new_mql;
+        self.mql.replace(new_mql);

-        this.notify_scale.set(true);
-        this.notify();
+        self.notify_scale.set(true);
+        self.notify();
    }

    fn process_entry(&self, entries: Array) -> PhysicalSize<u32> {
--- a/src/platform_impl/web/web_sys/schedule.rs
+++ b/src/platform_impl/web/web_sys/schedule.rs
@@ -1,12 +1,14 @@
-use js_sys::{Function, Object, Promise, Reflect};
+use js_sys::{Array, Function, Object, Promise, Reflect};
 use std::cell::OnceCell;
 use std::time::Duration;
 use wasm_bindgen::closure::Closure;
 use wasm_bindgen::prelude::wasm_bindgen;
 use wasm_bindgen::{JsCast, JsValue};
-use web_sys::{AbortController, AbortSignal, MessageChannel, MessagePort};
+use web_sys::{
+    AbortController, AbortSignal, Blob, BlobPropertyBag, MessageChannel, MessagePort, Url, Worker,
+};

-use crate::platform::web::PollStrategy;
+use crate::platform::web::{PollStrategy, WaitUntilStrategy};

 #[derive(Debug)]
 pub struct Schedule {
@@ -29,6 +31,7 @@ enum Inner {
        port: MessagePort,
        _timeout_closure: Closure<dyn FnMut()>,
    },
+    Worker(MessagePort),
 }

 impl Schedule {
@@ -45,14 +48,24 @@ impl Schedule {
        }
    }

-    pub fn new_with_duration<F>(window: &web_sys::Window, f: F, duration: Duration) -> Schedule
+    pub fn new_with_duration<F>(
+        strategy: WaitUntilStrategy,
+        window: &web_sys::Window,
+        f: F,
+        duration: Duration,
+    ) -> Schedule
    where
        F: 'static + FnMut(),
    {
-        if has_scheduler_support(window) {
-            Self::new_scheduler(window, f, Some(duration))
-        } else {
-            Self::new_timeout(window.clone(), f, Some(duration))
+        match strategy {
+            WaitUntilStrategy::Scheduler => {
+                if has_scheduler_support(window) {
+                    Self::new_scheduler(window, f, Some(duration))
+                } else {
+                    Self::new_timeout(window.clone(), f, Some(duration))
+                }
+            },
+            WaitUntilStrategy::Worker => Self::new_worker(f, duration),
        }
    }

@@ -74,7 +87,7 @@ impl Schedule {
            let duration = duration
                .as_secs()
                .checked_mul(1000)
-                .and_then(|secs| secs.checked_add(duration_millis_ceil(duration).into()))
+                .and_then(|secs| secs.checked_add(duration.subsec_micros().div_ceil(1000).into()))
                .unwrap_or(u64::MAX);

            options.delay(duration as f64);
@@ -127,7 +140,9 @@ impl Schedule {
                .ok()
                .and_then(|secs: i32| secs.checked_mul(1000))
                .and_then(|secs: i32| {
-                    let millis: i32 = duration_millis_ceil(duration)
+                    let millis: i32 = duration
+                        .subsec_micros()
+                        .div_ceil(1000)
                        .try_into()
                        .expect("millis are somehow bigger then 1K");
                    secs.checked_add(millis)
@@ -153,6 +168,44 @@ impl Schedule {
            },
        }
    }
+
+    fn new_worker<F>(f: F, duration: Duration) -> Schedule
+    where
+        F: 'static + FnMut(),
+    {
+        thread_local! {
+            static URL: ScriptUrl = ScriptUrl::new(include_str!("worker.min.js"));
+            static WORKER: Worker = URL.with(|url| Worker::new(&url.0)).expect("`new Worker()` is not expected to fail with a local script");
+        }
+
+        let channel = MessageChannel::new().unwrap();
+        let closure = Closure::new(f);
+        let port_1 = channel.port1();
+        port_1.set_onmessage(Some(closure.as_ref().unchecked_ref()));
+        port_1.start();
+
+        // `Duration::as_millis()` always rounds down (because of truncation), we want to round
+        // up instead. This makes sure that the we never wake up **before** the given time.
+        let duration = duration
+            .as_secs()
+            .try_into()
+            .ok()
+            .and_then(|secs: u32| secs.checked_mul(1000))
+            .and_then(|secs| secs.checked_add(duration.subsec_micros().div_ceil(1000)))
+            .unwrap_or(u32::MAX);
+
+        WORKER
+            .with(|worker| {
+                let port_2 = channel.port2();
+                worker.post_message_with_transfer(
+                    &Array::of2(&port_2, &duration.into()),
+                    &Array::of1(&port_2).into(),
+                )
+            })
+            .expect("`Worker.postMessage()` is not expected to fail");
+
+        Schedule { _closure: closure, inner: Inner::Worker(port_1) }
+    }
 }

 impl Drop for Schedule {
@@ -165,24 +218,14 @@ impl Drop for Schedule {
                port.close();
                port.set_onmessage(None);
            },
+            Inner::Worker(port) => {
+                port.close();
+                port.set_onmessage(None);
+            },
        }
    }
 }

-// TODO: Replace with `u32::div_ceil()` when we hit Rust v1.73.
-fn duration_millis_ceil(duration: Duration) -> u32 {
-    let micros = duration.subsec_micros();
-
-    // From <https://doc.rust-lang.org/1.73.0/src/core/num/uint_macros.rs.html#2086-2094>.
-    let d = micros / 1000;
-    let r = micros % 1000;
-    if r > 0 && 1000 > 0 {
-        d + 1
-    } else {
-        d
-    }
-}
-
 fn has_scheduler_support(window: &web_sys::Window) -> bool {
    thread_local! {
        static SCHEDULER_SUPPORT: OnceCell<bool> = const { OnceCell::new() };
@@ -226,6 +269,29 @@ fn has_idle_callback_support(window: &web_sys::Window) -> bool {
    })
 }

+struct ScriptUrl(String);
+
+impl ScriptUrl {
+    fn new(script: &str) -> Self {
+        let sequence = Array::of1(&script.into());
+        let mut property = BlobPropertyBag::new();
+        property.type_("text/javascript");
+        let blob = Blob::new_with_str_sequence_and_options(&sequence, &property)
+            .expect("`new Blob()` should never throw");
+
+        let url = Url::create_object_url_with_blob(&blob)
+            .expect("`URL.createObjectURL()` should never throw");
+
+        Self(url)
+    }
+}
+
+impl Drop for ScriptUrl {
+    fn drop(&mut self) {
+        Url::revoke_object_url(&self.0).expect("`URL.revokeObjectURL()` should never throw");
+    }
+}
+
 #[wasm_bindgen]
 extern "C" {
    type WindowSupportExt;
--- a/src/platform_impl/web/web_sys/worker.js
+++ b/src/platform_impl/web/web_sys/worker.js
@@ -0,0 +1,10 @@
+onmessage = event => {
+    const [port, timeout] = event.data
+    const f = () => port.postMessage(undefined)
+
+    if ('scheduler' in this) {
+        scheduler.postTask(f, { delay: timeout })
+    } else {
+        setTimeout(f, timeout)
+    }
+}
--- a/src/platform_impl/web/web_sys/worker.min.js
+++ b/src/platform_impl/web/web_sys/worker.min.js
@@ -0,0 +1 @@
+onmessage=e=>{let[s,t]=e.data,a=()=>s.postMessage(void 0);"scheduler"in this?scheduler.postTask(a,{delay:t}):setTimeout(a,t)};
--- a/src/platform_impl/windows/drop_handler.rs
+++ b/src/platform_impl/windows/drop_handler.rs
@@ -25,7 +25,7 @@ pub struct FileDropHandlerData {
    pub interface: IDropTarget,
    refcount: AtomicUsize,
    window: HWND,
-    send_event: Box<dyn Fn(Event<()>)>,
+    send_event: Box<dyn Fn(Event)>,
    cursor_effect: u32,
    hovered_is_valid: bool, /* If the currently hovered item is not valid there must not be any
                             * `HoveredFileCancelled` emitted */
@@ -37,7 +37,7 @@ pub struct FileDropHandler {

 #[allow(non_snake_case)]
 impl FileDropHandler {
-    pub fn new(window: HWND, send_event: Box<dyn Fn(Event<()>)>) -> FileDropHandler {
+    pub(crate) fn new(window: HWND, send_event: Box<dyn Fn(Event)>) -> FileDropHandler {
        let data = Box::new(FileDropHandlerData {
            interface: IDropTarget { lpVtbl: &DROP_TARGET_VTBL as *const IDropTargetVtbl },
            refcount: AtomicUsize::new(1),
@@ -211,7 +211,7 @@ impl FileDropHandler {
 }

 impl FileDropHandlerData {
-    fn send_event(&self, event: Event<()>) {
+    fn send_event(&self, event: Event) {
        (self.send_event)(event);
    }
 }
--- a/src/platform_impl/windows/event_loop.rs
+++ b/src/platform_impl/windows/event_loop.rs
@@ -8,7 +8,6 @@ use std::ffi::c_void;
 use std::marker::PhantomData;
 use std::rc::Rc;
 use std::sync::atomic::{AtomicU32, Ordering};
-use std::sync::mpsc::{self, Receiver, Sender};
 use std::sync::{Arc, Mutex, MutexGuard};
 use std::time::{Duration, Instant};
 use std::{mem, panic, ptr};
@@ -57,12 +56,13 @@ use windows_sys::Win32::UI::WindowsAndMessaging::{
    WS_EX_NOACTIVATE, WS_EX_TOOLWINDOW, WS_EX_TRANSPARENT, WS_OVERLAPPED, WS_POPUP, WS_VISIBLE,
 };

+use crate::application::ApplicationHandler;
 use crate::dpi::{PhysicalPosition, PhysicalSize};
 use crate::error::EventLoopError;
 use crate::event::{
    DeviceEvent, Event, Force, Ime, InnerSizeWriter, RawKeyEvent, Touch, TouchPhase, WindowEvent,
 };
-use crate::event_loop::{ActiveEventLoop as RootAEL, ControlFlow, DeviceEvents, EventLoopClosed};
+use crate::event_loop::{ActiveEventLoop as RootAEL, ControlFlow, DeviceEvents};
 use crate::keyboard::ModifiersState;
 use crate::platform::pump_events::PumpStatus;
 use crate::platform_impl::platform::dark_mode::try_theme;
@@ -83,35 +83,14 @@ use crate::platform_impl::platform::{
 use crate::window::{
    CustomCursor as RootCustomCursor, CustomCursorSource, WindowId as RootWindowId,
 };
-use runner::{EventLoopRunner, EventLoopRunnerShared};
+use runner::EventLoopRunner;

 use super::window::set_skip_taskbar;
 use super::SelectedCursor;

-/// some backends like macos uses an uninhabited `Never` type,
-/// on windows, `UserEvent`s are also dispatched through the
-/// WNDPROC callback, and due to the re-entrant nature of the
-/// callback, recursively delivered events must be queued in a
-/// buffer, the current implementation put this queue in
-/// `EventLoopRunner`, which is shared between the event pumping
-/// loop and the callback. because it's hard to decide from the
-/// outside whether a event needs to be buffered, I decided not
-/// use `Event<Never>` for the shared runner state, but use unit
-/// as a placeholder so user events can be buffered as usual,
-/// the real `UserEvent` is pulled from the mpsc channel directly
-/// when the placeholder event is delivered to the event handler
-pub(crate) struct UserEventPlaceholder;
-
-// here below, the generic `EventLoopRunnerShared<T>` is replaced with
-// `EventLoopRunnerShared<UserEventPlaceholder>` so we can get rid
-// of the generic parameter T in types which don't depend on T.
-// this is the approach which requires minimum changes to current
-// backend implementation. it should be considered transitional
-// and should be refactored and cleaned up eventually, I hope.
-
 pub(crate) struct WindowData {
    pub window_state: Arc<Mutex<WindowState>>,
-    pub event_loop_runner: EventLoopRunnerShared<UserEventPlaceholder>,
+    pub event_loop_runner: Rc<EventLoopRunner>,
    pub key_event_builder: KeyEventBuilder,
    pub _file_drop_handler: Option<FileDropHandler>,
    pub userdata_removed: Cell<bool>,
@@ -119,7 +98,7 @@ pub(crate) struct WindowData {
 }

 impl WindowData {
-    fn send_event(&self, event: Event<UserEventPlaceholder>) {
+    fn send_event(&self, event: Event) {
        self.event_loop_runner.send_event(event);
    }

@@ -129,11 +108,11 @@ impl WindowData {
 }

 struct ThreadMsgTargetData {
-    event_loop_runner: EventLoopRunnerShared<UserEventPlaceholder>,
+    event_loop_runner: Rc<EventLoopRunner>,
 }

 impl ThreadMsgTargetData {
-    fn send_event(&self, event: Event<UserEventPlaceholder>) {
+    fn send_event(&self, event: Event) {
        self.event_loop_runner.send_event(event);
    }
 }
@@ -145,9 +124,7 @@ pub(crate) enum ProcResult {
    Value(isize),
 }

-pub struct EventLoop<T: 'static> {
-    user_event_sender: Sender<T>,
-    user_event_receiver: Receiver<T>,
+pub struct EventLoop {
    window_target: RootAEL,
    msg_hook: Option<Box<dyn FnMut(*const c_void) -> bool + 'static>>,
 }
@@ -167,10 +144,10 @@ impl Default for PlatformSpecificEventLoopAttributes {
 pub struct ActiveEventLoop {
    thread_id: u32,
    thread_msg_target: HWND,
-    pub(crate) runner_shared: EventLoopRunnerShared<UserEventPlaceholder>,
+    pub(crate) runner_shared: Rc<EventLoopRunner>,
 }

-impl<T: 'static> EventLoop<T> {
+impl EventLoop {
    pub(crate) fn new(
        attributes: &mut PlatformSpecificEventLoopAttributes,
    ) -> Result<Self, EventLoopError> {
@@ -193,7 +170,6 @@ impl<T: 'static> EventLoop<T> {

        let runner_shared = Rc::new(EventLoopRunner::new(thread_msg_target));

-        let (user_event_sender, user_event_receiver) = mpsc::channel();
        insert_event_target_window_data(thread_msg_target, runner_shared.clone());
        raw_input::register_all_mice_and_keyboards_for_raw_input(
            thread_msg_target,
@@ -201,8 +177,6 @@ impl<T: 'static> EventLoop<T> {
        );

        Ok(EventLoop {
-            user_event_sender,
-            user_event_receiver,
            window_target: RootAEL {
                p: ActiveEventLoop { thread_id, thread_msg_target, runner_shared },
                _marker: PhantomData,
@@ -215,42 +189,36 @@ impl<T: 'static> EventLoop<T> {
        &self.window_target
    }

-    pub fn run<F>(mut self, event_handler: F) -> Result<(), EventLoopError>
-    where
-        F: FnMut(Event<T>, &RootAEL),
-    {
-        self.run_on_demand(event_handler)
+    pub fn run_app<A: ApplicationHandler>(mut self, app: &mut A) -> Result<(), EventLoopError> {
+        self.run_app_on_demand(app)
    }

-    pub fn run_on_demand<F>(&mut self, mut event_handler: F) -> Result<(), EventLoopError>
-    where
-        F: FnMut(Event<T>, &RootAEL),
-    {
+    pub fn run_app_on_demand<A: ApplicationHandler>(
+        &mut self,
+        app: &mut A,
+    ) -> Result<(), EventLoopError> {
        {
            let runner = &self.window_target.p.runner_shared;

            let event_loop_windows_ref = &self.window_target;
-            let user_event_receiver = &self.user_event_receiver;
            // # Safety
            // We make sure to call runner.clear_event_handler() before
            // returning
            unsafe {
-                runner.set_event_handler(move |event| {
-                    // the shared `EventLoopRunner` is not parameterized
-                    // `EventLoopProxy::send_event()` calls `PostMessage`
-                    // to wakeup and dispatch a placeholder `UserEvent`,
-                    // when we received the placeholder event here, the
-                    // real UserEvent(T) should already be put in the
-                    // mpsc channel and ready to be pulled
-                    let event = match event.map_nonuser_event() {
-                        Ok(non_user_event) => non_user_event,
-                        Err(_user_event_placeholder) => Event::UserEvent(
-                            user_event_receiver
-                                .try_recv()
-                                .expect("user event signaled but not received"),
-                        ),
-                    };
-                    event_handler(event, event_loop_windows_ref)
+                runner.set_event_handler(move |event| match event {
+                    Event::NewEvents(cause) => app.new_events(event_loop_windows_ref, cause),
+                    Event::WindowEvent { window_id, event } => {
+                        app.window_event(event_loop_windows_ref, window_id, event)
+                    },
+                    Event::DeviceEvent { device_id, event } => {
+                        app.device_event(event_loop_windows_ref, device_id, event)
+                    },
+                    Event::UserWakeUp => app.proxy_wake_up(event_loop_windows_ref),
+                    Event::Suspended => app.suspended(event_loop_windows_ref),
+                    Event::Resumed => app.resumed(event_loop_windows_ref),
+                    Event::AboutToWait => app.about_to_wait(event_loop_windows_ref),
+                    Event::LoopExiting => app.exiting(event_loop_windows_ref),
+                    Event::MemoryWarning => app.memory_warning(event_loop_windows_ref),
                });
            }
        }
@@ -284,14 +252,15 @@ impl<T: 'static> EventLoop<T> {
        }
    }

-    pub fn pump_events<F>(&mut self, timeout: Option<Duration>, mut event_handler: F) -> PumpStatus
-    where
-        F: FnMut(Event<T>, &RootAEL),
-    {
+    pub fn pump_app_events<A: ApplicationHandler>(
+        &mut self,
+        timeout: Option<Duration>,
+        app: &mut A,
+    ) -> PumpStatus {
        {
            let runner = &self.window_target.p.runner_shared;
            let event_loop_windows_ref = &self.window_target;
-            let user_event_receiver = &self.user_event_receiver;
+            // let user_event_receiver = &self.user_event_receiver;

            // # Safety
            // We make sure to call runner.clear_event_handler() before
@@ -301,17 +270,22 @@ impl<T: 'static> EventLoop<T> {
            // to leave the runner in an unsound state with an associated
            // event handler.
            unsafe {
-                runner.set_event_handler(move |event| {
-                    let event = match event.map_nonuser_event() {
-                        Ok(non_user_event) => non_user_event,
-                        Err(_user_event_placeholder) => Event::UserEvent(
-                            user_event_receiver
-                                .recv()
-                                .expect("user event signaled but not received"),
-                        ),
-                    };
-                    event_handler(event, event_loop_windows_ref)
+                runner.set_event_handler(move |event| match event {
+                    Event::NewEvents(cause) => app.new_events(event_loop_windows_ref, cause),
+                    Event::WindowEvent { window_id, event } => {
+                        app.window_event(event_loop_windows_ref, window_id, event)
+                    },
+                    Event::DeviceEvent { device_id, event } => {
+                        app.device_event(event_loop_windows_ref, device_id, event)
+                    },
+                    Event::UserWakeUp => app.proxy_wake_up(event_loop_windows_ref),
+                    Event::Suspended => app.suspended(event_loop_windows_ref),
+                    Event::Resumed => app.resumed(event_loop_windows_ref),
+                    Event::AboutToWait => app.about_to_wait(event_loop_windows_ref),
+                    Event::LoopExiting => app.exiting(event_loop_windows_ref),
+                    Event::MemoryWarning => app.memory_warning(event_loop_windows_ref),
                });
+
                runner.wakeup();
            }
        }
@@ -494,11 +468,8 @@ impl<T: 'static> EventLoop<T> {
        }
    }

-    pub fn create_proxy(&self) -> EventLoopProxy<T> {
-        EventLoopProxy {
-            target_window: self.window_target.p.thread_msg_target,
-            event_send: self.user_event_sender.clone(),
-        }
+    pub fn create_proxy(&self) -> EventLoopProxy {
+        EventLoopProxy { target_window: self.window_target.p.thread_msg_target }
    }

    fn exit_code(&self) -> Option<i32> {
@@ -670,7 +641,7 @@ fn dur2timeout(dur: Duration) -> u32 {
        .unwrap_or(INFINITE)
 }

-impl<T> Drop for EventLoop<T> {
+impl Drop for EventLoop {
    fn drop(&mut self) {
        unsafe {
            DestroyWindow(self.window_target.p.thread_msg_target);
@@ -728,27 +699,16 @@ impl EventLoopThreadExecutor {

 type ThreadExecFn = Box<Box<dyn FnMut()>>;

-pub struct EventLoopProxy<T: 'static> {
+#[derive(Clone)]
+pub struct EventLoopProxy {
    target_window: HWND,
-    event_send: Sender<T>,
-}
-unsafe impl<T: Send + 'static> Send for EventLoopProxy<T> {}
-
-impl<T: 'static> Clone for EventLoopProxy<T> {
-    fn clone(&self) -> Self {
-        Self { target_window: self.target_window, event_send: self.event_send.clone() }
-    }
 }

-impl<T: 'static> EventLoopProxy<T> {
-    pub fn send_event(&self, event: T) -> Result<(), EventLoopClosed<T>> {
-        self.event_send
-            .send(event)
-            .map(|result| {
-                unsafe { PostMessageW(self.target_window, USER_EVENT_MSG_ID.get(), 0, 0) };
-                result
-            })
-            .map_err(|e| EventLoopClosed(e.0))
+unsafe impl Send for EventLoopProxy {}
+
+impl EventLoopProxy {
+    pub fn wake_up(&self) {
+        unsafe { PostMessageW(self.target_window, USER_EVENT_MSG_ID.get(), 0, 0) };
    }
 }

@@ -880,7 +840,7 @@ fn create_event_target_window() -> HWND {

 fn insert_event_target_window_data(
    thread_msg_target: HWND,
-    event_loop_runner: EventLoopRunnerShared<UserEventPlaceholder>,
+    event_loop_runner: Rc<EventLoopRunner>,
 ) {
    let userdata = ThreadMsgTargetData { event_loop_runner };
    let input_ptr = Box::into_raw(Box::new(userdata));
@@ -2426,7 +2386,7 @@ unsafe extern "system" fn thread_event_target_callback(
            // user event is still in the mpsc channel and will be pulled
            // once the placeholder event is delivered to the wrapper
            // `event_handler`
-            userdata.send_event(Event::UserEvent(UserEventPlaceholder));
+            userdata.send_event(Event::UserWakeUp);
            0
        },
        _ if msg == EXEC_MSG_ID.get() => {
--- a/src/platform_impl/windows/event_loop/runner.rs
+++ b/src/platform_impl/windows/event_loop/runner.rs
@@ -1,7 +1,6 @@
 use std::any::Any;
 use std::cell::{Cell, RefCell};
 use std::collections::VecDeque;
-use std::rc::Rc;
 use std::sync::{Arc, Mutex};
 use std::time::Instant;
 use std::{mem, panic};
@@ -16,11 +15,9 @@ use crate::window::WindowId;

 use super::ControlFlow;

-pub(crate) type EventLoopRunnerShared<T> = Rc<EventLoopRunner<T>>;
+type EventHandler = Cell<Option<Box<dyn FnMut(Event)>>>;

-type EventHandler<T> = Cell<Option<Box<dyn FnMut(Event<T>)>>>;
-
-pub(crate) struct EventLoopRunner<T: 'static> {
+pub(crate) struct EventLoopRunner {
    // The event loop's win32 handles
    pub(super) thread_msg_target: HWND,

@@ -33,8 +30,8 @@ pub(crate) struct EventLoopRunner<T: 'static> {
    exit: Cell<Option<i32>>,
    runner_state: Cell<RunnerState>,
    last_events_cleared: Cell<Instant>,
-    event_handler: EventHandler<T>,
-    event_buffer: RefCell<VecDeque<BufferedEvent<T>>>,
+    event_handler: EventHandler,
+    event_buffer: RefCell<VecDeque<BufferedEvent>>,

    panic_error: Cell<Option<PanicError>>,
 }
@@ -55,13 +52,13 @@ pub(crate) enum RunnerState {
    Destroyed,
 }

-enum BufferedEvent<T: 'static> {
-    Event(Event<T>),
+enum BufferedEvent {
+    Event(Event),
    ScaleFactorChanged(WindowId, f64, PhysicalSize<u32>),
 }

-impl<T> EventLoopRunner<T> {
-    pub(crate) fn new(thread_msg_target: HWND) -> EventLoopRunner<T> {
+impl EventLoopRunner {
+    pub(crate) fn new(thread_msg_target: HWND) -> EventLoopRunner {
        EventLoopRunner {
            thread_msg_target,
            interrupt_msg_dispatch: Cell::new(false),
@@ -88,13 +85,12 @@ impl<T> EventLoopRunner<T> {
    /// undefined behaviour.
    pub(crate) unsafe fn set_event_handler<F>(&self, f: F)
    where
-        F: FnMut(Event<T>),
+        F: FnMut(Event),
    {
        // Erase closure lifetime.
        // SAFETY: Caller upholds that the lifetime of the closure is upheld.
-        let f = unsafe {
-            mem::transmute::<Box<dyn FnMut(Event<T>)>, Box<dyn FnMut(Event<T>)>>(Box::new(f))
-        };
+        let f =
+            unsafe { mem::transmute::<Box<dyn FnMut(Event)>, Box<dyn FnMut(Event)>>(Box::new(f)) };
        let old_event_handler = self.event_handler.replace(Some(f));
        assert!(old_event_handler.is_none());
    }
@@ -124,7 +120,7 @@ impl<T> EventLoopRunner<T> {
 }

 /// State retrieval functions.
-impl<T> EventLoopRunner<T> {
+impl EventLoopRunner {
    #[allow(unused)]
    pub fn thread_msg_target(&self) -> HWND {
        self.thread_msg_target
@@ -166,7 +162,7 @@ impl<T> EventLoopRunner<T> {
 }

 /// Misc. functions
-impl<T> EventLoopRunner<T> {
+impl EventLoopRunner {
    pub fn catch_unwind<R>(&self, f: impl FnOnce() -> R) -> Option<R> {
        let panic_error = self.panic_error.take();
        if panic_error.is_none() {
@@ -196,7 +192,7 @@ impl<T> EventLoopRunner<T> {
 }

 /// Event dispatch functions.
-impl<T> EventLoopRunner<T> {
+impl EventLoopRunner {
    pub(crate) fn prepare_wait(&self) {
        self.move_state_to(RunnerState::Idle);
    }
@@ -205,7 +201,7 @@ impl<T> EventLoopRunner<T> {
        self.move_state_to(RunnerState::HandlingMainEvents);
    }

-    pub(crate) fn send_event(&self, event: Event<T>) {
+    pub(crate) fn send_event(&self, event: Event) {
        if let Event::WindowEvent { event: WindowEvent::RedrawRequested, .. } = event {
            self.call_event_handler(event);
            // As a rule, to ensure that `pump_events` can't block an external event loop
@@ -226,7 +222,7 @@ impl<T> EventLoopRunner<T> {
        self.move_state_to(RunnerState::Destroyed);
    }

-    fn call_event_handler(&self, event: Event<T>) {
+    fn call_event_handler(&self, event: Event) {
        self.catch_unwind(|| {
            let mut event_handler = self.event_handler.take().expect(
                "either event handler is re-entrant (likely), or no event handler is registered \
@@ -358,8 +354,8 @@ impl<T> EventLoopRunner<T> {
    }
 }

-impl<T> BufferedEvent<T> {
-    pub fn from_event(event: Event<T>) -> BufferedEvent<T> {
+impl BufferedEvent {
+    pub fn from_event(event: Event) -> BufferedEvent {
        match event {
            Event::WindowEvent {
                event: WindowEvent::ScaleFactorChanged { scale_factor, inner_size_writer },
@@ -373,7 +369,7 @@ impl<T> BufferedEvent<T> {
        }
    }

-    pub fn dispatch_event(self, dispatch: impl FnOnce(Event<T>)) {
+    pub fn dispatch_event(self, dispatch: impl FnOnce(Event)) {
        match self {
            Self::Event(event) => dispatch(event),
            Self::ScaleFactorChanged(window_id, scale_factor, new_inner_size) => {
--- a/src/platform_impl/windows/mod.rs
+++ b/src/platform_impl/windows/mod.rs
@@ -1,5 +1,3 @@
-#![cfg(windows_platform)]
-
 use smol_str::SmolStr;
 use windows_sys::Win32::Foundation::{HANDLE, HWND};
 use windows_sys::Win32::UI::WindowsAndMessaging::{HMENU, WINDOW_LONG_PTR_INDEX};
--- a/src/platform_impl/windows/window.rs
+++ b/src/platform_impl/windows/window.rs
@@ -1186,11 +1186,7 @@ impl<'a> InitData<'a> {
            let file_drop_runner = self.event_loop.runner_shared.clone();
            let file_drop_handler = FileDropHandler::new(
                win.window,
-                Box::new(move |event| {
-                    if let Ok(e) = event.map_nonuser_event() {
-                        file_drop_runner.send_event(e)
-                    }
-                }),
+                Box::new(move |event| file_drop_runner.send_event(event)),
            );

            let handler_interface_ptr =
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Mads Marquart	bf73a978df	Only run observers in the default run loop mode	2024-06-29 00:27:31 +02:00
Mads Marquart	82d9bbe559	Remove EventLoopExtIOS::idiom and ios::Idiom (#2924 ) Introduced in `3a7350c` with unclear motivation. Nowadays, this feature is incomplete and unsound, and the equivalent functionality can be trivially achieved outside of `winit` using `objc2-ui-kit`.	2024-06-24 22:56:20 +02:00
Mads Marquart	8bdd4d620e	Use `self::` when re-importing local module (#3757 ) Follow-up to https://github.com/rust-windowing/winit/pull/3755.	2024-06-24 22:40:49 +02:00
Mads Marquart	9d5412ffe1	Move iOS and macOS implementations into new `apple` module (#3756 ) Move iOS and macOS implementations to a shared folder called `apple`, to allow us to reduce the code-duplication between these platforms in the future. The folder structure is now: - `src/platform_impl/apple/` - `appkit/` - `uikit/` - `example_shared_file.rs` - `mod.rs` * Add preliminary support for tvOS, watchOS and visionOS * Reduce duplication in Cargo.toml when specifying dependencies	2024-06-24 13:26:49 +02:00
Kirill Chibisov	ecb887e5c3	event_loop: remove generic user event Let the users wake up the event loop and then they could poll their user sources. Co-authored-by: Mads Marquart <mads@marquart.dk> Co-authored-by: daxpedda <daxpedda@gmail.com>	2024-06-24 13:04:55 +03:00
Mads Marquart	7d1287958f	Avoid `path` when importing modules (#3755 ) Rust tooling generally works better this way. This includes rust-analyzer, but more noticeably the output from `tracing` typically prints the module path, which did not correspond to the actual file system before. Concretely, tracing output from the macOS backend changes from printing: `winit::platform_impl::platform::util` To printing: `winit::platform_impl::macos::util`	2024-06-24 03:57:48 +02:00
Mads Marquart	c0c14aaf00	macOS: Call `ApplicationHandler` directly instead of using `Event` (#3753 ) Additionally, always queue events in `handle_scale_factor_changed`. These events were intentionally not queued before, since they are executed inside `handle_scale_factor_changed`, which is itself queued. Though that's a bit too subtle, so let's just take the minuscule perf hit of redundantly checking whether we need to queue again. Co-authored-by: Kirill Chibisov <contact@kchibisov.com>	2024-06-23 23:14:22 +02:00
John Nunley	10dc0674bb	ci: Use taiki-e/checkout-action taiki-e/checkout-action has a few advantages over actions/checkout, such as: - It is written in Bash rather than Node.js - It does not have frequent breaking changes, reducing churn Signed-off-by: John Nunley <dev@notgull.net>	2024-06-23 12:28:58 -07:00
msiglreith	4f59796e8a	Add notgull as Windows maintainer	2024-06-22 08:41:37 -07:00
msiglreith	32097d75c7	Update codeowner list	2024-06-22 08:41:37 -07:00
Bruce Mitchener	c6c4395c3b	Use `default-features`, not `default_features` (#3746 ) The latter syntax is deprecated and will be removed in Rust 2024 edition. This also generates a warning with current versions of Rust.	2024-06-22 11:38:42 +02:00
Kirill Chibisov	38e6f9ad84	Bump version on master This commit does not represent a release and only synchronizes CHANGELOG from the latest release.	2024-06-21 21:40:16 +03:00
daxpedda	3e6092b8ed	Web: implement `WaitUntilStrategy` (#3739 )	2024-06-20 23:07:42 +02:00
daxpedda	b4e83a5966	Web: set control flow strategies on `EventLoop` (#3740 )	2024-06-20 22:56:08 +02:00
Mads Marquart	db2c97a995	macOS: set the theme on the NSWindow, instead of application-wide This new implementation uses: - The NSAppearanceCustomization protocol for retrieving the appearance of the window, instead of using the application-wide `-[NSApplication effectiveAppearance]`. - Key-Value observing for observing the `effectiveAppearance` to compute the `ThemeChanged` event, instead of using the undocumented `AppleInterfaceThemeChangedNotification` notification. This also fixes `WindowBuilder::with_theme` not having any effect, and the conversion between `Theme` and `NSAppearance` is made a bit more robust.	2024-06-20 17:05:34 +03:00
daxpedda	1552eb21f7	Bump MSRV to v1.73 (#3743 )	2024-06-20 11:09:15 +02:00
Kirill Chibisov	d8ffd4bb26	x11: fix build on arm The c_char type, which was used under the hood is different depending on arch, thus use it directly instead of i8. Fixes #3735.	2024-06-17 13:51:08 +03:00
Kirill Chibisov	34c15608e0	Bump version on master This commit does not represent a release and only synchronizes CHANGELOG from the latest release.	2024-06-15 23:50:40 +03:00
Kirill Chibisov	eef6977f45	macOS: fix opacity handling Not using `NSColor::clearColor()` results in Quartz thinking that the window is not transparent at all, which results in artifacts. However, not setting the `windowBackgroundColor` in `Window::set_transparent` results in border not properly rendered. Fixes: `94664ff687` (Don't set the background color)	2024-06-15 15:41:34 +03:00
Kirill Chibisov	078b46720b	chore: address 1.79 clippy lints	2024-06-15 15:26:26 +03:00
daxpedda	3b4e064a07	Web: fix crash `InnerSizeWriter::request_inner_size()` (#3727 )	2024-06-12 00:22:03 +02:00
daxpedda	39bc139500	Web: don't overwrite cursor with `CursorIcon::Default` (#3729 )	2024-06-12 00:12:14 +02:00
daxpedda	9522670081	Web: queue `EventLoopProxy::send_event()` to microtask	2024-06-12 00:02:26 +02:00
Kirill Chibisov	9a1ef49dc3	Bump version on master This commit does not represent a release and only synchronizes CHANGELOG from the latest release.	2024-06-10 17:13:33 -07:00
Mads Marquart	3a624e0f52	macOS/iOS: Various refactorings in application state (#3720 ) I'm preparing to get rid of our application delegate in favour of registering notification observers, to do so I'm renaming `app_delegate.rs` to `app_state.rs`, and moving the functionality out of the Objective-C method into a normal method. Additionally, `AppState` previously implemented `Default`, but really, this was a hack done because someone (probably myself) was too lazy to write out the full initialization in `AppDelegate::new`.	2024-06-06 14:39:31 +02:00
Mads Marquart	279e3edc54	macOS: Improve event queuing (#3708 ) * Use AppKit's internal queuing mechanisms This allows events to be queued in a more consistent order, they're now interleaved with events that we handle immediately (like redraw events), instead of being handled afterwards. * Only queue events if necessary This makes the call stack / backtraces easier to understand whenever possible, and generally improves upon the order in which events are delivered.	2024-06-06 12:32:02 +02:00
Philippe Renon	0e74d37ff5	doc: clarify `Window::pre_present_notify` availability Fixes #3703.	2024-06-06 12:11:06 +03:00
ShikiSuen	2d1382f7d6	Handle _selected_range sent to NSTextInputClient.setMarkedText(). (#3619 ) Co-authored-by: Mads Marquart <mads@marquart.dk>	2024-05-31 08:54:20 +02:00
Mads Marquart	5d8091fc7f	Implement ApplicationHandler for `&mut A` and `Box<A>` (#3709 )	2024-05-29 11:51:53 +02:00
Mads Marquart	d7abe0316e	Update `objc2` to `v0.2.2` (#3702 ) - Use new `bitflags!` support. - Use `objc2-ui-kit`. - Change usage of `Id` to `Retained`.	2024-05-27 14:49:22 +02:00
Diggory Hardy	5ea20fc905	event_loop: add is_x11 and is_wayland on EventLoop	2024-05-26 17:38:10 +04:00
Golden Water	e108fa2fbf	Resize when size changes on scale change on macOS This fixes an issue where the window glitched due to resize when the user doesn't actually change the window, but macOS function to update window size was still called.	2024-05-23 20:40:07 +04:00
Kirill Chibisov	fff6788c12	chore: explicitly use cfg_aliases 0.2.1 This correctly handles recent nightly lint that requires to explicitly define the CFG guards.	2024-05-22 15:51:29 +04:00
Kirill Chibisov	3e8fa41073	event_loop: remove deprecated `run` APIs The APIs are not well suited for the `&dyn ApplicationHandler` model and `Box<dyn EventLoop>` structure, thus remove them.	2024-05-20 20:27:36 +04:00
Kevin Müller	2b1c8cea1b	bugfix: Replace pointer dereference with read_unaligned On Raspberry Pi, using the Rust crate eframe caused the program to crash on mouse movement. The Backtrace lead to this specific line of code, and the exact error was a "misaligned pointer dereference: address must be a multiple of 0x8 but is xxxx" The edit has been tested with the Raspberry Pi, which works now.	2024-05-19 15:08:14 -07:00
Ryan Burleson	ab33fb8eda	fix doc typo in application.rs (#3676 )	2024-05-07 21:24:02 +02:00
linkmauve	b0b64a9a15	Reexport older versions of raw-window-handle When the user decides to use an older version of raw-window-handle, through the rwh_04 or rwh_05 features, it makes sense to reexport the crate so they don’t have to depend on it manually and can instead use winit::raw_window_handle.	2024-05-06 19:50:25 +04:00
Mads Marquart	d5d202d60e	Reduce usage of direct `msg_send!`	2024-05-06 19:09:38 +04:00
Mads Marquart	cb39ab29f4	macOS: Move util::EMPTY_RANGE to usage spot (#3685 )	2024-05-06 16:54:52 +02:00
Mads Marquart	0a3cacd577	Retain ApplicationDelegate in NSWindowDelegate and NSView The delegate is only weakly referenced by NSApplication, so getting it from there may fail if the event loop has been dropped. Fixes #3668.	2024-05-06 18:29:07 +04:00
Mads Marquart	16fd2baba0	Use `rustc-check-cfg` (#3682 )	2024-05-06 07:11:57 +02:00
daxpedda	7f8771a362	Web: fix Clippy v1.78 FPs (#3678 )	2024-05-03 22:24:54 +02:00
Kirill Chibisov	337d50779c	Bump version on master This commit does not represent a release and only synchronizes CHANGELOG from the latest release.	2024-04-27 20:02:40 +04:00
Joshua Pedrick	fd477986de	Add UIGestureRecognizerDelegate and PanGestureRecogniser (#3597 ) - Allow all gestures simultaneously recognized. - Add PanGestureRecogniser with min/max number of touches. - Fix sending delta values relative to Update instead to match macOS. - Fix rotation gesture units from iOS to be in degrees instead of radians. Co-authored-by: Mads Marquart <mads@marquart.dk>	2024-04-27 15:55:04 +02:00
Mads Marquart	94664ff687	Don't set the background color when initializing with transparency (#3657 ) Setting the background color changes how the window title bar appears, which is something that the application should customize itself if it wants this behaviour (and also, it wasn't set when calling `set_transparent`, so the behaviour wasn't consistent).	2024-04-27 15:41:14 +02:00
growfrow	0fc8c37721	chore: fix some typos in comments (#3635 ) Signed-off-by: growfrow <growfrow@outlook.com>	2024-04-27 15:29:11 +02:00
Kirill Chibisov	ec29c81ad2	chore: ensure that `.cargo` config is not published Just in case, so the correct changelog will be rendered when pulling the crate from the crates.io as archive and trying to build it.	2024-04-27 17:03:28 +04:00
Marijn Suijten	304a585493	android: bump to `ndk 0.9.0` and `android-activity 0.6.0`	2024-04-27 13:35:11 +04:00
				`@@ -0,0 +1 @@`
				`onmessage=e=>{let[s,t]=e.data,a=()=>s.postMessage(void 0);"scheduler"in this?scheduler.postTask(a,{delay:t}):setTimeout(a,t)};`