Winit version 0.31.0-beta.2

winit-core: fix set_ime_allowed always panicing
winit/event_loop: Add register_app and run_app_never_return
2026-06-26 22:53:15 -04:00 · 2025-11-16 17:23:28 +09:00 · 2025-11-16 17:23:28 +09:00 · 2025-11-16 17:23:28 +09:00 · 2025-11-16 17:23:28 +09:00 · 2025-11-16 13:32:44 +09:00
295 changed files with 9618 additions and 8322 deletions
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -1,31 +1,26 @@
 # Android
-/src/platform/android.rs            @MarijnS95
-/src/platform_impl/android          @MarijnS95
+/winit-android                      @MarijnS95

 # Apple (AppKit + UIKit)
-/src/platform/ios.rs                @madsmtm
-/src/platform/macos.rs              @madsmtm
-/src/platform_impl/apple            @madsmtm
+/winit-appkit                       @madsmtm
+/winit-uikit                        @madsmtm
+/winit-common/src/core_foundation   @madsmtm
+/winit-common/src/event_handler.rs  @madsmtm

-# Unix
-/src/platform_impl/linux/mod.rs     @kchibisov
+# XKB
+/winit-common/src/xkb               @kchibisov

 # Wayland
-/src/platform/wayland.rs            @kchibisov
-/src/platform_impl/linux/wayland    @kchibisov
+/winit-wayland                      @kchibisov

 # X11
-/src/platform/x11.rs                @kchibisov @notgull
-/src/platform_impl/linux/x11        @kchibisov @notgull
+/winit-x11                          @kchibisov

 # Web
-/src/platform/web.rs                @daxpedda
-/src/platform_impl/web              @daxpedda
+/winit-web                          @daxpedda

-# Windows
-/src/platform/windows.rs            @notgull
-/src/platform_impl/windows          @notgull
+# Windows (Win32) (UNOWNED)
+#/winit-win32                       

 # Orbital (Redox OS)
-/src/platform/orbital.rs            @jackpot51
-/src/platform_impl/orbital          @jackpot51
+/winit-orbital                      @jackpot51
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -55,7 +55,7 @@ jobs:
    strategy:
      fail-fast: false
      matrix:
-        toolchain: [stable, nightly, '1.80']
+        toolchain: [stable, nightly, '1.85']
        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,  }
@@ -66,7 +66,7 @@ jobs:
          - { name: 'Linux 64bit',        target: x86_64-unknown-linux-gnu, os: ubuntu-latest,   }
          - { name: 'X11',                target: x86_64-unknown-linux-gnu, os: ubuntu-latest, options: '--no-default-features --features=x11' }
          - { name: 'Wayland',            target: x86_64-unknown-linux-gnu, os: ubuntu-latest, options: '--no-default-features --features=wayland,wayland-dlopen' }
-          - { name: 'Android',            target: aarch64-linux-android,    os: ubuntu-latest, options: '--package=winit --features=android-native-activity', cmd: 'apk --' }
+          - { name: 'Android',            target: aarch64-linux-android,    os: ubuntu-latest, options: '--package winit --features=android-native-activity', cmd: 'apk -- ' }
          - { name: 'Redox OS',           target: x86_64-unknown-redox,     os: ubuntu-latest,   }
          - { name: 'macOS x86_64',       target: x86_64-apple-darwin,      os: macos-latest,    }
          - { name: 'macOS Aarch64',      target: aarch64-apple-darwin,     os: macos-latest,    }
@@ -82,14 +82,14 @@ jobs:
          - toolchain: nightly
            platform: { name: 'Windows 32bit GNU' }
          # Android is tested on stable-3
-          - toolchain: '1.80'
+          - toolchain: '1.85'
            platform: { name: 'Android' }
          # Redox OS doesn't follow MSRV
-          - toolchain: '1.80'
+          - toolchain: '1.85'
            platform: { name: 'Redox OS' }
        include:
-          - toolchain: '1.80'
-            platform: { name: 'Android', target: aarch64-linux-android, os: ubuntu-latest, options: '--package=winit --features=android-native-activity', cmd: 'apk --' }
+          - toolchain: '1.85'
+            platform: { name: 'Android', target: aarch64-linux-android, os: ubuntu-latest, options: '--package winit --features=android-native-activity', cmd: 'apk -- ' }
          - toolchain: 'nightly'
            platform: { name: 'Web', target: wasm32-unknown-unknown, os: ubuntu-latest, test-options: -Zdoctest-xcompile }
          - toolchain: 'nightly'
@@ -136,7 +136,7 @@ jobs:

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

    - name: Install GCC Multilib
      if: (matrix.platform.os == 'ubuntu-latest') && contains(matrix.platform.target, 'i686')
@@ -179,23 +179,70 @@ jobs:
    - name: Build crate
      run: cargo $CMD build $OPTIONS

+    - name: Test winit core
+      run: cargo test -p winit-core
+
+    - name: Test winit Android
+      if: contains(matrix.platform.target, 'android')
+      run: cargo $CMD test -p winit-android --features native-activity --no-run
+
+    - name: Test winit Common (EventHandler)
+      run: cargo $CMD test -p winit-common --features event-handler --no-run
+
+    - name: Test winit Common (CF)
+      if: contains(matrix.platform.target, 'apple')
+      run: cargo $CMD test -p winit-common --features core-foundation --no-run
+
+    - name: Test winit Common (XKB)
+      if: contains(matrix.platform.target, 'linux-gnu')
+      run: cargo $CMD test -p winit-common --features xkb,x11,wayland --no-run
+
+    - name: Test winit AppKit
+      if: contains(matrix.platform.target, 'macos')
+      run: cargo $CMD test -p winit-appkit $OPTIONS
+
+    - name: Test winit Orbital
+      if: contains(matrix.platform.target, 'redox')
+      run: cargo test -p winit-orbital
+
+    - name: Test winit UIKit
+      if: contains(matrix.platform.target, 'ios')
+      # TODO: Run on Simulator
+      run: cargo $CMD test -p winit-uikit $OPTIONS --no-run
+
+    - name: Test winit Web
+      if: contains(matrix.platform.target, 'wasm')
+      run: cargo $CMD test -p winit-web $OPTIONS --no-run
+
+    - name: Test winit Win32
+      if: contains(matrix.platform.target, 'windows')
+      run: cargo $CMD test -p winit-win32 $OPTIONS
+
+    - name: Test winit X11
+      if: contains(matrix.platform.target, 'linux-gnu')
+      run: cargo $CMD test -p winit-x11 --target=${{ matrix.platform.target }}
+
+    - name: Test winit Wayland
+      if: contains(matrix.platform.target, 'linux-gnu')
+      run: cargo $CMD test -p winit-wayland --target=${{ matrix.platform.target }}
+
    # Test only on Linux x86_64, so we avoid spending unnecessary CI hours.
    - name: Test dpi crate
      if: >
        contains(matrix.platform.name, 'Linux 64bit') &&
-        matrix.toolchain != '1.80'
+        matrix.toolchain != '1.85'
      run: cargo test -p dpi
-      
+
    - name: Check dpi crate (no_std)
      if: >
        contains(matrix.platform.name, 'Linux 64bit') &&
-        matrix.toolchain != '1.80'
+        matrix.toolchain != '1.85'
      run: cargo check -p dpi --no-default-features

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

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

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

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

    - name: Check docs.rs documentation
@@ -266,6 +313,7 @@ jobs:
      with:
        command: check
        log-level: error
+        manifest-path: winit/Cargo.toml
        arguments: --all-features --target ${{ matrix.platform.target }}

  eslint:
@@ -274,14 +322,14 @@ jobs:
    runs-on: ubuntu-latest
    defaults:
      run:
-        working-directory: ./src/platform_impl/web/script
+        working-directory: ./winit-web/src/script

    steps:
      - uses: taiki-e/checkout-action@v1
      - name: Setup NPM
        run: npm install
      - name: Run ESLint
-        run: npx eslint
+        run: npx eslint@9.38.0

  swc:
    name: Minimize JavaScript
@@ -289,7 +337,7 @@ jobs:
    runs-on: ubuntu-latest
    defaults:
      run:
-        working-directory: ./src/platform_impl/web/script
+        working-directory: ./winit-web/src/script

    steps:
      - uses: taiki-e/checkout-action@v1
--- a/.github/workflows/docs.yml
+++ b/.github/workflows/docs.yml
@@ -19,7 +19,7 @@ jobs:
      id-token: write

    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5

      - uses: dtolnay/rust-toolchain@master
        with:
@@ -41,7 +41,7 @@ jobs:
          done

      - name: Upload artifact
-        uses: actions/upload-pages-artifact@v3
+        uses: actions/upload-pages-artifact@v4
        with:
          path: target/doc

--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3,6 +3,6 @@ Changelog entries should be put in the [`changelog::unreleased`].
 The changelog can also be viewed [on docs.rs][docs_rs] or [on the current
 master docs][master_docs].

-[`changelog::unreleased`]: src/changelog/unreleased.md
+[`changelog::unreleased`]: winit/src/changelog/unreleased.md
 [docs_rs]: https://docs.rs/winit/latest/winit/changelog/index.html
 [master_docs]: https://rust-windowing.github.io/winit/winit/changelog/index.html
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -13,6 +13,13 @@ To save your time it's wise to check already opened [pull requests][prs] and
 accepted, however larger new API proposals should go into the issue first. When
 in doubt contact us on [Matrix][matrix] or via opening an issue.

+### Windows
+
+To run the examples on Windows, you must have symlinks enabled, see
+[this][git-windows-symlinks].
+
+[git-windows-symlinks]: https://gitforwindows.org/symbolic-links.html
+
 ### Submitting your work and handling review

 All patches have to be sent on Github as [pull requests][prs]. To simplify your
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,403 +1,96 @@
-[package]
-authors = ["The winit contributors", "Pierre Krieger <pierre.krieger1708@gmail.com>"]
-categories = ["gui"]
-description = "Cross-platform window creation library."
-documentation = "https://docs.rs/winit"
-edition.workspace = true
-include = [
-    "/build.rs",
-    "/docs",
-    "/examples",
-    "/FEATURES.md",
-    "/LICENSE",
-    "/src",
-    "!/src/platform_impl/web/script",
-    "/src/platform_impl/web/script/**/*.min.js",
-    "/tests",
-]
-keywords = ["windowing"]
-license.workspace = true
-name = "winit"
-readme = "README.md"
-repository.workspace = true
-rust-version.workspace = true
-version = "0.30.10"
+[workspace]
+default-members = ["winit"]
+members = ["dpi", "winit*"]
+resolver = "2"

-[package.metadata.docs.rs]
-features = [
-    "serde",
-    "mint",
-    # Enabled to get docs to compile
-    "android-native-activity",
-]
-# These are all tested in CI
-rustdoc-args = ["--cfg", "docsrs"]
-targets = [
-    # Windows
-    "i686-pc-windows-msvc",
-    "x86_64-pc-windows-msvc",
-    # macOS
-    "aarch64-apple-darwin",
-    "x86_64-apple-darwin",
-    # Unix (X11 & Wayland)
-    "i686-unknown-linux-gnu",
-    "x86_64-unknown-linux-gnu",
-    # iOS
-    "aarch64-apple-ios",
-    # Android
-    "aarch64-linux-android",
-    # Web
-    "wasm32-unknown-unknown",
-]
+[workspace.package]
+edition = "2024"
+license = "Apache-2.0"
+repository = "https://github.com/rust-windowing/winit"
+rust-version = "1.85"
+version = "0.31.0-beta.2"

-# Features are documented in either `lib.rs` or under `winit::platform`.
-[features]
-android-game-activity = ["android-activity/game-activity"]
-android-native-activity = ["android-activity/native-activity"]
-default = ["x11", "wayland", "wayland-dlopen", "wayland-csd-adwaita"]
-mint = ["dpi/mint"]
-serde = ["dep:serde", "cursor-icon/serde", "smol_str/serde", "dpi/serde", "bitflags/serde"]
-wayland = [
-    "wayland-client",
-    "wayland-backend",
-    "wayland-protocols",
-    "wayland-protocols-plasma",
-    "sctk",
-    "ahash",
-    "memmap2",
-]
-wayland-csd-adwaita = ["sctk-adwaita", "sctk-adwaita/ab_glyph"]
-wayland-csd-adwaita-crossfont = ["sctk-adwaita", "sctk-adwaita/crossfont"]
-wayland-csd-adwaita-notitle = ["sctk-adwaita"]
-wayland-dlopen = ["wayland-backend/dlopen"]
-x11 = ["x11-dl", "bytemuck", "percent-encoding", "xkbcommon-dl/x11", "x11rb"]
+[workspace.dependencies]
+# Workspace dependencies.
+# `winit` has no version here to allow using it in dev deps for docs.
+winit = { path = "winit" }
+winit-android = { version = "=0.31.0-beta.2", path = "winit-android" }
+winit-appkit = { version = "=0.31.0-beta.2", path = "winit-appkit" }
+winit-common = { version = "=0.31.0-beta.2", path = "winit-common" }
+winit-core = { version = "=0.31.0-beta.2", path = "winit-core" }
+winit-orbital = { version = "=0.31.0-beta.2", path = "winit-orbital" }
+winit-uikit = { version = "=0.31.0-beta.2", path = "winit-uikit" }
+winit-wayland = { version = "=0.31.0-beta.2", path = "winit-wayland", default-features = false }
+winit-web = { version = "=0.31.0-beta.2", path = "winit-web" }
+winit-win32 = { version = "=0.31.0-beta.2", path = "winit-win32" }
+winit-x11 = { version = "=0.31.0-beta.2", path = "winit-x11" }

-[build-dependencies]
-cfg_aliases = "0.2.1"
-
-[dependencies]
+# Core dependencies.
 bitflags = "2"
+cfg_aliases = "0.2.1"
 cursor-icon = "1.1.0"
 dpi = { version = "0.1.2", path = "dpi" }
+keyboard-types = "0.8.0"
+mint = "0.5.6"
 rwh_06 = { package = "raw-window-handle", version = "0.6", features = ["std"] }
-serde = { workspace = true, optional = true }
+serde = { version = "1", features = ["serde_derive"] }
 smol_str = "0.3"
 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-subscriber = { version = "0.3.18", features = ["env-filter"] }
-
-[target.'cfg(not(target_os = "android"))'.dev-dependencies]
+# Dev dependencies.
+image = { version = "0.25.0", default-features = false }
 softbuffer = { version = "0.4.6", default-features = false, features = [
    "x11",
    "x11-dlopen",
    "wayland",
    "wayland-dlopen",
 ] }
+tracing-subscriber = "0.3.18"

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

-# AppKit or UIKit
-[target.'cfg(target_vendor = "apple")'.dependencies]
+# Apple dependencies.
 block2 = "0.6.1"
 dispatch2 = { version = "0.3.0", default-features = false, features = ["std", "objc2"] }
-objc2 = "0.6.1"
+objc2 = { version = "0.6.1", features = ["relax-sign-encoding"] }
+objc2-app-kit = { version = "0.3.2", default-features = false }
+objc2-core-foundation = { version = "0.3.2", default-features = false }
+objc2-core-graphics = { version = "0.3.2", default-features = false }
+objc2-core-video = { version = "0.3.2", default-features = false }
+objc2-foundation = { version = "0.3.2", default-features = false }
+objc2-ui-kit = { version = "0.3.2", default-features = false }

-# AppKit
-[target.'cfg(target_os = "macos")'.dependencies]
-objc2-app-kit = { version = "0.3.1", default-features = false, features = [
-    "std",
-    "objc2-core-foundation",
-    "NSAppearance",
-    "NSApplication",
-    "NSBitmapImageRep",
-    "NSButton",
-    "NSColor",
-    "NSControl",
-    "NSCursor",
-    "NSDragging",
-    "NSEvent",
-    "NSGraphics",
-    "NSGraphicsContext",
-    "NSImage",
-    "NSImageRep",
-    "NSMenu",
-    "NSMenuItem",
-    "NSOpenGLView",
-    "NSPanel",
-    "NSPasteboard",
-    "NSResponder",
-    "NSRunningApplication",
-    "NSScreen",
-    "NSTextInputClient",
-    "NSTextInputContext",
-    "NSToolbar",
-    "NSView",
-    "NSWindow",
-    "NSWindowScripting",
-    "NSWindowTabGroup",
-] }
-objc2-core-foundation = { version = "0.3.1", default-features = false, features = [
-    "std",
-    "block2",
-    "CFBase",
-    "CFCGTypes",
-    "CFData",
-    "CFRunLoop",
-    "CFString",
-    "CFUUID",
-] }
-objc2-core-graphics = { version = "0.3.1", default-features = false, features = [
-    "std",
-    "libc",
-    "CGDirectDisplay",
-    "CGDisplayConfiguration",
-    "CGDisplayFade",
-    "CGError",
-    "CGRemoteOperation",
-    "CGWindowLevel",
-] }
-objc2-core-video = { version = "0.3.1", default-features = false, features = [
-    "std",
-    "objc2-core-graphics",
-    "CVBase",
-    "CVReturn",
-    "CVDisplayLink",
-] }
-objc2-foundation = { version = "0.3.1", default-features = false, features = [
-    "std",
-    "block2",
-    "objc2-core-foundation",
-    "NSArray",
-    "NSAttributedString",
-    "NSData",
-    "NSDictionary",
-    "NSDistributedNotificationCenter",
-    "NSEnumerator",
-    "NSGeometry",
-    "NSKeyValueObserving",
-    "NSNotification",
-    "NSObjCRuntime",
-    "NSOperation",
-    "NSPathUtilities",
-    "NSProcessInfo",
-    "NSRunLoop",
-    "NSString",
-    "NSThread",
-    "NSValue",
-] }
-
-# UIKit
-[target.'cfg(all(target_vendor = "apple", not(target_os = "macos")))'.dependencies]
-objc2-core-foundation = { version = "0.3.1", default-features = false, features = [
-    "std",
-    "CFCGTypes",
-    "CFBase",
-    "CFRunLoop",
-    "CFString",
-] }
-objc2-foundation = { version = "0.3.1", default-features = false, features = [
-    "std",
-    "block2",
-    "objc2-core-foundation",
-    "NSArray",
-    "NSEnumerator",
-    "NSGeometry",
-    "NSObjCRuntime",
-    "NSOperation",
-    "NSString",
-    "NSThread",
-    "NSSet",
-] }
-objc2-ui-kit = { version = "0.3.1", default-features = false, features = [
-    "std",
-    "objc2-core-foundation",
-    "UIApplication",
-    "UIDevice",
-    "UIEvent",
-    "UIGeometry",
-    "UIGestureRecognizer",
-    "UITextInput",
-    "UITextInputTraits",
-    "UIOrientation",
-    "UIPanGestureRecognizer",
-    "UIPinchGestureRecognizer",
-    "UIResponder",
-    "UIRotationGestureRecognizer",
-    "UIScreen",
-    "UIScreenMode",
-    "UITapGestureRecognizer",
-    "UITouch",
-    "UITraitCollection",
-    "UIView",
-    "UIViewController",
-    "UIWindow",
-] }
-
-# Windows
-[target.'cfg(target_os = "windows")'.dependencies]
+# Windows dependencies.
 unicode-segmentation = "1.7.1"
-windows-sys = { version = "0.59.0", features = [
-    "Win32_Devices_HumanInterfaceDevice",
-    "Win32_Foundation",
-    "Win32_Globalization",
-    "Win32_Graphics_Dwm",
-    "Win32_Graphics_Gdi",
-    "Win32_Media",
-    "Win32_System_Com_StructuredStorage",
-    "Win32_System_Com",
-    "Win32_System_LibraryLoader",
-    "Win32_System_Ole",
-    "Win32_Security",
-    "Win32_System_SystemInformation",
-    "Win32_System_SystemServices",
-    "Win32_System_Threading",
-    "Win32_System_WindowsProgramming",
-    "Win32_UI_Accessibility",
-    "Win32_UI_Controls",
-    "Win32_UI_HiDpi",
-    "Win32_UI_Input_Ime",
-    "Win32_UI_Input_KeyboardAndMouse",
-    "Win32_UI_Input_Pointer",
-    "Win32_UI_Input_Touch",
-    "Win32_UI_Shell",
-    "Win32_UI_TextServices",
-    "Win32_UI_WindowsAndMessaging",
-] }
+windows-sys = "0.59.0"

-# 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.13.0"
+# Linux dependencies.
+ahash = { version = "0.8.7", features = ["no-rng"] }
+bytemuck = { version = "1.13.1", default-features = false }
+calloop = "0.14.3"
 libc = "0.2.64"
-memmap2 = { version = "0.9.0", optional = true }
-percent-encoding = { version = "2.0", optional = true }
-rustix = { version = "0.38.4", default-features = false, features = [
-    "std",
-    "system",
-    "thread",
-    "process",
-] }
-sctk = { package = "smithay-client-toolkit", version = "0.19.2", default-features = false, features = [
-    "calloop",
-], optional = true }
-sctk-adwaita = { version = "0.10.1", default-features = false, optional = true }
-wayland-backend = { version = "0.3.10", default-features = false, features = [
-    "client_system",
-], optional = true }
-wayland-client = { version = "0.31.10", optional = true }
-wayland-protocols = { version = "0.32.8", features = ["staging"], optional = true }
-wayland-protocols-plasma = { version = "0.3.8", features = ["client"], optional = true }
-x11-dl = { version = "2.19.1", optional = true }
-x11rb = { version = "0.13.0", default-features = false, features = [
-    "allow-unsafe-code",
-    "cursor",
-    "dl-libxcb",
-    "randr",
-    "resource_manager",
-    "sync",
-    "xinput",
-    "xkb",
-], optional = true }
+memmap2 = "0.9.0"
+percent-encoding = "2.0"
+rustix = { version = "1.0.7", default-features = false }
+x11-dl = "2.19.1"
+x11rb = { version = "0.13.0", default-features = false }
 xkbcommon-dl = "0.4.2"

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

-# Web
-[target.'cfg(target_family = "wasm")'.dependencies]
-js-sys = "0.3.70"
-pin-project = "1"
-wasm-bindgen = "0.2.93"
-wasm-bindgen-futures = "0.4.43"
-web-time = "1"
-web_sys = { package = "web-sys", version = "0.3.70", features = [
-    "AbortController",
-    "AbortSignal",
-    "Blob",
-    "BlobPropertyBag",
-    "console",
-    "CssStyleDeclaration",
-    "Document",
-    "DomException",
-    "DomRect",
-    "DomRectReadOnly",
-    "Element",
-    "Event",
-    "EventTarget",
-    "FocusEvent",
-    "HtmlCanvasElement",
-    "HtmlElement",
-    "HtmlHtmlElement",
-    "HtmlImageElement",
-    "ImageBitmap",
-    "ImageBitmapOptions",
-    "ImageBitmapRenderingContext",
-    "ImageData",
-    "IntersectionObserver",
-    "IntersectionObserverEntry",
-    "KeyboardEvent",
-    "MediaQueryList",
-    "MessageChannel",
-    "MessagePort",
-    "Navigator",
-    "Node",
-    "OrientationLockType",
-    "OrientationType",
-    "PageTransitionEvent",
-    "Permissions",
-    "PermissionState",
-    "PermissionStatus",
-    "PointerEvent",
-    "PremultiplyAlpha",
-    "ResizeObserver",
-    "ResizeObserverBoxOptions",
-    "ResizeObserverEntry",
-    "ResizeObserverOptions",
-    "ResizeObserverSize",
-    "Screen",
-    "ScreenOrientation",
-    "Url",
-    "VisibilityState",
-    "WheelEvent",
-    "Window",
-    "Worker",
-] }
-
-[target.'cfg(all(target_family = "wasm", target_feature = "atomics"))'.dependencies]
+# Web dependencies.
 atomic-waker = "1"
 concurrent-queue = { version = "2", default-features = false }
-
-[target.'cfg(target_family = "wasm")'.dev-dependencies]
 console_error_panic_hook = "0.1"
+js-sys = "0.3.70"
+pin-project = "1"
 tracing-web = "0.1"
+wasm-bindgen = "0.2.93"
+wasm-bindgen-futures = "0.4.43"
 wasm-bindgen-test = "0.3"
-
-[[example]]
-doc-scrape-examples = true
-name = "window"
-
-[[example]]
-name = "child_window"
-
-[workspace]
-members = ["dpi"]
-resolver = "2"
-
-[workspace.package]
-edition = "2021"
-license = "Apache-2.0"
-repository = "https://github.com/rust-windowing/winit"
-rust-version = "1.80"
-
-[workspace.dependencies]
-mint = "0.5.6"
-serde = { version = "1", features = ["serde_derive"] }
+web-time = "1"
+web_sys = { package = "web-sys", version = "0.3.70" }
--- a/README.md
+++ b/README.md
@@ -8,7 +8,7 @@

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

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

 ## MSRV Policy

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

 As a **tentative** policy, the upper bound of the MSRV is given by the following
--- a/clippy.toml
+++ b/clippy.toml
@@ -1,16 +1,20 @@
+# Using allow-invalid because this is platform-specific code
 disallowed-methods = [
-    { 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 = "web_sys::Document::exit_fullscreen", reason = "Doesn't account for compatibility with Safari" },
-    { path = "web_sys::Document::fullscreen_element", reason = "Doesn't account for compatibility with Safari" },
-    { path = "web_sys::Element::request_fullscreen", reason = "Doesn't account for compatibility with Safari" },
-    { path = "web_sys::HtmlCanvasElement::height", reason = "Winit shouldn't touch the internal canvas size" },
-    { path = "web_sys::HtmlCanvasElement::set_height", reason = "Winit shouldn't touch the internal canvas size" },
-    { path = "web_sys::HtmlCanvasElement::set_width", reason = "Winit shouldn't touch the internal canvas size" },
-    { path = "web_sys::HtmlCanvasElement::width", reason = "Winit shouldn't touch the internal canvas size" },
-    { path = "web_sys::HtmlElement::style", reason = "cache this to reduce calls to JS" },
-    { path = "web_sys::Window::document", reason = "cache this to reduce calls to JS" },
-    { path = "web_sys::Window::get_computed_style", reason = "cache this to reduce calls to JS" },
-    { path = "web_sys::Window::navigator", reason = "cache this to reduce calls to JS" },
-    { path = "web_sys::window", reason = "is not available in every context" },
+    { allow-invalid = true, 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." },
+    { allow-invalid = true, path = "objc2_app_kit::NSWindow::setFrameTopLeftPoint", reason = "Not sufficient when working with Winit's coordinate system, use `flip_window_screen_coordinates` instead" },
+    { allow-invalid = true, path = "web_sys::Document::exit_fullscreen", reason = "Doesn't account for compatibility with Safari" },
+    { allow-invalid = true, path = "web_sys::Document::fullscreen_element", reason = "Doesn't account for compatibility with Safari" },
+    { allow-invalid = true, path = "web_sys::Element::request_fullscreen", reason = "Doesn't account for compatibility with Safari" },
+    { allow-invalid = true, path = "web_sys::HtmlCanvasElement::height", reason = "Winit shouldn't touch the internal canvas size" },
+    { allow-invalid = true, path = "web_sys::HtmlCanvasElement::set_height", reason = "Winit shouldn't touch the internal canvas size" },
+    { allow-invalid = true, path = "web_sys::HtmlCanvasElement::set_width", reason = "Winit shouldn't touch the internal canvas size" },
+    { allow-invalid = true, path = "web_sys::HtmlCanvasElement::width", reason = "Winit shouldn't touch the internal canvas size" },
+    { allow-invalid = true, path = "web_sys::HtmlElement::style", reason = "cache this to reduce calls to JS" },
+    { allow-invalid = true, path = "web_sys::MouseEvent::buttons", reason = "Use `backend::event::cursor_buttons()` to avoid wrong conversions" },
+    { allow-invalid = true, path = "web_sys::MouseEvent::button", reason = "Use `backend::event::cursor_button()` to avoid wrong conversions" },
+    { allow-invalid = true, path = "web_sys::PointerEvent::pointer_type", reason = "Use `WebPointerType` to emit warnings" },
+    { allow-invalid = true, path = "web_sys::Window::document", reason = "cache this to reduce calls to JS" },
+    { allow-invalid = true, path = "web_sys::Window::get_computed_style", reason = "cache this to reduce calls to JS" },
+    { allow-invalid = true, path = "web_sys::Window::navigator", reason = "cache this to reduce calls to JS" },
+    { allow-invalid = true, path = "web_sys::window", reason = "is not available in every context" },
 ]
--- a/deny.toml
+++ b/deny.toml
@@ -38,8 +38,12 @@ private = { ignore = true }

 [bans]
 multiple-versions = "deny"
-skip = [{ crate = "bitflags@1", reason = "the ecosystem is in the process of migrating" }]
-wildcards = "allow"                                                                        # at least until https://github.com/EmbarkStudios/cargo-deny/issues/241 is fixed
+skip = [
+    { crate = "bitflags@1", reason = "the ecosystem is in the process of migrating" },
+    { crate = "rustix@0.38", reason = "the ecosystem is in the process of migrating" },
+    { crate = "linux-raw-sys@0.4", reason = "the ecosystem is in the process of migrating" },
+]
+wildcards = "allow" # at least until https://github.com/EmbarkStudios/cargo-deny/issues/241 is fixed

 [bans.build]
 include-archives = true
@@ -55,6 +59,10 @@ crate = "android-activity"
 allow-globs = ["ci/*", "githooks/*"]
 crate = "zerocopy"

+[[bans.build.bypass]]
+allow-globs = ["cherry-pick-stable.sh"]
+crate = "libc"
+
 [[bans.build.bypass]]
 allow-globs = ["freetype2/*"]
 crate = "freetype-sys"
--- a/docs/ATTRIBUTION.md
+++ b/docs/ATTRIBUTION.md
@@ -1,18 +0,0 @@
-# Image Attribution
-
-These images are used in the documentation of `winit`.
-
-## keyboard_*.svg
-
-These files are a modified version of "[ANSI US QWERTY (Windows)](https://commons.wikimedia.org/wiki/File:ANSI_US_QWERTY_(Windows).svg)"
-by [Tomiĉo] (https://commons.wikimedia.org/wiki/User:Tomi%C4%89o). It was
-originally released under the [CC-BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/deed.en)
-License. Minor modifications have been made by [John Nunley](https://github.com/notgull),
-which have been released under the same license as a derivative work.
-
-## `coordinate-systems*`
-
-These files are created by [Mads Marquart](https://github.com/madsmtm) using
-[draw.io](https://draw.io/), and compressed using [svgomg.net](https://svgomg.net/).
-
-They are licensed under the [CC-BY 4.0](https://creativecommons.org/licenses/by/4.0/) license.
--- a/docs/res/keyboard_left_shift_key.svg
+++ b/docs/res/keyboard_left_shift_key.svg
--- a/docs/res/keyboard_numpad_1_key.svg
+++ b/docs/res/keyboard_numpad_1_key.svg
--- a/docs/res/keyboard_right_shift_key.svg
+++ b/docs/res/keyboard_right_shift_key.svg
--- a/docs/res/keyboard_standard_1_key.svg
+++ b/docs/res/keyboard_standard_1_key.svg
--- a/dpi/src/lib.rs
+++ b/dpi/src/lib.rs
@@ -64,7 +64,7 @@
 //! [points]: https://en.wikipedia.org/wiki/Point_(typography)
 //! [picas]: https://en.wikipedia.org/wiki/Pica_(typography)

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

--- a/1
+++ b/1
@@ -0,0 +1 @@
+winit/examples
--- a/src/keyboard.rs
+++ b/src/keyboard.rs
--- a/src/platform/event_loop.rs
+++ b/src/platform/event_loop.rs
@@ -1,193 +0,0 @@
-use std::marker::PhantomData;
-#[cfg(any(x11_platform, wayland_platform))]
-use std::os::unix::io::{AsFd, AsRawFd, BorrowedFd, RawFd};
-use std::sync::atomic::{AtomicBool, Ordering};
-
-use rwh_06::{DisplayHandle, HandleError, HasDisplayHandle};
-
-use crate::application::ApplicationHandler;
-use crate::cursor::{CustomCursor, CustomCursorSource};
-use crate::error::{EventLoopError, RequestError};
-use crate::event_loop::{
-    ControlFlow, DeviceEvents, EventLoopProvider, EventLoopProxy, OwnedDisplayHandle,
-};
-use crate::platform_impl;
-
-/// Provides a way to retrieve events from the system and from the windows that were registered to
-/// the events loop.
-///
-/// An `EventLoop` can be seen more or less as a "context". Calling [`EventLoop::new`]
-/// initializes everything that will be required to create windows. For example on Linux creating
-/// an event loop opens a connection to the X or Wayland server.
-///
-/// To wake up an `EventLoop` from a another thread, see the [`EventLoopProxy`] docs.
-///
-/// Note that this cannot be shared across threads (due to platform-dependant logic
-/// forbidding it), as such it is neither [`Send`] nor [`Sync`]. If you need cross-thread access,
-/// the [`Window`] created from this _can_ be sent to an other thread, and the
-/// [`EventLoopProxy`] allows you to wake up an `EventLoop` from another thread.
-///
-/// [`Window`]: crate::window::Window
-#[derive(Debug)]
-pub struct EventLoop {
-    pub(crate) event_loop: platform_impl::EventLoop,
-    pub(crate) _marker: PhantomData<*mut ()>, // Not Send nor Sync
-}
-
-impl EventLoop {
-    /// Create the event loop.
-    ///
-    /// This is an alias of `EventLoop::builder().build()`.
-    #[inline]
-    pub fn new() -> Result<EventLoop, EventLoopError> {
-        Self::builder().build()
-    }
-
-    /// Start building a new event loop.
-    ///
-    /// This returns an [`EventLoopBuilder`], to allow configuring the event loop before creation.
-    ///
-    /// To get the actual event loop, call [`build`][EventLoopBuilder::build] on that.
-    #[inline]
-    pub fn builder() -> EventLoopBuilder {
-        EventLoopBuilder { platform_specific: Default::default() }
-    }
-}
-
-impl EventLoopProvider for EventLoop {
-    #[cfg(not(all(web_platform, target_feature = "exception-handling")))]
-    fn run_app(self, app: impl ApplicationHandler) -> Result<(), EventLoopError> {
-        self.event_loop.run_app(app)
-    }
-
-    fn create_proxy(&self) -> EventLoopProxy {
-        self.event_loop.window_target().create_proxy()
-    }
-
-    fn owned_display_handle(&self) -> OwnedDisplayHandle {
-        self.event_loop.window_target().owned_display_handle()
-    }
-
-    fn listen_device_events(&self, allowed: DeviceEvents) {
-        let _span = tracing::debug_span!(
-            "winit::EventLoop::listen_device_events",
-            allowed = ?allowed
-        )
-        .entered();
-        self.event_loop.window_target().listen_device_events(allowed)
-    }
-
-    fn set_control_flow(&self, control_flow: ControlFlow) {
-        self.event_loop.window_target().set_control_flow(control_flow);
-    }
-
-    fn create_custom_cursor(
-        &self,
-        custom_cursor: CustomCursorSource,
-    ) -> Result<CustomCursor, RequestError> {
-        self.event_loop.window_target().create_custom_cursor(custom_cursor)
-    }
-}
-
-impl HasDisplayHandle for EventLoop {
-    fn display_handle(&self) -> Result<DisplayHandle<'_>, HandleError> {
-        HasDisplayHandle::display_handle(self.event_loop.window_target().rwh_06_handle())
-    }
-}
-
-#[cfg(any(x11_platform, wayland_platform))]
-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.
-    ///
-    /// [`calloop`]: https://crates.io/crates/calloop
-    /// [`mio`]: https://crates.io/crates/mio
-    /// [`pump_app_events`]: crate::platform::pump_events::EventLoopExtPumpEvents::pump_app_events
-    fn as_fd(&self) -> BorrowedFd<'_> {
-        self.event_loop.as_fd()
-    }
-}
-
-#[cfg(any(x11_platform, wayland_platform))]
-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.
-    ///
-    /// [`calloop`]: https://crates.io/crates/calloop
-    /// [`mio`]: https://crates.io/crates/mio
-    /// [`pump_app_events`]: crate::platform::pump_events::EventLoopExtPumpEvents::pump_app_events
-    fn as_raw_fd(&self) -> RawFd {
-        self.event_loop.as_raw_fd()
-    }
-}
-
-/// Object that allows building the event loop.
-///
-/// 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::builder`].
-#[derive(Default, Debug, PartialEq, Eq, Hash)]
-pub struct EventLoopBuilder {
-    pub(crate) platform_specific: platform_impl::PlatformSpecificEventLoopAttributes,
-}
-
-static EVENT_LOOP_CREATED: AtomicBool = AtomicBool::new(false);
-
-impl EventLoopBuilder {
-    /// Builds a new event loop.
-    ///
-    /// ***For cross-platform compatibility, the [`EventLoop`] must be created on the main thread,
-    /// and only once per application.***
-    ///
-    /// Calling this function will result in display backend initialisation.
-    ///
-    /// ## Panics
-    ///
-    /// Attempting to create the event loop off the main thread will panic. This
-    /// restriction isn't strictly necessary on all platforms, but is imposed to
-    /// eliminate any nasty surprises when porting to platforms that require it.
-    /// `EventLoopBuilderExt::with_any_thread` functions are exposed in the relevant
-    /// [`platform`] module if the target platform supports creating an event
-    /// loop on any thread.
-    ///
-    /// ## Platform-specific
-    ///
-    /// - **Wayland/X11:** to prevent running under `Wayland` or `X11` unset `WAYLAND_DISPLAY` or
-    ///   `DISPLAY` respectively when building the event loop.
-    /// - **Android:** must be configured with an `AndroidApp` from `android_main()` by calling
-    ///   [`.with_android_app(app)`] before calling `.build()`, otherwise it'll panic.
-    ///
-    /// [`platform`]: crate::platform
-    #[cfg_attr(
-        android_platform,
-        doc = "[`.with_android_app(app)`]: \
-               crate::platform::android::EventLoopBuilderExtAndroid::with_android_app"
-    )]
-    #[cfg_attr(
-        not(android_platform),
-        doc = "[`.with_android_app(app)`]: #only-available-on-android"
-    )]
-    #[inline]
-    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) {
-            return Err(EventLoopError::RecreationAttempt);
-        }
-
-        // Certain platforms accept a mutable reference in their API.
-        #[allow(clippy::unnecessary_mut_passed)]
-        Ok(EventLoop {
-            event_loop: platform_impl::EventLoop::new(&mut self.platform_specific)?,
-            _marker: PhantomData,
-        })
-    }
-
-    #[cfg(web_platform)]
-    pub(crate) fn allow_event_loop_recreation() {
-        EVENT_LOOP_CREATED.store(false, Ordering::Relaxed);
-    }
-}
--- a/src/platform/mod.rs
+++ b/src/platform/mod.rs
@@ -1,48 +0,0 @@
-//! Contains traits with platform-specific methods in them.
-//!
-//! Only the modules corresponding to the platform you're compiling to will be available.
-
-#[cfg(android_platform)]
-pub mod android;
-#[cfg(ios_platform)]
-pub mod ios;
-#[cfg(macos_platform)]
-pub mod macos;
-#[cfg(orbital_platform)]
-pub mod orbital;
-#[cfg(any(x11_platform, wayland_platform))]
-pub mod startup_notify;
-#[cfg(wayland_platform)]
-pub mod wayland;
-#[cfg(web_platform)]
-pub mod web;
-#[cfg(windows_platform)]
-pub mod windows;
-#[cfg(x11_platform)]
-pub mod x11;
-
-#[allow(unused_imports)]
-#[cfg(any(
-    windows_platform,
-    macos_platform,
-    android_platform,
-    x11_platform,
-    wayland_platform,
-    docsrs,
-))]
-pub mod run_on_demand;
-
-#[cfg(any(
-    windows_platform,
-    macos_platform,
-    android_platform,
-    x11_platform,
-    wayland_platform,
-    docsrs,
-))]
-pub mod pump_events;
-
-#[cfg(any(windows_platform, macos_platform, x11_platform, wayland_platform, docsrs))]
-pub mod scancode;
-
-pub mod event_loop;
--- a/src/platform/orbital.rs
+++ b/src/platform/orbital.rs
@@ -1,6 +0,0 @@
-//! # Orbital / Redox OS
-//!
-//! Redox OS has some functionality not yet present that will be implemented
-//! when its orbital display server provides it.
-
-// There are no Orbital specific traits yet.
--- a/src/platform/wayland.rs
+++ b/src/platform/wayland.rs
@@ -1,111 +0,0 @@
-//! # Wayland
-//!
-//! **Note:** Windows don't appear on Wayland until you draw/present to them.
-//!
-//! By default, Winit loads system libraries using `dlopen`. This can be
-//! disabled by disabling the `"wayland-dlopen"` cargo feature.
-//!
-//! ## Client-side decorations
-//!
-//! Winit provides client-side decorations by default, but the behaviour can
-//! be controlled with the following feature flags:
-//!
-//! * `wayland-csd-adwaita` (default).
-//! * `wayland-csd-adwaita-crossfont`.
-//! * `wayland-csd-adwaita-notitle`.
-
-use std::ffi::c_void;
-use std::ptr::NonNull;
-
-use crate::event_loop::{ActiveEventLoop, EventLoop, EventLoopBuilder};
-use crate::platform_impl::wayland::Window;
-pub use crate::window::Theme;
-use crate::window::{Window as CoreWindow, WindowAttributes};
-
-/// Additional methods on [`ActiveEventLoop`] that are specific to Wayland.
-pub trait ActiveEventLoopExtWayland {
-    /// True if the [`ActiveEventLoop`] uses Wayland.
-    fn is_wayland(&self) -> bool;
-}
-
-impl ActiveEventLoopExtWayland for dyn ActiveEventLoop + '_ {
-    #[inline]
-    fn is_wayland(&self) -> bool {
-        self.cast_ref::<crate::platform_impl::wayland::ActiveEventLoop>().is_some()
-    }
-}
-
-/// 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.
-    fn with_wayland(&mut self) -> &mut Self;
-
-    /// Whether to allow the event loop to be created off of the main thread.
-    ///
-    /// By default, the window is only allowed to be created on the main
-    /// thread, to make platform compatibility easier.
-    fn with_any_thread(&mut self, any_thread: bool) -> &mut Self;
-}
-
-impl EventLoopBuilderExtWayland for EventLoopBuilder {
-    #[inline]
-    fn with_wayland(&mut self) -> &mut Self {
-        self.platform_specific.forced_backend = Some(crate::platform_impl::Backend::Wayland);
-        self
-    }
-
-    #[inline]
-    fn with_any_thread(&mut self, any_thread: bool) -> &mut Self {
-        self.platform_specific.any_thread = any_thread;
-        self
-    }
-}
-
-/// Additional methods on [`Window`] that are specific to Wayland.
-///
-/// [`Window`]: crate::window::Window
-pub trait WindowExtWayland {
-    /// Returns `xdg_toplevel` of the window or [`None`] if the window is X11 window.
-    fn xdg_toplevel(&self) -> Option<NonNull<c_void>>;
-}
-
-impl WindowExtWayland for dyn CoreWindow + '_ {
-    #[inline]
-    fn xdg_toplevel(&self) -> Option<NonNull<c_void>> {
-        self.cast_ref::<Window>()?.xdg_toplevel()
-    }
-}
-
-/// Additional methods on [`WindowAttributes`] that are specific to Wayland.
-pub trait WindowAttributesExtWayland {
-    /// Build window with the given name.
-    ///
-    /// The `general` name sets an application ID, which should match the `.desktop`
-    /// file distributed with your program. The `instance` is a `no-op`.
-    ///
-    /// For details about application ID conventions, see the
-    /// [Desktop Entry Spec](https://specifications.freedesktop.org/desktop-entry-spec/desktop-entry-spec-latest.html#desktop-file-id)
-    fn with_name(self, general: impl Into<String>, instance: impl Into<String>) -> Self;
-}
-
-impl WindowAttributesExtWayland for WindowAttributes {
-    #[inline]
-    fn with_name(mut self, general: impl Into<String>, instance: impl Into<String>) -> Self {
-        self.platform_specific.name =
-            Some(crate::platform_impl::ApplicationName::new(general.into(), instance.into()));
-        self
-    }
-}
--- a/src/platform_impl/apple/appkit/mod.rs
+++ b/src/platform_impl/apple/appkit/mod.rs
@@ -1,23 +0,0 @@
-#[macro_use]
-mod util;
-
-mod app;
-mod app_state;
-mod cursor;
-mod event;
-mod event_loop;
-mod ffi;
-mod menu;
-mod monitor;
-mod observer;
-mod view;
-mod window;
-mod window_delegate;
-
-pub(crate) use self::event::{physicalkey_to_scancode, scancode_to_physicalkey};
-pub(crate) use self::event_loop::{
-    ActiveEventLoop, EventLoop, PlatformSpecificEventLoopAttributes,
-};
-pub(crate) use self::monitor::MonitorHandle;
-pub(crate) use self::window::Window;
-pub(crate) use self::window_delegate::PlatformSpecificWindowAttributes;
--- a/src/platform_impl/apple/mod.rs
+++ b/src/platform_impl/apple/mod.rs
@@ -1,16 +0,0 @@
-//! Apple/Darwin-specific implementations
-
-#[cfg(target_os = "macos")]
-mod appkit;
-mod event_handler;
-mod event_loop_proxy;
-mod notification_center;
-#[cfg(not(target_os = "macos"))]
-mod uikit;
-
-#[allow(unused_imports)]
-#[cfg(target_os = "macos")]
-pub use self::appkit::*;
-#[allow(unused_imports)]
-#[cfg(not(target_os = "macos"))]
-pub use self::uikit::*;
--- a/src/platform_impl/apple/uikit/mod.rs
+++ b/src/platform_impl/apple/uikit/mod.rs
@@ -1,25 +0,0 @@
-#![allow(clippy::let_unit_value)]
-
-mod app_state;
-mod event_loop;
-mod monitor;
-mod view;
-mod view_controller;
-mod window;
-
-use std::fmt;
-
-pub(crate) use self::event_loop::{
-    ActiveEventLoop, EventLoop, PlatformSpecificEventLoopAttributes,
-};
-pub(crate) use self::monitor::MonitorHandle;
-pub(crate) use self::window::{PlatformSpecificWindowAttributes, Window};
-
-#[derive(Debug)]
-pub enum OsError {}
-
-impl fmt::Display for OsError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "os error")
-    }
-}
--- a/src/platform_impl/linux/common/mod.rs
+++ b/src/platform_impl/linux/common/mod.rs
@@ -1 +0,0 @@
-pub mod xkb;
--- a/src/platform_impl/linux/wayland/mod.rs
+++ b/src/platform_impl/linux/wayland/mod.rs
@@ -1,30 +0,0 @@
-//! Winit's Wayland backend.
-
-use sctk::reexports::client::protocol::wl_surface::WlSurface;
-use sctk::reexports::client::Proxy;
-
-use crate::dpi::{LogicalSize, PhysicalSize};
-use crate::window::WindowId;
-
-mod event_loop;
-mod output;
-mod seat;
-mod state;
-mod types;
-mod window;
-
-pub use event_loop::{ActiveEventLoop, EventLoop};
-pub use window::Window;
-
-/// Get the WindowId out of the surface.
-#[inline]
-fn make_wid(surface: &WlSurface) -> WindowId {
-    WindowId::from_raw(surface.id().as_ptr() as usize)
-}
-
-/// The default routine does floor, but we need round on Wayland.
-fn logical_to_physical_rounded(size: LogicalSize<u32>, scale_factor: f64) -> PhysicalSize<u32> {
-    let width = size.width as f64 * scale_factor;
-    let height = size.height as f64 * scale_factor;
-    (width.round(), height.round()).into()
-}
--- a/src/platform_impl/linux/wayland/seat/text_input/mod.rs
+++ b/src/platform_impl/linux/wayland/seat/text_input/mod.rs
@@ -1,200 +0,0 @@
-use std::ops::Deref;
-
-use sctk::globals::GlobalData;
-use sctk::reexports::client::globals::{BindError, GlobalList};
-use sctk::reexports::client::protocol::wl_surface::WlSurface;
-use sctk::reexports::client::{delegate_dispatch, Connection, Dispatch, Proxy, QueueHandle};
-use sctk::reexports::protocols::wp::text_input::zv3::client::zwp_text_input_manager_v3::ZwpTextInputManagerV3;
-use sctk::reexports::protocols::wp::text_input::zv3::client::zwp_text_input_v3::{
-    ContentHint, ContentPurpose, Event as TextInputEvent, ZwpTextInputV3,
-};
-
-use crate::event::{Ime, WindowEvent};
-use crate::platform_impl::wayland;
-use crate::platform_impl::wayland::state::WinitState;
-use crate::window::ImePurpose;
-
-#[derive(Debug)]
-pub struct TextInputState {
-    text_input_manager: ZwpTextInputManagerV3,
-}
-
-impl TextInputState {
-    pub fn new(
-        globals: &GlobalList,
-        queue_handle: &QueueHandle<WinitState>,
-    ) -> Result<Self, BindError> {
-        let text_input_manager = globals.bind(queue_handle, 1..=1, GlobalData)?;
-        Ok(Self { text_input_manager })
-    }
-}
-
-impl Deref for TextInputState {
-    type Target = ZwpTextInputManagerV3;
-
-    fn deref(&self) -> &Self::Target {
-        &self.text_input_manager
-    }
-}
-
-impl Dispatch<ZwpTextInputManagerV3, GlobalData, WinitState> for TextInputState {
-    fn event(
-        _state: &mut WinitState,
-        _proxy: &ZwpTextInputManagerV3,
-        _event: <ZwpTextInputManagerV3 as Proxy>::Event,
-        _data: &GlobalData,
-        _conn: &Connection,
-        _qhandle: &QueueHandle<WinitState>,
-    ) {
-    }
-}
-
-impl Dispatch<ZwpTextInputV3, TextInputData, WinitState> for TextInputState {
-    fn event(
-        state: &mut WinitState,
-        text_input: &ZwpTextInputV3,
-        event: <ZwpTextInputV3 as Proxy>::Event,
-        data: &TextInputData,
-        _conn: &Connection,
-        _qhandle: &QueueHandle<WinitState>,
-    ) {
-        let windows = state.windows.get_mut();
-        let mut text_input_data = data.inner.lock().unwrap();
-        match event {
-            TextInputEvent::Enter { surface } => {
-                let window_id = wayland::make_wid(&surface);
-                text_input_data.surface = Some(surface);
-
-                let mut window = match windows.get(&window_id) {
-                    Some(window) => window.lock().unwrap(),
-                    None => return,
-                };
-
-                if window.ime_allowed() {
-                    text_input.enable();
-                    text_input.set_content_type_by_purpose(window.ime_purpose());
-                    text_input.commit();
-                    state.events_sink.push_window_event(WindowEvent::Ime(Ime::Enabled), window_id);
-                }
-
-                window.text_input_entered(text_input);
-            },
-            TextInputEvent::Leave { surface } => {
-                text_input_data.surface = None;
-
-                // Always issue a disable.
-                text_input.disable();
-                text_input.commit();
-
-                let window_id = wayland::make_wid(&surface);
-
-                // XXX this check is essential, because `leave` could have a
-                // reference to nil surface...
-                let mut window = match windows.get(&window_id) {
-                    Some(window) => window.lock().unwrap(),
-                    None => return,
-                };
-
-                window.text_input_left(text_input);
-
-                state.events_sink.push_window_event(WindowEvent::Ime(Ime::Disabled), window_id);
-            },
-            TextInputEvent::PreeditString { text, cursor_begin, cursor_end } => {
-                let text = text.unwrap_or_default();
-                let cursor_begin = usize::try_from(cursor_begin)
-                    .ok()
-                    .and_then(|idx| text.is_char_boundary(idx).then_some(idx));
-                let cursor_end = usize::try_from(cursor_end)
-                    .ok()
-                    .and_then(|idx| text.is_char_boundary(idx).then_some(idx));
-
-                text_input_data.pending_preedit = Some(Preedit { text, cursor_begin, cursor_end })
-            },
-            TextInputEvent::CommitString { text } => {
-                text_input_data.pending_preedit = None;
-                text_input_data.pending_commit = text;
-            },
-            TextInputEvent::Done { .. } => {
-                let window_id = match text_input_data.surface.as_ref() {
-                    Some(surface) => wayland::make_wid(surface),
-                    None => return,
-                };
-
-                // Clear preedit, unless all we'll be doing next is sending a new preedit.
-                if text_input_data.pending_commit.is_some()
-                    || text_input_data.pending_preedit.is_none()
-                {
-                    state.events_sink.push_window_event(
-                        WindowEvent::Ime(Ime::Preedit(String::new(), None)),
-                        window_id,
-                    );
-                }
-
-                // Send `Commit`.
-                if let Some(text) = text_input_data.pending_commit.take() {
-                    state
-                        .events_sink
-                        .push_window_event(WindowEvent::Ime(Ime::Commit(text)), window_id);
-                }
-
-                // Send preedit.
-                if let Some(preedit) = text_input_data.pending_preedit.take() {
-                    let cursor_range =
-                        preedit.cursor_begin.map(|b| (b, preedit.cursor_end.unwrap_or(b)));
-
-                    state.events_sink.push_window_event(
-                        WindowEvent::Ime(Ime::Preedit(preedit.text, cursor_range)),
-                        window_id,
-                    );
-                }
-            },
-            TextInputEvent::DeleteSurroundingText { .. } => {
-                // Not handled.
-            },
-            _ => {},
-        }
-    }
-}
-
-pub trait ZwpTextInputV3Ext {
-    fn set_content_type_by_purpose(&self, purpose: ImePurpose);
-}
-
-impl ZwpTextInputV3Ext for ZwpTextInputV3 {
-    fn set_content_type_by_purpose(&self, purpose: ImePurpose) {
-        let (hint, purpose) = match purpose {
-            ImePurpose::Normal => (ContentHint::None, ContentPurpose::Normal),
-            ImePurpose::Password => (ContentHint::SensitiveData, ContentPurpose::Password),
-            ImePurpose::Terminal => (ContentHint::None, ContentPurpose::Terminal),
-        };
-        self.set_content_type(hint, purpose);
-    }
-}
-
-/// The Data associated with the text input.
-#[derive(Default)]
-pub struct TextInputData {
-    inner: std::sync::Mutex<TextInputDataInner>,
-}
-
-#[derive(Default)]
-pub struct TextInputDataInner {
-    /// The `WlSurface` we're performing input to.
-    surface: Option<WlSurface>,
-
-    /// The commit to submit on `done`.
-    pending_commit: Option<String>,
-
-    /// The preedit to submit on `done`.
-    pending_preedit: Option<Preedit>,
-}
-
-/// The state of the preedit.
-struct Preedit {
-    text: String,
-    cursor_begin: Option<usize>,
-    cursor_end: Option<usize>,
-}
-
-delegate_dispatch!(WinitState: [ZwpTextInputManagerV3: GlobalData] => TextInputState);
-delegate_dispatch!(WinitState: [ZwpTextInputV3: TextInputData] => TextInputState);
--- a/src/platform_impl/linux/wayland/types/cursor.rs
+++ b/src/platform_impl/linux/wayland/types/cursor.rs
@@ -1,68 +0,0 @@
-use cursor_icon::CursorIcon;
-use sctk::reexports::client::protocol::wl_shm::Format;
-use sctk::shm::slot::{Buffer, SlotPool};
-
-use crate::cursor::{CursorImage, CustomCursorProvider};
-
-// Wrap in our own type to not impl trait on global type.
-#[derive(Debug)]
-pub struct WaylandCustomCursor(pub(crate) CursorImage);
-impl CustomCursorProvider for WaylandCustomCursor {
-    fn is_animated(&self) -> bool {
-        false
-    }
-}
-
-#[derive(Debug)]
-pub enum SelectedCursor {
-    Named(CursorIcon),
-    Custom(CustomCursor),
-}
-
-impl Default for SelectedCursor {
-    fn default() -> Self {
-        Self::Named(Default::default())
-    }
-}
-
-#[derive(Debug)]
-pub struct CustomCursor {
-    pub buffer: Buffer,
-    pub w: i32,
-    pub h: i32,
-    pub hotspot_x: i32,
-    pub hotspot_y: i32,
-}
-
-impl CustomCursor {
-    pub(crate) fn new(pool: &mut SlotPool, image: &WaylandCustomCursor) -> Self {
-        let image = &image.0;
-        let (buffer, canvas) = pool
-            .create_buffer(
-                image.width as i32,
-                image.height as i32,
-                4 * (image.width as i32),
-                Format::Argb8888,
-            )
-            .unwrap();
-
-        for (canvas_chunk, rgba) in canvas.chunks_exact_mut(4).zip(image.rgba.chunks_exact(4)) {
-            // Alpha in buffer is premultiplied.
-            let alpha = rgba[3] as f32 / 255.;
-            let r = (rgba[0] as f32 * alpha) as u32;
-            let g = (rgba[1] as f32 * alpha) as u32;
-            let b = (rgba[2] as f32 * alpha) as u32;
-            let color = ((rgba[3] as u32) << 24) + (r << 16) + (g << 8) + b;
-            let array: &mut [u8; 4] = canvas_chunk.try_into().unwrap();
-            *array = color.to_le_bytes();
-        }
-
-        CustomCursor {
-            buffer,
-            w: image.width as i32,
-            h: image.height as i32,
-            hotspot_x: image.hotspot_x as i32,
-            hotspot_y: image.hotspot_y as i32,
-        }
-    }
-}
--- a/src/platform_impl/linux/x11/util/icon.rs
+++ b/src/platform_impl/linux/x11/util/icon.rs
@@ -1,36 +0,0 @@
-#![allow(clippy::assertions_on_constants)]
-
-use super::*;
-use crate::icon::{Pixel, RgbaIcon, PIXEL_SIZE};
-
-impl Pixel {
-    pub fn to_packed_argb(&self) -> Cardinal {
-        let mut cardinal = 0;
-        assert!(CARDINAL_SIZE >= PIXEL_SIZE);
-        let as_bytes = &mut cardinal as *mut _ as *mut u8;
-        unsafe {
-            *as_bytes.offset(0) = self.b;
-            *as_bytes.offset(1) = self.g;
-            *as_bytes.offset(2) = self.r;
-            *as_bytes.offset(3) = self.a;
-        }
-        cardinal
-    }
-}
-
-impl RgbaIcon {
-    pub(crate) fn to_cardinals(&self) -> Vec<Cardinal> {
-        assert_eq!(self.rgba.len() % PIXEL_SIZE, 0);
-        let pixel_count = self.rgba.len() / PIXEL_SIZE;
-        assert_eq!(pixel_count, (self.width * self.height) as usize);
-        let mut data = Vec::with_capacity(pixel_count);
-        data.push(self.width as Cardinal);
-        data.push(self.height as Cardinal);
-        let pixels = self.rgba.as_ptr() as *const Pixel;
-        for pixel_index in 0..pixel_count {
-            let pixel = unsafe { &*pixels.add(pixel_index) };
-            data.push(pixel.to_packed_argb());
-        }
-        data
-    }
-}
--- a/src/platform_impl/web/error.rs
+++ b/src/platform_impl/web/error.rs
@@ -1,10 +0,0 @@
-use std::fmt;
-
-#[derive(Debug)]
-pub struct OsError(pub String);
-
-impl fmt::Display for OsError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", self.0)
-    }
-}
--- a/src/platform_impl/web/event_loop/mod.rs
+++ b/src/platform_impl/web/event_loop/mod.rs
@@ -1,86 +0,0 @@
-use super::{backend, HasMonitorPermissionFuture, MonitorPermissionFuture};
-use crate::application::ApplicationHandler;
-use crate::error::{EventLoopError, NotSupportedError};
-use crate::event_loop::ActiveEventLoop as RootActiveEventLoop;
-use crate::platform::web::{PollStrategy, WaitUntilStrategy};
-
-mod proxy;
-pub(crate) mod runner;
-mod state;
-mod window_target;
-
-pub(crate) use window_target::ActiveEventLoop;
-
-#[derive(Debug)]
-pub struct EventLoop {
-    elw: ActiveEventLoop,
-}
-
-#[derive(Default, Debug, Copy, Clone, PartialEq, Eq, Hash)]
-pub(crate) struct PlatformSpecificEventLoopAttributes {}
-
-impl EventLoop {
-    pub(crate) fn new(_: &PlatformSpecificEventLoopAttributes) -> Result<Self, EventLoopError> {
-        Ok(EventLoop { elw: ActiveEventLoop::new() })
-    }
-
-    pub fn run_app<A: ApplicationHandler>(self, app: A) -> ! {
-        let app = Box::new(app);
-
-        // SAFETY: The `transmute` is necessary because `run()` requires `'static`. This is safe
-        // because this function will never return and all resources not cleaned up by the point we
-        // `throw` will leak, making this actually `'static`.
-        let app = unsafe {
-            std::mem::transmute::<
-                Box<dyn ApplicationHandler + '_>,
-                Box<dyn ApplicationHandler + 'static>,
-            >(app)
-        };
-
-        self.elw.run(app, false);
-
-        // Throw an exception to break out of Rust execution and use unreachable to tell the
-        // compiler this function won't return, giving it a return type of '!'
-        backend::throw(
-            "Using exceptions for control flow, don't mind me. This isn't actually an error!",
-        );
-
-        unreachable!();
-    }
-
-    pub fn spawn_app<A: ApplicationHandler + 'static>(self, app: A) {
-        self.elw.run(Box::new(app), true);
-    }
-
-    pub fn window_target(&self) -> &dyn RootActiveEventLoop {
-        &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()
-    }
-
-    pub fn has_multiple_screens(&self) -> Result<bool, NotSupportedError> {
-        self.elw.has_multiple_screens()
-    }
-
-    pub(crate) fn request_detailed_monitor_permission(&self) -> MonitorPermissionFuture {
-        self.elw.request_detailed_monitor_permission()
-    }
-
-    pub fn has_detailed_monitor_permission(&self) -> HasMonitorPermissionFuture {
-        self.elw.runner.monitor().has_detailed_monitor_permission_async()
-    }
-}
--- a/src/platform_impl/web/keyboard.rs
+++ b/src/platform_impl/web/keyboard.rs
@@ -1,525 +0,0 @@
-use smol_str::SmolStr;
-
-use crate::keyboard::{Key, KeyCode, NamedKey, NativeKey, NativeKeyCode, PhysicalKey};
-
-impl Key {
-    pub(crate) fn from_key_attribute_value(kav: &str) -> Self {
-        Key::Named(match kav {
-            "Unidentified" => return Key::Unidentified(NativeKey::Web(SmolStr::new(kav))),
-            "Dead" => return Key::Dead(None),
-            "Alt" => NamedKey::Alt,
-            "AltGraph" => NamedKey::AltGraph,
-            "CapsLock" => NamedKey::CapsLock,
-            "Control" => NamedKey::Control,
-            "Fn" => NamedKey::Fn,
-            "FnLock" => NamedKey::FnLock,
-            "NumLock" => NamedKey::NumLock,
-            "ScrollLock" => NamedKey::ScrollLock,
-            "Shift" => NamedKey::Shift,
-            "Symbol" => NamedKey::Symbol,
-            "SymbolLock" => NamedKey::SymbolLock,
-            #[allow(deprecated)]
-            "Super" => NamedKey::Super,
-            #[allow(deprecated)]
-            "Hyper" => NamedKey::Hyper,
-            "Meta" => NamedKey::Meta,
-            "Enter" => NamedKey::Enter,
-            "Tab" => NamedKey::Tab,
-            "ArrowDown" => NamedKey::ArrowDown,
-            "ArrowLeft" => NamedKey::ArrowLeft,
-            "ArrowRight" => NamedKey::ArrowRight,
-            "ArrowUp" => NamedKey::ArrowUp,
-            "End" => NamedKey::End,
-            "Home" => NamedKey::Home,
-            "PageDown" => NamedKey::PageDown,
-            "PageUp" => NamedKey::PageUp,
-            "Backspace" => NamedKey::Backspace,
-            "Clear" => NamedKey::Clear,
-            "Copy" => NamedKey::Copy,
-            "CrSel" => NamedKey::CrSel,
-            "Cut" => NamedKey::Cut,
-            "Delete" => NamedKey::Delete,
-            "EraseEof" => NamedKey::EraseEof,
-            "ExSel" => NamedKey::ExSel,
-            "Insert" => NamedKey::Insert,
-            "Paste" => NamedKey::Paste,
-            "Redo" => NamedKey::Redo,
-            "Undo" => NamedKey::Undo,
-            "Accept" => NamedKey::Accept,
-            "Again" => NamedKey::Again,
-            "Attn" => NamedKey::Attn,
-            "Cancel" => NamedKey::Cancel,
-            "ContextMenu" => NamedKey::ContextMenu,
-            "Escape" => NamedKey::Escape,
-            "Execute" => NamedKey::Execute,
-            "Find" => NamedKey::Find,
-            "Help" => NamedKey::Help,
-            "Pause" => NamedKey::Pause,
-            "Play" => NamedKey::Play,
-            "Props" => NamedKey::Props,
-            "Select" => NamedKey::Select,
-            "ZoomIn" => NamedKey::ZoomIn,
-            "ZoomOut" => NamedKey::ZoomOut,
-            "BrightnessDown" => NamedKey::BrightnessDown,
-            "BrightnessUp" => NamedKey::BrightnessUp,
-            "Eject" => NamedKey::Eject,
-            "LogOff" => NamedKey::LogOff,
-            "Power" => NamedKey::Power,
-            "PowerOff" => NamedKey::PowerOff,
-            "PrintScreen" => NamedKey::PrintScreen,
-            "Hibernate" => NamedKey::Hibernate,
-            "Standby" => NamedKey::Standby,
-            "WakeUp" => NamedKey::WakeUp,
-            "AllCandidates" => NamedKey::AllCandidates,
-            "Alphanumeric" => NamedKey::Alphanumeric,
-            "CodeInput" => NamedKey::CodeInput,
-            "Compose" => NamedKey::Compose,
-            "Convert" => NamedKey::Convert,
-            "FinalMode" => NamedKey::FinalMode,
-            "GroupFirst" => NamedKey::GroupFirst,
-            "GroupLast" => NamedKey::GroupLast,
-            "GroupNext" => NamedKey::GroupNext,
-            "GroupPrevious" => NamedKey::GroupPrevious,
-            "ModeChange" => NamedKey::ModeChange,
-            "NextCandidate" => NamedKey::NextCandidate,
-            "NonConvert" => NamedKey::NonConvert,
-            "PreviousCandidate" => NamedKey::PreviousCandidate,
-            "Process" => NamedKey::Process,
-            "SingleCandidate" => NamedKey::SingleCandidate,
-            "HangulMode" => NamedKey::HangulMode,
-            "HanjaMode" => NamedKey::HanjaMode,
-            "JunjaMode" => NamedKey::JunjaMode,
-            "Eisu" => NamedKey::Eisu,
-            "Hankaku" => NamedKey::Hankaku,
-            "Hiragana" => NamedKey::Hiragana,
-            "HiraganaKatakana" => NamedKey::HiraganaKatakana,
-            "KanaMode" => NamedKey::KanaMode,
-            "KanjiMode" => NamedKey::KanjiMode,
-            "Katakana" => NamedKey::Katakana,
-            "Romaji" => NamedKey::Romaji,
-            "Zenkaku" => NamedKey::Zenkaku,
-            "ZenkakuHankaku" => NamedKey::ZenkakuHankaku,
-            "Soft1" => NamedKey::Soft1,
-            "Soft2" => NamedKey::Soft2,
-            "Soft3" => NamedKey::Soft3,
-            "Soft4" => NamedKey::Soft4,
-            "ChannelDown" => NamedKey::ChannelDown,
-            "ChannelUp" => NamedKey::ChannelUp,
-            "Close" => NamedKey::Close,
-            "MailForward" => NamedKey::MailForward,
-            "MailReply" => NamedKey::MailReply,
-            "MailSend" => NamedKey::MailSend,
-            "MediaClose" => NamedKey::MediaClose,
-            "MediaFastForward" => NamedKey::MediaFastForward,
-            "MediaPause" => NamedKey::MediaPause,
-            "MediaPlay" => NamedKey::MediaPlay,
-            "MediaPlayPause" => NamedKey::MediaPlayPause,
-            "MediaRecord" => NamedKey::MediaRecord,
-            "MediaRewind" => NamedKey::MediaRewind,
-            "MediaStop" => NamedKey::MediaStop,
-            "MediaTrackNext" => NamedKey::MediaTrackNext,
-            "MediaTrackPrevious" => NamedKey::MediaTrackPrevious,
-            "New" => NamedKey::New,
-            "Open" => NamedKey::Open,
-            "Print" => NamedKey::Print,
-            "Save" => NamedKey::Save,
-            "SpellCheck" => NamedKey::SpellCheck,
-            "Key11" => NamedKey::Key11,
-            "Key12" => NamedKey::Key12,
-            "AudioBalanceLeft" => NamedKey::AudioBalanceLeft,
-            "AudioBalanceRight" => NamedKey::AudioBalanceRight,
-            "AudioBassBoostDown" => NamedKey::AudioBassBoostDown,
-            "AudioBassBoostToggle" => NamedKey::AudioBassBoostToggle,
-            "AudioBassBoostUp" => NamedKey::AudioBassBoostUp,
-            "AudioFaderFront" => NamedKey::AudioFaderFront,
-            "AudioFaderRear" => NamedKey::AudioFaderRear,
-            "AudioSurroundModeNext" => NamedKey::AudioSurroundModeNext,
-            "AudioTrebleDown" => NamedKey::AudioTrebleDown,
-            "AudioTrebleUp" => NamedKey::AudioTrebleUp,
-            "AudioVolumeDown" => NamedKey::AudioVolumeDown,
-            "AudioVolumeUp" => NamedKey::AudioVolumeUp,
-            "AudioVolumeMute" => NamedKey::AudioVolumeMute,
-            "MicrophoneToggle" => NamedKey::MicrophoneToggle,
-            "MicrophoneVolumeDown" => NamedKey::MicrophoneVolumeDown,
-            "MicrophoneVolumeUp" => NamedKey::MicrophoneVolumeUp,
-            "MicrophoneVolumeMute" => NamedKey::MicrophoneVolumeMute,
-            "SpeechCorrectionList" => NamedKey::SpeechCorrectionList,
-            "SpeechInputToggle" => NamedKey::SpeechInputToggle,
-            "LaunchApplication1" => NamedKey::LaunchApplication1,
-            "LaunchApplication2" => NamedKey::LaunchApplication2,
-            "LaunchCalendar" => NamedKey::LaunchCalendar,
-            "LaunchContacts" => NamedKey::LaunchContacts,
-            "LaunchMail" => NamedKey::LaunchMail,
-            "LaunchMediaPlayer" => NamedKey::LaunchMediaPlayer,
-            "LaunchMusicPlayer" => NamedKey::LaunchMusicPlayer,
-            "LaunchPhone" => NamedKey::LaunchPhone,
-            "LaunchScreenSaver" => NamedKey::LaunchScreenSaver,
-            "LaunchSpreadsheet" => NamedKey::LaunchSpreadsheet,
-            "LaunchWebBrowser" => NamedKey::LaunchWebBrowser,
-            "LaunchWebCam" => NamedKey::LaunchWebCam,
-            "LaunchWordProcessor" => NamedKey::LaunchWordProcessor,
-            "BrowserBack" => NamedKey::BrowserBack,
-            "BrowserFavorites" => NamedKey::BrowserFavorites,
-            "BrowserForward" => NamedKey::BrowserForward,
-            "BrowserHome" => NamedKey::BrowserHome,
-            "BrowserRefresh" => NamedKey::BrowserRefresh,
-            "BrowserSearch" => NamedKey::BrowserSearch,
-            "BrowserStop" => NamedKey::BrowserStop,
-            "AppSwitch" => NamedKey::AppSwitch,
-            "Call" => NamedKey::Call,
-            "Camera" => NamedKey::Camera,
-            "CameraFocus" => NamedKey::CameraFocus,
-            "EndCall" => NamedKey::EndCall,
-            "GoBack" => NamedKey::GoBack,
-            "GoHome" => NamedKey::GoHome,
-            "HeadsetHook" => NamedKey::HeadsetHook,
-            "LastNumberRedial" => NamedKey::LastNumberRedial,
-            "Notification" => NamedKey::Notification,
-            "MannerMode" => NamedKey::MannerMode,
-            "VoiceDial" => NamedKey::VoiceDial,
-            "TV" => NamedKey::TV,
-            "TV3DMode" => NamedKey::TV3DMode,
-            "TVAntennaCable" => NamedKey::TVAntennaCable,
-            "TVAudioDescription" => NamedKey::TVAudioDescription,
-            "TVAudioDescriptionMixDown" => NamedKey::TVAudioDescriptionMixDown,
-            "TVAudioDescriptionMixUp" => NamedKey::TVAudioDescriptionMixUp,
-            "TVContentsMenu" => NamedKey::TVContentsMenu,
-            "TVDataService" => NamedKey::TVDataService,
-            "TVInput" => NamedKey::TVInput,
-            "TVInputComponent1" => NamedKey::TVInputComponent1,
-            "TVInputComponent2" => NamedKey::TVInputComponent2,
-            "TVInputComposite1" => NamedKey::TVInputComposite1,
-            "TVInputComposite2" => NamedKey::TVInputComposite2,
-            "TVInputHDMI1" => NamedKey::TVInputHDMI1,
-            "TVInputHDMI2" => NamedKey::TVInputHDMI2,
-            "TVInputHDMI3" => NamedKey::TVInputHDMI3,
-            "TVInputHDMI4" => NamedKey::TVInputHDMI4,
-            "TVInputVGA1" => NamedKey::TVInputVGA1,
-            "TVMediaContext" => NamedKey::TVMediaContext,
-            "TVNetwork" => NamedKey::TVNetwork,
-            "TVNumberEntry" => NamedKey::TVNumberEntry,
-            "TVPower" => NamedKey::TVPower,
-            "TVRadioService" => NamedKey::TVRadioService,
-            "TVSatellite" => NamedKey::TVSatellite,
-            "TVSatelliteBS" => NamedKey::TVSatelliteBS,
-            "TVSatelliteCS" => NamedKey::TVSatelliteCS,
-            "TVSatelliteToggle" => NamedKey::TVSatelliteToggle,
-            "TVTerrestrialAnalog" => NamedKey::TVTerrestrialAnalog,
-            "TVTerrestrialDigital" => NamedKey::TVTerrestrialDigital,
-            "TVTimer" => NamedKey::TVTimer,
-            "AVRInput" => NamedKey::AVRInput,
-            "AVRPower" => NamedKey::AVRPower,
-            "ColorF0Red" => NamedKey::ColorF0Red,
-            "ColorF1Green" => NamedKey::ColorF1Green,
-            "ColorF2Yellow" => NamedKey::ColorF2Yellow,
-            "ColorF3Blue" => NamedKey::ColorF3Blue,
-            "ColorF4Grey" => NamedKey::ColorF4Grey,
-            "ColorF5Brown" => NamedKey::ColorF5Brown,
-            "ClosedCaptionToggle" => NamedKey::ClosedCaptionToggle,
-            "Dimmer" => NamedKey::Dimmer,
-            "DisplaySwap" => NamedKey::DisplaySwap,
-            "DVR" => NamedKey::DVR,
-            "Exit" => NamedKey::Exit,
-            "FavoriteClear0" => NamedKey::FavoriteClear0,
-            "FavoriteClear1" => NamedKey::FavoriteClear1,
-            "FavoriteClear2" => NamedKey::FavoriteClear2,
-            "FavoriteClear3" => NamedKey::FavoriteClear3,
-            "FavoriteRecall0" => NamedKey::FavoriteRecall0,
-            "FavoriteRecall1" => NamedKey::FavoriteRecall1,
-            "FavoriteRecall2" => NamedKey::FavoriteRecall2,
-            "FavoriteRecall3" => NamedKey::FavoriteRecall3,
-            "FavoriteStore0" => NamedKey::FavoriteStore0,
-            "FavoriteStore1" => NamedKey::FavoriteStore1,
-            "FavoriteStore2" => NamedKey::FavoriteStore2,
-            "FavoriteStore3" => NamedKey::FavoriteStore3,
-            "Guide" => NamedKey::Guide,
-            "GuideNextDay" => NamedKey::GuideNextDay,
-            "GuidePreviousDay" => NamedKey::GuidePreviousDay,
-            "Info" => NamedKey::Info,
-            "InstantReplay" => NamedKey::InstantReplay,
-            "Link" => NamedKey::Link,
-            "ListProgram" => NamedKey::ListProgram,
-            "LiveContent" => NamedKey::LiveContent,
-            "Lock" => NamedKey::Lock,
-            "MediaApps" => NamedKey::MediaApps,
-            "MediaAudioTrack" => NamedKey::MediaAudioTrack,
-            "MediaLast" => NamedKey::MediaLast,
-            "MediaSkipBackward" => NamedKey::MediaSkipBackward,
-            "MediaSkipForward" => NamedKey::MediaSkipForward,
-            "MediaStepBackward" => NamedKey::MediaStepBackward,
-            "MediaStepForward" => NamedKey::MediaStepForward,
-            "MediaTopMenu" => NamedKey::MediaTopMenu,
-            "NavigateIn" => NamedKey::NavigateIn,
-            "NavigateNext" => NamedKey::NavigateNext,
-            "NavigateOut" => NamedKey::NavigateOut,
-            "NavigatePrevious" => NamedKey::NavigatePrevious,
-            "NextFavoriteChannel" => NamedKey::NextFavoriteChannel,
-            "NextUserProfile" => NamedKey::NextUserProfile,
-            "OnDemand" => NamedKey::OnDemand,
-            "Pairing" => NamedKey::Pairing,
-            "PinPDown" => NamedKey::PinPDown,
-            "PinPMove" => NamedKey::PinPMove,
-            "PinPToggle" => NamedKey::PinPToggle,
-            "PinPUp" => NamedKey::PinPUp,
-            "PlaySpeedDown" => NamedKey::PlaySpeedDown,
-            "PlaySpeedReset" => NamedKey::PlaySpeedReset,
-            "PlaySpeedUp" => NamedKey::PlaySpeedUp,
-            "RandomToggle" => NamedKey::RandomToggle,
-            "RcLowBattery" => NamedKey::RcLowBattery,
-            "RecordSpeedNext" => NamedKey::RecordSpeedNext,
-            "RfBypass" => NamedKey::RfBypass,
-            "ScanChannelsToggle" => NamedKey::ScanChannelsToggle,
-            "ScreenModeNext" => NamedKey::ScreenModeNext,
-            "Settings" => NamedKey::Settings,
-            "SplitScreenToggle" => NamedKey::SplitScreenToggle,
-            "STBInput" => NamedKey::STBInput,
-            "STBPower" => NamedKey::STBPower,
-            "Subtitle" => NamedKey::Subtitle,
-            "Teletext" => NamedKey::Teletext,
-            "VideoModeNext" => NamedKey::VideoModeNext,
-            "Wink" => NamedKey::Wink,
-            "ZoomToggle" => NamedKey::ZoomToggle,
-            "F1" => NamedKey::F1,
-            "F2" => NamedKey::F2,
-            "F3" => NamedKey::F3,
-            "F4" => NamedKey::F4,
-            "F5" => NamedKey::F5,
-            "F6" => NamedKey::F6,
-            "F7" => NamedKey::F7,
-            "F8" => NamedKey::F8,
-            "F9" => NamedKey::F9,
-            "F10" => NamedKey::F10,
-            "F11" => NamedKey::F11,
-            "F12" => NamedKey::F12,
-            "F13" => NamedKey::F13,
-            "F14" => NamedKey::F14,
-            "F15" => NamedKey::F15,
-            "F16" => NamedKey::F16,
-            "F17" => NamedKey::F17,
-            "F18" => NamedKey::F18,
-            "F19" => NamedKey::F19,
-            "F20" => NamedKey::F20,
-            "F21" => NamedKey::F21,
-            "F22" => NamedKey::F22,
-            "F23" => NamedKey::F23,
-            "F24" => NamedKey::F24,
-            "F25" => NamedKey::F25,
-            "F26" => NamedKey::F26,
-            "F27" => NamedKey::F27,
-            "F28" => NamedKey::F28,
-            "F29" => NamedKey::F29,
-            "F30" => NamedKey::F30,
-            "F31" => NamedKey::F31,
-            "F32" => NamedKey::F32,
-            "F33" => NamedKey::F33,
-            "F34" => NamedKey::F34,
-            "F35" => NamedKey::F35,
-            string => return Key::Character(SmolStr::new(string)),
-        })
-    }
-}
-
-impl PhysicalKey {
-    pub fn from_key_code_attribute_value(kcav: &str) -> Self {
-        PhysicalKey::Code(match kcav {
-            "Backquote" => KeyCode::Backquote,
-            "Backslash" => KeyCode::Backslash,
-            "BracketLeft" => KeyCode::BracketLeft,
-            "BracketRight" => KeyCode::BracketRight,
-            "Comma" => KeyCode::Comma,
-            "Digit0" => KeyCode::Digit0,
-            "Digit1" => KeyCode::Digit1,
-            "Digit2" => KeyCode::Digit2,
-            "Digit3" => KeyCode::Digit3,
-            "Digit4" => KeyCode::Digit4,
-            "Digit5" => KeyCode::Digit5,
-            "Digit6" => KeyCode::Digit6,
-            "Digit7" => KeyCode::Digit7,
-            "Digit8" => KeyCode::Digit8,
-            "Digit9" => KeyCode::Digit9,
-            "Equal" => KeyCode::Equal,
-            "IntlBackslash" => KeyCode::IntlBackslash,
-            "IntlRo" => KeyCode::IntlRo,
-            "IntlYen" => KeyCode::IntlYen,
-            "KeyA" => KeyCode::KeyA,
-            "KeyB" => KeyCode::KeyB,
-            "KeyC" => KeyCode::KeyC,
-            "KeyD" => KeyCode::KeyD,
-            "KeyE" => KeyCode::KeyE,
-            "KeyF" => KeyCode::KeyF,
-            "KeyG" => KeyCode::KeyG,
-            "KeyH" => KeyCode::KeyH,
-            "KeyI" => KeyCode::KeyI,
-            "KeyJ" => KeyCode::KeyJ,
-            "KeyK" => KeyCode::KeyK,
-            "KeyL" => KeyCode::KeyL,
-            "KeyM" => KeyCode::KeyM,
-            "KeyN" => KeyCode::KeyN,
-            "KeyO" => KeyCode::KeyO,
-            "KeyP" => KeyCode::KeyP,
-            "KeyQ" => KeyCode::KeyQ,
-            "KeyR" => KeyCode::KeyR,
-            "KeyS" => KeyCode::KeyS,
-            "KeyT" => KeyCode::KeyT,
-            "KeyU" => KeyCode::KeyU,
-            "KeyV" => KeyCode::KeyV,
-            "KeyW" => KeyCode::KeyW,
-            "KeyX" => KeyCode::KeyX,
-            "KeyY" => KeyCode::KeyY,
-            "KeyZ" => KeyCode::KeyZ,
-            "Minus" => KeyCode::Minus,
-            "Period" => KeyCode::Period,
-            "Quote" => KeyCode::Quote,
-            "Semicolon" => KeyCode::Semicolon,
-            "Slash" => KeyCode::Slash,
-            "AltLeft" => KeyCode::AltLeft,
-            "AltRight" => KeyCode::AltRight,
-            "Backspace" => KeyCode::Backspace,
-            "CapsLock" => KeyCode::CapsLock,
-            "ContextMenu" => KeyCode::ContextMenu,
-            "ControlLeft" => KeyCode::ControlLeft,
-            "ControlRight" => KeyCode::ControlRight,
-            "Enter" => KeyCode::Enter,
-            "MetaLeft" => KeyCode::MetaLeft,
-            "MetaRight" => KeyCode::MetaRight,
-            "ShiftLeft" => KeyCode::ShiftLeft,
-            "ShiftRight" => KeyCode::ShiftRight,
-            "Space" => KeyCode::Space,
-            "Tab" => KeyCode::Tab,
-            "Convert" => KeyCode::Convert,
-            "KanaMode" => KeyCode::KanaMode,
-            "Lang1" => KeyCode::Lang1,
-            "Lang2" => KeyCode::Lang2,
-            "Lang3" => KeyCode::Lang3,
-            "Lang4" => KeyCode::Lang4,
-            "Lang5" => KeyCode::Lang5,
-            "NonConvert" => KeyCode::NonConvert,
-            "Delete" => KeyCode::Delete,
-            "End" => KeyCode::End,
-            "Help" => KeyCode::Help,
-            "Home" => KeyCode::Home,
-            "Insert" => KeyCode::Insert,
-            "PageDown" => KeyCode::PageDown,
-            "PageUp" => KeyCode::PageUp,
-            "ArrowDown" => KeyCode::ArrowDown,
-            "ArrowLeft" => KeyCode::ArrowLeft,
-            "ArrowRight" => KeyCode::ArrowRight,
-            "ArrowUp" => KeyCode::ArrowUp,
-            "NumLock" => KeyCode::NumLock,
-            "Numpad0" => KeyCode::Numpad0,
-            "Numpad1" => KeyCode::Numpad1,
-            "Numpad2" => KeyCode::Numpad2,
-            "Numpad3" => KeyCode::Numpad3,
-            "Numpad4" => KeyCode::Numpad4,
-            "Numpad5" => KeyCode::Numpad5,
-            "Numpad6" => KeyCode::Numpad6,
-            "Numpad7" => KeyCode::Numpad7,
-            "Numpad8" => KeyCode::Numpad8,
-            "Numpad9" => KeyCode::Numpad9,
-            "NumpadAdd" => KeyCode::NumpadAdd,
-            "NumpadBackspace" => KeyCode::NumpadBackspace,
-            "NumpadClear" => KeyCode::NumpadClear,
-            "NumpadClearEntry" => KeyCode::NumpadClearEntry,
-            "NumpadComma" => KeyCode::NumpadComma,
-            "NumpadDecimal" => KeyCode::NumpadDecimal,
-            "NumpadDivide" => KeyCode::NumpadDivide,
-            "NumpadEnter" => KeyCode::NumpadEnter,
-            "NumpadEqual" => KeyCode::NumpadEqual,
-            "NumpadHash" => KeyCode::NumpadHash,
-            "NumpadMemoryAdd" => KeyCode::NumpadMemoryAdd,
-            "NumpadMemoryClear" => KeyCode::NumpadMemoryClear,
-            "NumpadMemoryRecall" => KeyCode::NumpadMemoryRecall,
-            "NumpadMemoryStore" => KeyCode::NumpadMemoryStore,
-            "NumpadMemorySubtract" => KeyCode::NumpadMemorySubtract,
-            "NumpadMultiply" => KeyCode::NumpadMultiply,
-            "NumpadParenLeft" => KeyCode::NumpadParenLeft,
-            "NumpadParenRight" => KeyCode::NumpadParenRight,
-            "NumpadStar" => KeyCode::NumpadStar,
-            "NumpadSubtract" => KeyCode::NumpadSubtract,
-            "Escape" => KeyCode::Escape,
-            "Fn" => KeyCode::Fn,
-            "FnLock" => KeyCode::FnLock,
-            "PrintScreen" => KeyCode::PrintScreen,
-            "ScrollLock" => KeyCode::ScrollLock,
-            "Pause" => KeyCode::Pause,
-            "BrowserBack" => KeyCode::BrowserBack,
-            "BrowserFavorites" => KeyCode::BrowserFavorites,
-            "BrowserForward" => KeyCode::BrowserForward,
-            "BrowserHome" => KeyCode::BrowserHome,
-            "BrowserRefresh" => KeyCode::BrowserRefresh,
-            "BrowserSearch" => KeyCode::BrowserSearch,
-            "BrowserStop" => KeyCode::BrowserStop,
-            "Eject" => KeyCode::Eject,
-            "LaunchApp1" => KeyCode::LaunchApp1,
-            "LaunchApp2" => KeyCode::LaunchApp2,
-            "LaunchMail" => KeyCode::LaunchMail,
-            "MediaPlayPause" => KeyCode::MediaPlayPause,
-            "MediaSelect" => KeyCode::MediaSelect,
-            "MediaStop" => KeyCode::MediaStop,
-            "MediaTrackNext" => KeyCode::MediaTrackNext,
-            "MediaTrackPrevious" => KeyCode::MediaTrackPrevious,
-            "Power" => KeyCode::Power,
-            "Sleep" => KeyCode::Sleep,
-            "AudioVolumeDown" => KeyCode::AudioVolumeDown,
-            "AudioVolumeMute" => KeyCode::AudioVolumeMute,
-            "AudioVolumeUp" => KeyCode::AudioVolumeUp,
-            "WakeUp" => KeyCode::WakeUp,
-            #[allow(deprecated)]
-            "Super" => KeyCode::Super,
-            #[allow(deprecated)]
-            "Hyper" => KeyCode::Hyper,
-            #[allow(deprecated)]
-            "Turbo" => KeyCode::Turbo,
-            "Abort" => KeyCode::Abort,
-            "Resume" => KeyCode::Resume,
-            "Suspend" => KeyCode::Suspend,
-            "Again" => KeyCode::Again,
-            "Copy" => KeyCode::Copy,
-            "Cut" => KeyCode::Cut,
-            "Find" => KeyCode::Find,
-            "Open" => KeyCode::Open,
-            "Paste" => KeyCode::Paste,
-            "Props" => KeyCode::Props,
-            "Select" => KeyCode::Select,
-            "Undo" => KeyCode::Undo,
-            "Hiragana" => KeyCode::Hiragana,
-            "Katakana" => KeyCode::Katakana,
-            "F1" => KeyCode::F1,
-            "F2" => KeyCode::F2,
-            "F3" => KeyCode::F3,
-            "F4" => KeyCode::F4,
-            "F5" => KeyCode::F5,
-            "F6" => KeyCode::F6,
-            "F7" => KeyCode::F7,
-            "F8" => KeyCode::F8,
-            "F9" => KeyCode::F9,
-            "F10" => KeyCode::F10,
-            "F11" => KeyCode::F11,
-            "F12" => KeyCode::F12,
-            "F13" => KeyCode::F13,
-            "F14" => KeyCode::F14,
-            "F15" => KeyCode::F15,
-            "F16" => KeyCode::F16,
-            "F17" => KeyCode::F17,
-            "F18" => KeyCode::F18,
-            "F19" => KeyCode::F19,
-            "F20" => KeyCode::F20,
-            "F21" => KeyCode::F21,
-            "F22" => KeyCode::F22,
-            "F23" => KeyCode::F23,
-            "F24" => KeyCode::F24,
-            "F25" => KeyCode::F25,
-            "F26" => KeyCode::F26,
-            "F27" => KeyCode::F27,
-            "F28" => KeyCode::F28,
-            "F29" => KeyCode::F29,
-            "F30" => KeyCode::F30,
-            "F31" => KeyCode::F31,
-            "F32" => KeyCode::F32,
-            "F33" => KeyCode::F33,
-            "F34" => KeyCode::F34,
-            "F35" => KeyCode::F35,
-            _ => return PhysicalKey::Unidentified(NativeKeyCode::Unidentified),
-        })
-    }
-}
--- a/src/platform_impl/web/mod.rs
+++ b/src/platform_impl/web/mod.rs
@@ -1,44 +0,0 @@
-// Brief introduction to the internals of the Web backend:
-// The Web backend used to support both wasm-bindgen and stdweb as methods of binding to the
-// environment. Because they are both supporting the same underlying APIs, the actual Web bindings
-// are cordoned off into backend abstractions, which present the thinnest unifying layer possible.
-//
-// When adding support for new events or interactions with the browser, first consult trusted
-// documentation (such as MDN) to ensure it is well-standardised and supported across many browsers.
-// Once you have decided on the relevant Web APIs, add support to both backends.
-//
-// The backend is used by the rest of the module to implement Winit's business logic, which forms
-// the rest of the code. 'device', 'error', 'monitor', and 'window' define Web-specific structures
-// for winit's cross-platform structures. They are all relatively simple translations.
-//
-// The event_loop module handles listening for and processing events. 'Proxy' implements
-// EventLoopProxy and 'WindowTarget' implements ActiveEventLoop. WindowTarget also handles
-// registering the event handlers. The 'Execution' struct in the 'runner' module handles taking
-// 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-clippy/issues/12377> is fixed.
-#![allow(clippy::empty_docs)]
-
-mod r#async;
-mod cursor;
-mod error;
-mod event;
-mod event_loop;
-mod keyboard;
-mod lock;
-mod main_thread;
-mod monitor;
-mod web_sys;
-mod window;
-
-pub(crate) use cursor::CustomCursorFuture;
-
-pub(crate) use self::event_loop::{
-    ActiveEventLoop, EventLoop, PlatformSpecificEventLoopAttributes,
-};
-pub(crate) use self::monitor::{
-    HasMonitorPermissionFuture, MonitorHandle, MonitorPermissionFuture, OrientationLockFuture,
-};
-use self::web_sys as backend;
-pub use self::window::{PlatformSpecificWindowAttributes, Window};
--- a/src/platform_impl/windows/mod.rs
+++ b/src/platform_impl/windows/mod.rs
@@ -1,126 +0,0 @@
-use windows_sys::Win32::Foundation::HWND;
-use windows_sys::Win32::UI::WindowsAndMessaging::{HMENU, WINDOW_LONG_PTR_INDEX};
-
-pub(crate) use self::event_loop::{EventLoop, PlatformSpecificEventLoopAttributes};
-pub(crate) use self::icon::{RaiiIcon, SelectedCursor};
-pub(crate) use self::keyboard::{physicalkey_to_scancode, scancode_to_physicalkey};
-pub(crate) use self::monitor::MonitorHandle;
-pub(crate) use self::window::Window;
-use crate::event::DeviceId;
-use crate::icon::Icon;
-use crate::platform::windows::{BackdropType, Color, CornerPreference};
-
-#[derive(Clone, Debug)]
-pub struct PlatformSpecificWindowAttributes {
-    pub owner: Option<HWND>,
-    pub menu: Option<HMENU>,
-    pub taskbar_icon: Option<Icon>,
-    pub no_redirection_bitmap: bool,
-    pub drag_and_drop: bool,
-    pub skip_taskbar: bool,
-    pub class_name: String,
-    pub decoration_shadow: bool,
-    pub backdrop_type: BackdropType,
-    pub clip_children: bool,
-    pub border_color: Option<Color>,
-    pub title_background_color: Option<Color>,
-    pub title_text_color: Option<Color>,
-    pub corner_preference: Option<CornerPreference>,
-}
-
-impl Default for PlatformSpecificWindowAttributes {
-    fn default() -> Self {
-        Self {
-            owner: None,
-            menu: None,
-            taskbar_icon: None,
-            no_redirection_bitmap: false,
-            drag_and_drop: true,
-            skip_taskbar: false,
-            class_name: "Window Class".to_string(),
-            decoration_shadow: false,
-            backdrop_type: BackdropType::default(),
-            clip_children: true,
-            border_color: None,
-            title_background_color: None,
-            title_text_color: None,
-            corner_preference: None,
-        }
-    }
-}
-
-unsafe impl Send for PlatformSpecificWindowAttributes {}
-unsafe impl Sync for PlatformSpecificWindowAttributes {}
-
-fn wrap_device_id(id: u32) -> DeviceId {
-    DeviceId::from_raw(id as i64)
-}
-
-#[inline(always)]
-const fn get_xbutton_wparam(x: u32) -> u16 {
-    hiword(x)
-}
-
-#[inline(always)]
-const fn get_x_lparam(x: u32) -> i16 {
-    loword(x) as _
-}
-
-#[inline(always)]
-const fn get_y_lparam(x: u32) -> i16 {
-    hiword(x) as _
-}
-
-#[inline(always)]
-pub(crate) const fn primarylangid(lgid: u16) -> u16 {
-    lgid & 0x3ff
-}
-
-#[inline(always)]
-pub(crate) const fn loword(x: u32) -> u16 {
-    (x & 0xffff) as u16
-}
-
-#[inline(always)]
-const fn hiword(x: u32) -> u16 {
-    ((x >> 16) & 0xffff) as u16
-}
-
-#[inline(always)]
-unsafe fn get_window_long(hwnd: HWND, nindex: WINDOW_LONG_PTR_INDEX) -> isize {
-    #[cfg(target_pointer_width = "64")]
-    return unsafe { windows_sys::Win32::UI::WindowsAndMessaging::GetWindowLongPtrW(hwnd, nindex) };
-    #[cfg(target_pointer_width = "32")]
-    return unsafe {
-        windows_sys::Win32::UI::WindowsAndMessaging::GetWindowLongW(hwnd, nindex) as isize
-    };
-}
-
-#[inline(always)]
-unsafe fn set_window_long(hwnd: HWND, nindex: WINDOW_LONG_PTR_INDEX, dwnewlong: isize) -> isize {
-    #[cfg(target_pointer_width = "64")]
-    return unsafe {
-        windows_sys::Win32::UI::WindowsAndMessaging::SetWindowLongPtrW(hwnd, nindex, dwnewlong)
-    };
-    #[cfg(target_pointer_width = "32")]
-    return unsafe {
-        windows_sys::Win32::UI::WindowsAndMessaging::SetWindowLongW(hwnd, nindex, dwnewlong as i32)
-            as isize
-    };
-}
-
-#[macro_use]
-mod util;
-mod dark_mode;
-mod definitions;
-mod dpi;
-mod drop_handler;
-mod event_loop;
-mod icon;
-mod ime;
-mod keyboard;
-mod keyboard_layout;
-mod monitor;
-pub(crate) mod raw_input;
-mod window;
-mod window_state;
--- a/winit-android/Cargo.toml
+++ b/winit-android/Cargo.toml
@@ -0,0 +1,35 @@
+[package]
+description = "Winit's Android backend"
+documentation = "https://docs.rs/winit-android"
+edition.workspace = true
+license.workspace = true
+name = "winit-android"
+repository.workspace = true
+rust-version.workspace = true
+version.workspace = true
+
+[features]
+game-activity = ["android-activity/game-activity"]
+native-activity = ["android-activity/native-activity"]
+serde = ["dep:serde", "bitflags/serde", "smol_str/serde", "dpi/serde", "winit-core/serde"]
+
+[dependencies]
+bitflags.workspace = true
+dpi.workspace = true
+rwh_06.workspace = true
+serde = { workspace = true, optional = true }
+smol_str.workspace = true
+tracing.workspace = true
+winit-core.workspace = true
+
+# Platform-specific
+[target.'cfg(target_os = "android")'.dependencies]
+android-activity.workspace = true
+ndk.workspace = true
+
+[dev-dependencies]
+winit.workspace = true
+
+[package.metadata.docs.rs]
+features = ["serde", "native-activity"]
+targets = ["aarch64-linux-android"]
--- a/winit-android/LICENSE
+++ b/winit-android/LICENSE
@@ -0,0 +1 @@
+../LICENSE
--- a/winit-android/README.md
+++ b/winit-android/README.md
@@ -0,0 +1 @@
+../README.md
--- a/src/platform_impl/android/mod.rs
+++ b/src/platform_impl/android/mod.rs
@@ -1,4 +1,5 @@
 use std::cell::Cell;
+use std::fmt;
 use std::hash::Hash;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Mutex};
@@ -8,26 +9,26 @@ use android_activity::input::{InputEvent, KeyAction, Keycode, MotionAction};
 use android_activity::{
    AndroidApp, AndroidAppWaker, ConfigurationRef, InputStatus, MainEvent, Rect,
 };
+use dpi::{PhysicalInsets, PhysicalPosition, PhysicalSize, Position, Size};
 use tracing::{debug, trace, warn};
-
-use crate::application::ApplicationHandler;
-use crate::cursor::Cursor;
-use crate::dpi::{PhysicalInsets, PhysicalPosition, PhysicalSize, Position, Size};
-use crate::error::{EventLoopError, NotSupportedError, RequestError};
-use crate::event::{self, DeviceId, FingerId, Force, StartCause, SurfaceSizeWriter};
-use crate::event_loop::{
+use winit_core::application::ApplicationHandler;
+use winit_core::cursor::{Cursor, CustomCursor, CustomCursorSource};
+use winit_core::error::{EventLoopError, NotSupportedError, RequestError};
+use winit_core::event::{self, DeviceId, FingerId, Force, StartCause, SurfaceSizeWriter};
+use winit_core::event_loop::pump_events::PumpStatus;
+use winit_core::event_loop::{
    ActiveEventLoop as RootActiveEventLoop, ControlFlow, DeviceEvents,
    EventLoopProxy as CoreEventLoopProxy, EventLoopProxyProvider,
    OwnedDisplayHandle as CoreOwnedDisplayHandle,
 };
-use crate::monitor::{Fullscreen, MonitorHandle as CoreMonitorHandle};
-use crate::platform::pump_events::PumpStatus;
-use crate::window::{
-    self, CursorGrabMode, CustomCursor, CustomCursorSource, ImePurpose, ResizeDirection, Theme,
-    Window as CoreWindow, WindowAttributes, WindowButtons, WindowId, WindowLevel,
+use winit_core::monitor::{Fullscreen, MonitorHandle as CoreMonitorHandle};
+use winit_core::window::{
+    self, CursorGrabMode, ImeCapabilities, ImePurpose, ImeRequest, ImeRequestError,
+    ResizeDirection, Theme, Window as CoreWindow, WindowAttributes, WindowButtons, WindowId,
+    WindowLevel,
 };

-mod keycodes;
+use crate::keycodes;

 static HAS_FOCUS: AtomicBool = AtomicBool::new(true);

@@ -43,7 +44,7 @@ struct SharedFlagSetter {
    flag: Arc<AtomicBool>,
 }
 impl SharedFlagSetter {
-    pub fn set(&self) -> bool {
+    fn set(&self) -> bool {
        self.flag.compare_exchange(false, true, Ordering::AcqRel, Ordering::Relaxed).is_ok()
    }
 }
@@ -58,21 +59,21 @@ struct SharedFlag {
 // we just need to know at the start of a main loop iteration if a redraw
 // was queued and be able to read and clear the state atomically)
 impl SharedFlag {
-    pub fn new() -> Self {
+    fn new() -> Self {
        Self { flag: Arc::new(AtomicBool::new(false)) }
    }

-    pub fn setter(&self) -> SharedFlagSetter {
+    fn setter(&self) -> SharedFlagSetter {
        SharedFlagSetter { flag: self.flag.clone() }
    }

-    pub fn get_and_reset(&self) -> bool {
+    fn get_and_reset(&self) -> bool {
        self.flag.swap(false, std::sync::atomic::Ordering::AcqRel)
    }
 }

 #[derive(Clone)]
-pub struct RedrawRequester {
+struct RedrawRequester {
    flag: SharedFlagSetter,
    waker: AndroidAppWaker,
 }
@@ -88,7 +89,7 @@ impl RedrawRequester {
        RedrawRequester { flag: flag.setter(), waker }
    }

-    pub fn request_redraw(&self) {
+    fn request_redraw(&self) {
        if self.flag.set() {
            // Only explicitly try to wake up the main loop when the flag
            // value changes
@@ -99,7 +100,7 @@ impl RedrawRequester {

 #[derive(Debug)]
 pub struct EventLoop {
-    pub(crate) android_app: AndroidApp,
+    pub android_app: AndroidApp,
    window_target: ActiveEventLoop,
    redraw_flag: SharedFlag,
    loop_running: bool, // Dispatched `NewEvents<Init>`
@@ -112,9 +113,9 @@ pub struct EventLoop {
 }

 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub(crate) struct PlatformSpecificEventLoopAttributes {
-    pub(crate) android_app: Option<AndroidApp>,
-    pub(crate) ignore_volume_keys: bool,
+pub struct PlatformSpecificEventLoopAttributes {
+    pub android_app: Option<AndroidApp>,
+    pub ignore_volume_keys: bool,
 }

 impl Default for PlatformSpecificEventLoopAttributes {
@@ -127,9 +128,13 @@ impl Default for PlatformSpecificEventLoopAttributes {
 const GLOBAL_WINDOW: WindowId = WindowId::from_raw(0);

 impl EventLoop {
-    pub(crate) fn new(
-        attributes: &PlatformSpecificEventLoopAttributes,
-    ) -> Result<Self, EventLoopError> {
+    pub fn new(attributes: &PlatformSpecificEventLoopAttributes) -> Result<Self, EventLoopError> {
+        static EVENT_LOOP_CREATED: AtomicBool = AtomicBool::new(false);
+        if EVENT_LOOP_CREATED.swap(true, Ordering::Relaxed) {
+            // For better cross-platformness.
+            return Err(EventLoopError::RecreationAttempt);
+        }
+
        let android_app = attributes.android_app.as_ref().expect(
            "An `AndroidApp` as passed to android_main() is required to create an `EventLoop` on \
             Android",
@@ -159,7 +164,7 @@ impl EventLoop {
        })
    }

-    pub(crate) fn window_target(&self) -> &dyn RootActiveEventLoop {
+    pub fn window_target(&self) -> &dyn RootActiveEventLoop {
        &self.window_target
    }

@@ -495,10 +500,6 @@ impl EventLoop {
        input_status
    }

-    pub fn run_app<A: ApplicationHandler>(mut self, app: A) -> Result<(), EventLoopError> {
-        self.run_app_on_demand(app)
-    }
-
    pub fn run_app_on_demand<A: ApplicationHandler>(
        &mut self,
        mut app: A,
@@ -752,8 +753,9 @@ impl rwh_06::HasDisplayHandle for OwnedDisplayHandle {
 pub struct PlatformSpecificWindowAttributes;

 #[derive(Debug)]
-pub(crate) struct Window {
+pub struct Window {
    app: AndroidApp,
+    ime_capabilities: Mutex<Option<ImeCapabilities>>,
    redraw_requester: RedrawRequester,
 }

@@ -764,14 +766,18 @@ impl Window {
    ) -> Result<Self, RequestError> {
        // FIXME this ignores requested window attributes

-        Ok(Self { app: el.app.clone(), redraw_requester: el.redraw_requester.clone() })
+        Ok(Self {
+            app: el.app.clone(),
+            ime_capabilities: Default::default(),
+            redraw_requester: el.redraw_requester.clone(),
+        })
    }

-    pub fn config(&self) -> ConfigurationRef {
+    pub(crate) fn config(&self) -> ConfigurationRef {
        self.app.config()
    }

-    pub fn content_rect(&self) -> Rect {
+    pub(crate) fn content_rect(&self) -> Rect {
        self.app.content_rect()
    }

@@ -928,16 +934,37 @@ impl CoreWindow for Window {

    fn set_window_level(&self, _level: WindowLevel) {}

-    fn set_window_icon(&self, _window_icon: Option<crate::icon::Icon>) {}
+    fn set_window_icon(&self, _window_icon: Option<winit_core::icon::Icon>) {}

    fn set_ime_cursor_area(&self, _position: Position, _size: Size) {}

-    fn set_ime_allowed(&self, allowed: bool) {
-        if allowed {
-            self.app.show_soft_input(true);
-        } else {
-            self.app.hide_soft_input(true);
+    fn request_ime_update(&self, request: ImeRequest) -> Result<(), ImeRequestError> {
+        let mut current_caps = self.ime_capabilities.lock().unwrap();
+        match request {
+            ImeRequest::Enable(enable) => {
+                let (capabilities, _) = enable.into_raw();
+                if current_caps.is_some() {
+                    return Err(ImeRequestError::AlreadyEnabled);
+                }
+                *current_caps = Some(capabilities);
+                self.app.show_soft_input(true);
+            },
+            ImeRequest::Update(_) => {
+                if current_caps.is_none() {
+                    return Err(ImeRequestError::NotEnabled);
+                }
+            },
+            ImeRequest::Disable => {
+                *current_caps = None;
+                self.app.hide_soft_input(true);
+            },
        }
+
+        Ok(())
+    }
+
+    fn ime_capabilities(&self) -> Option<ImeCapabilities> {
+        *self.ime_capabilities.lock().unwrap()
    }

    fn set_ime_purpose(&self, _purpose: ImePurpose) {}
@@ -1000,16 +1027,6 @@ impl CoreWindow for Window {
    }
 }

-#[derive(Default, Clone, Debug)]
-pub struct OsError;
-
-use std::fmt::{self, Display, Formatter};
-impl Display for OsError {
-    fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), fmt::Error> {
-        write!(fmt, "Android OS Error")
-    }
-}
-
 fn screen_size(app: &AndroidApp) -> PhysicalSize<u32> {
    if let Some(native_window) = app.native_window() {
        PhysicalSize::new(native_window.width() as _, native_window.height() as _)
--- a/src/platform_impl/android/keycodes.rs
+++ b/src/platform_impl/android/keycodes.rs
@@ -1,7 +1,8 @@
-use android_activity::input::{KeyAction, KeyEvent, KeyMapChar, Keycode};
 use android_activity::AndroidApp;
-
-use crate::keyboard::{Key, KeyCode, KeyLocation, NamedKey, NativeKey, NativeKeyCode, PhysicalKey};
+use android_activity::input::{KeyAction, KeyEvent, KeyMapChar, Keycode};
+use winit_core::keyboard::{
+    Key, KeyCode, KeyLocation, NamedKey, NativeKey, NativeKeyCode, PhysicalKey,
+};

 pub fn to_physical_key(keycode: Keycode) -> PhysicalKey {
    PhysicalKey::Code(match keycode {
--- a/winit-android/src/lib.rs
+++ b/winit-android/src/lib.rs
@@ -62,17 +62,26 @@
 //! 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.10",
-//!    features = [ "android-native-activity" ] }`
+//! 2. Enable the `"android-native-activity"` feature for Winit: `winit = { version =
+//!    "0.31.0-beta.2", features = [ "android-native-activity" ] }`
 //! 3. Add an `android_main` entrypoint (as above), instead of using the '`[ndk_glue::main]` proc
 //!    macro from `ndk-macros` (optionally add a dependency on `android_logger` and initialize
 //!    logging as above).
 //! 4. Pass a clone of the `AndroidApp` that your application receives to Winit when building your
 //!    event loop (as shown above).
+#![cfg(target_os = "android")]
+
+mod event_loop;
+mod keycodes;
+
+use winit_core::event_loop::ActiveEventLoop as CoreActiveEventLoop;
+use winit_core::window::Window as CoreWindow;

 use self::activity::{AndroidApp, ConfigurationRef, Rect};
-use crate::event_loop::{ActiveEventLoop, EventLoop, EventLoopBuilder};
-use crate::window::{Window, WindowAttributes};
+pub use crate::event_loop::{
+    ActiveEventLoop, EventLoop, EventLoopProxy, PlatformSpecificEventLoopAttributes,
+    PlatformSpecificWindowAttributes, Window,
+};

 /// Additional methods on [`EventLoop`] that are specific to Android.
 pub trait EventLoopExtAndroid {
@@ -80,12 +89,6 @@ pub trait EventLoopExtAndroid {
    fn android_app(&self) -> &AndroidApp;
 }

-impl EventLoopExtAndroid for EventLoop {
-    fn android_app(&self) -> &AndroidApp {
-        &self.event_loop.android_app
-    }
-}
-
 /// Additional methods on [`ActiveEventLoop`] that are specific to Android.
 pub trait ActiveEventLoopExtAndroid {
    /// Get the [`AndroidApp`] which was used to create this event loop.
@@ -99,30 +102,25 @@ pub trait WindowExtAndroid {
    fn config(&self) -> ConfigurationRef;
 }

-impl WindowExtAndroid for dyn Window + '_ {
+impl WindowExtAndroid for dyn CoreWindow + '_ {
    fn content_rect(&self) -> Rect {
-        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<Window>().unwrap();
        window.content_rect()
    }

    fn config(&self) -> ConfigurationRef {
-        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<Window>().unwrap();
        window.config()
    }
 }

-impl ActiveEventLoopExtAndroid for dyn ActiveEventLoop + '_ {
+impl ActiveEventLoopExtAndroid for dyn CoreActiveEventLoop + '_ {
    fn android_app(&self) -> &AndroidApp {
-        let event_loop = self.cast_ref::<crate::platform_impl::ActiveEventLoop>().unwrap();
+        let event_loop = self.cast_ref::<ActiveEventLoop>().unwrap();
        &event_loop.app
    }
 }

-/// Additional methods on [`WindowAttributes`] that are specific to Android.
-pub trait WindowAttributesExtAndroid {}
-
-impl WindowAttributesExtAndroid for WindowAttributes {}
-
 pub trait EventLoopBuilderExtAndroid {
    /// Associates the [`AndroidApp`] that was passed to `android_main()` with the event loop
    ///
@@ -135,18 +133,6 @@ pub trait EventLoopBuilderExtAndroid {
    fn handle_volume_keys(&mut self) -> &mut Self;
 }

-impl EventLoopBuilderExtAndroid for EventLoopBuilder {
-    fn with_android_app(&mut self, app: AndroidApp) -> &mut Self {
-        self.platform_specific.android_app = Some(app);
-        self
-    }
-
-    fn handle_volume_keys(&mut self) -> &mut Self {
-        self.platform_specific.ignore_volume_keys = false;
-        self
-    }
-}
-
 /// Re-export of the `android_activity` API
 ///
 /// Winit re-exports the `android_activity` API for convenience so that most
@@ -175,16 +161,5 @@ pub mod activity {
    // feature enabled, so we avoid inlining it so that they're forced to view
    // it on the crate's own docs.rs page.
    #[doc(no_inline)]
-    #[cfg(android_platform)]
    pub use android_activity::*;
-
-    #[cfg(not(android_platform))]
-    #[doc(hidden)]
-    pub struct Rect;
-    #[cfg(not(android_platform))]
-    #[doc(hidden)]
-    pub struct ConfigurationRef;
-    #[cfg(not(android_platform))]
-    #[doc(hidden)]
-    pub struct AndroidApp;
 }
--- a/winit-appkit/Cargo.toml
+++ b/winit-appkit/Cargo.toml
@@ -0,0 +1,116 @@
+[package]
+description = "Winit's Appkit / macOS backend"
+documentation = "https://docs.rs/winit-appkit"
+edition.workspace = true
+license.workspace = true
+name = "winit-appkit"
+repository.workspace = true
+rust-version.workspace = true
+version.workspace = true
+
+[features]
+serde = ["dep:serde", "bitflags/serde", "smol_str/serde", "dpi/serde"]
+
+[dependencies]
+bitflags.workspace = true
+dpi.workspace = true
+rwh_06.workspace = true
+serde = { workspace = true, optional = true }
+smol_str.workspace = true
+tracing.workspace = true
+winit-core.workspace = true
+
+# Platform-specific
+[target.'cfg(target_vendor = "apple")'.dependencies]
+block2.workspace = true
+dispatch2 = { workspace = true, features = ["std", "objc2"] }
+objc2.workspace = true
+objc2-app-kit = { workspace = true, features = [
+    "std",
+    "objc2-core-foundation",
+    "NSAppearance",
+    "NSApplication",
+    "NSBitmapImageRep",
+    "NSButton",
+    "NSColor",
+    "NSControl",
+    "NSCursor",
+    "NSDragging",
+    "NSEvent",
+    "NSGraphics",
+    "NSGraphicsContext",
+    "NSImage",
+    "NSImageRep",
+    "NSMenu",
+    "NSMenuItem",
+    "NSOpenGLView",
+    "NSPanel",
+    "NSPasteboard",
+    "NSResponder",
+    "NSRunningApplication",
+    "NSScreen",
+    "NSTextInputClient",
+    "NSTextInputContext",
+    "NSToolbar",
+    "NSView",
+    "NSWindow",
+    "NSWindowScripting",
+    "NSWindowTabGroup",
+] }
+objc2-core-foundation = { workspace = true, features = [
+    "std",
+    "block2",
+    "CFBase",
+    "CFCGTypes",
+    "CFData",
+    "CFRunLoop",
+    "CFString",
+    "CFUUID",
+] }
+objc2-core-graphics = { workspace = true, features = [
+    "std",
+    "libc",
+    "CGDirectDisplay",
+    "CGDisplayConfiguration",
+    "CGDisplayFade",
+    "CGError",
+    "CGRemoteOperation",
+    "CGWindowLevel",
+] }
+objc2-core-video = { workspace = true, features = [
+    "std",
+    "objc2-core-graphics",
+    "CVBase",
+    "CVReturn",
+    "CVDisplayLink",
+] }
+objc2-foundation = { workspace = true, features = [
+    "std",
+    "block2",
+    "objc2-core-foundation",
+    "NSArray",
+    "NSAttributedString",
+    "NSData",
+    "NSDictionary",
+    "NSDistributedNotificationCenter",
+    "NSEnumerator",
+    "NSGeometry",
+    "NSKeyValueObserving",
+    "NSNotification",
+    "NSObjCRuntime",
+    "NSOperation",
+    "NSPathUtilities",
+    "NSProcessInfo",
+    "NSRunLoop",
+    "NSString",
+    "NSThread",
+    "NSValue",
+] }
+winit-common = { workspace = true, features = ["core-foundation", "event-handler"] }
+
+[dev-dependencies]
+winit.workspace = true
+
+[package.metadata.docs.rs]
+all-features = true
+targets = ["aarch64-apple-darwin", "x86_64-apple-darwin"]
--- a/winit-appkit/LICENSE
+++ b/winit-appkit/LICENSE
@@ -0,0 +1 @@
+../LICENSE
--- a/winit-appkit/README.md
+++ b/winit-appkit/README.md
@@ -0,0 +1 @@
+../README.md
--- a/src/platform_impl/apple/appkit/app.rs
+++ b/src/platform_impl/apple/appkit/app.rs
@@ -9,9 +9,9 @@ use objc2::runtime::{Imp, Sel};
 use objc2::sel;
 use objc2_app_kit::{NSApplication, NSEvent, NSEventModifierFlags, NSEventType};
 use objc2_foundation::MainThreadMarker;
+use winit_core::event::{DeviceEvent, ElementState};

 use super::app_state::AppState;
-use crate::event::{DeviceEvent, ElementState};

 type SendEvent = extern "C-unwind" fn(&NSApplication, Sel, &NSEvent);

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

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

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

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

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

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

    #[test]
--- a/src/platform_impl/apple/appkit/app_state.rs
+++ b/src/platform_impl/apple/appkit/app_state.rs
@@ -1,6 +1,6 @@
 use std::cell::{Cell, OnceCell, RefCell};
 use std::mem;
-use std::rc::{Rc, Weak};
+use std::rc::Rc;
 use std::sync::Arc;
 use std::time::Instant;

@@ -8,16 +8,16 @@ use dispatch2::MainThreadBound;
 use objc2::MainThreadMarker;
 use objc2_app_kit::{NSApplication, NSApplicationActivationPolicy, NSRunningApplication};
 use objc2_foundation::NSNotification;
+use winit_common::core_foundation::EventLoopProxy;
+use winit_common::event_handler::EventHandler;
+use winit_core::application::ApplicationHandler;
+use winit_core::event::{StartCause, WindowEvent};
+use winit_core::event_loop::ControlFlow;
+use winit_core::window::WindowId;

-use super::super::event_handler::EventHandler;
-use super::super::event_loop_proxy::EventLoopProxy;
-use super::event_loop::{notify_windows_of_exit, stop_app_immediately, ActiveEventLoop, PanicInfo};
+use super::event_loop::{ActiveEventLoop, notify_windows_of_exit, stop_app_immediately};
 use super::menu;
 use super::observer::{EventLoopWaker, RunLoop};
-use crate::application::ApplicationHandler;
-use crate::event::{StartCause, WindowEvent};
-use crate::event_loop::ControlFlow;
-use crate::window::WindowId;

 #[derive(Debug)]
 pub(super) struct AppState {
@@ -58,7 +58,7 @@ impl AppState {
        activation_policy: Option<NSApplicationActivationPolicy>,
        default_menu: bool,
        activate_ignoring_other_apps: bool,
-    ) -> Rc<Self> {
+    ) -> Option<Rc<Self>> {
        let event_loop_proxy = Arc::new(EventLoopProxy::new(mtm, move || {
            Self::get(mtm).with_handler(|app, event_loop| app.proxy_wake_up(event_loop));
        }));
@@ -85,8 +85,7 @@ impl AppState {
            pending_redraw: RefCell::new(vec![]),
        });

-        GLOBAL.get(mtm).set(this.clone()).expect("application state can only be set once");
-        this
+        GLOBAL.get(mtm).set(this.clone()).ok().and(Some(this))
    }

    pub fn get(mtm: MainThreadMarker) -> Rc<Self> {
@@ -118,7 +117,7 @@ impl AppState {
            // - https://github.com/rust-windowing/winit/issues/261
            // - https://github.com/rust-windowing/winit/issues/3958
            let is_bundled =
-                unsafe { NSRunningApplication::currentApplication().bundleIdentifier().is_some() };
+                NSRunningApplication::currentApplication().bundleIdentifier().is_some();
            if !is_bundled {
                app.setActivationPolicy(NSApplicationActivationPolicy::Regular);
            }
@@ -309,13 +308,9 @@ impl AppState {
    }

    // Called by RunLoopObserver after finishing waiting for new events
-    pub fn wakeup(self: &Rc<Self>, panic_info: Weak<PanicInfo>) {
-        let panic_info = panic_info
-            .upgrade()
-            .expect("The panic info must exist here. This failure indicates a developer error.");
-
+    pub fn wakeup(self: &Rc<Self>) {
        // Return when in event handler due to https://github.com/rust-windowing/winit/issues/1779
-        if panic_info.is_panicking() || !self.event_handler.ready() || !self.is_running() {
+        if !self.event_handler.ready() || !self.is_running() {
            return;
        }

@@ -341,15 +336,11 @@ impl AppState {
    }

    // Called by RunLoopObserver before waiting for new events
-    pub fn cleared(self: &Rc<Self>, panic_info: Weak<PanicInfo>) {
-        let panic_info = panic_info
-            .upgrade()
-            .expect("The panic info must exist here. This failure indicates a developer error.");
-
+    pub fn cleared(self: &Rc<Self>) {
        // 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.event_handler.ready() || !self.is_running() {
+        if !self.event_handler.ready() || !self.is_running() {
            return;
        }

--- a/src/platform_impl/apple/appkit/cursor.rs
+++ b/src/platform_impl/apple/appkit/cursor.rs
@@ -4,15 +4,13 @@ use std::sync::OnceLock;

 use objc2::rc::Retained;
 use objc2::runtime::Sel;
-use objc2::{available, msg_send, sel, AllocAnyThread, ClassType};
+use objc2::{AllocAnyThread, ClassType, available, msg_send, sel};
 use objc2_app_kit::{NSBitmapImageRep, NSCursor, NSDeviceRGBColorSpace, NSImage};
 use objc2_foundation::{
-    ns_string, NSData, NSDictionary, NSNumber, NSObject, NSPoint, NSSize, NSString,
+    NSData, NSDictionary, NSNumber, NSObject, NSPoint, NSSize, NSString, ns_string,
 };
-
-use crate::cursor::{CursorImage, CustomCursorProvider, CustomCursorSource};
-use crate::error::{NotSupportedError, RequestError};
-use crate::window::CursorIcon;
+use winit_core::cursor::{CursorIcon, CursorImage, CustomCursorProvider, CustomCursorSource};
+use winit_core::error::{NotSupportedError, RequestError};

 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct CustomCursor(pub(crate) Retained<NSCursor>);
@@ -33,7 +31,7 @@ impl CustomCursor {
        let cursor = match cursor {
            CustomCursorSource::Image(cursor_image) => cursor_image,
            CustomCursorSource::Animation { .. } | CustomCursorSource::Url { .. } => {
-                return Err(NotSupportedError::new("unsupported cursor kind").into())
+                return Err(NotSupportedError::new("unsupported cursor kind").into());
            },
        };

@@ -42,8 +40,8 @@ impl CustomCursor {
 }

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

    let bitmap = unsafe {
        NSBitmapImageRep::initWithBitmapDataPlanes_pixelsWide_pixelsHigh_bitsPerSample_samplesPerPixel_hasAlpha_isPlanar_colorSpaceName_bytesPerRow_bitsPerPixel(
@@ -60,15 +58,14 @@ pub(crate) fn cursor_from_image(cursor: &CursorImage) -> Result<Retained<NSCurso
            32,
        )
    }.ok_or_else(|| os_error!("parent view should be installed in a window"))?;
-    let bitmap_data = unsafe { slice::from_raw_parts_mut(bitmap.bitmapData(), cursor.rgba.len()) };
-    bitmap_data.copy_from_slice(&cursor.rgba);
+    let bitmap_data =
+        unsafe { slice::from_raw_parts_mut(bitmap.bitmapData(), cursor.buffer().len()) };
+    bitmap_data.copy_from_slice(cursor.buffer());

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

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

    Ok(NSCursor::initWithImage_hotSpot(NSCursor::alloc(), &image, hotspot))
 }
@@ -141,12 +138,9 @@ unsafe fn load_webkit_cursor(name: &NSString) -> Retained<NSCursor> {

    // TODO: Handle PLists better
    let info_path = cursor_path.stringByAppendingPathComponent(ns_string!("info.plist"));
-    let info: Retained<NSDictionary<NSObject, NSObject>> = unsafe {
-        msg_send![
-            <NSDictionary<NSObject, NSObject>>::class(),
-            dictionaryWithContentsOfFile: &*info_path,
-        ]
-    };
+    #[allow(deprecated)]
+    let info: Retained<NSDictionary<NSObject, NSObject>> =
+        unsafe { NSDictionary::dictionaryWithContentsOfFile(&info_path) }.unwrap();
    let mut x = 0.0;
    if let Some(n) = info.objectForKey(ns_string!("hotx")) {
        if let Ok(n) = n.downcast::<NSNumber>() {
@@ -217,9 +211,9 @@ pub(crate) fn cursor_from_icon(icon: CursorIcon) -> Retained<NSCursor> {
        CursorIcon::EwResize | CursorIcon::ColResize => NSCursor::resizeLeftRightCursor(),
        CursorIcon::NsResize | CursorIcon::RowResize => NSCursor::resizeUpDownCursor(),
        CursorIcon::Help => _helpCursor(),
-        CursorIcon::ZoomIn if available!(macos = 15.0) => unsafe { NSCursor::zoomInCursor() },
+        CursorIcon::ZoomIn if available!(macos = 15.0) => NSCursor::zoomInCursor(),
        CursorIcon::ZoomIn => _zoomInCursor(),
-        CursorIcon::ZoomOut if available!(macos = 15.0) => unsafe { NSCursor::zoomOutCursor() },
+        CursorIcon::ZoomOut if available!(macos = 15.0) => NSCursor::zoomOutCursor(),
        CursorIcon::ZoomOut => _zoomOutCursor(),
        CursorIcon::NeResize => _windowResizeNorthEastCursor(),
        CursorIcon::NwResize => _windowResizeNorthWestCursor(),
--- a/src/platform_impl/apple/appkit/event.rs
+++ b/src/platform_impl/apple/appkit/event.rs
@@ -6,14 +6,14 @@ use objc2_app_kit::{NSEvent, NSEventModifierFlags, NSEventSubtype, NSEventType};
 use objc2_core_foundation::{CFData, CFRetained};
 use objc2_foundation::NSPoint;
 use smol_str::SmolStr;
-
-use super::ffi;
-use crate::event::{ElementState, KeyEvent, Modifiers};
-use crate::keyboard::{
+use winit_core::event::{ElementState, KeyEvent, Modifiers};
+use winit_core::keyboard::{
    Key, KeyCode, KeyLocation, ModifiersKeys, ModifiersState, NamedKey, NativeKey, NativeKeyCode,
    PhysicalKey,
 };

+use super::ffi;
+
 /// Ignores ALL modifiers.
 pub fn get_modifierless_char(scancode: u16) -> Key {
    let Some(ptr) = NonNull::new(unsafe { ffi::TISCopyCurrentKeyboardLayoutInputSource() }) else {
@@ -67,9 +67,7 @@ pub fn get_modifierless_char(scancode: u16) -> Key {

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

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

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

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

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

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

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

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

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

@@ -330,12 +328,11 @@ pub(super) fn event_mods(event: &NSEvent) -> Modifiers {
    pressed_mods.set(ModifiersKeys::LMETA, flags.contains(NX_DEVICELCMDKEYMASK));
    pressed_mods.set(ModifiersKeys::RMETA, flags.contains(NX_DEVICERCMDKEYMASK));

-    Modifiers { state, pressed_mods }
+    Modifiers::new(state, pressed_mods)
 }

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

-pub(crate) fn physicalkey_to_scancode(physical_key: PhysicalKey) -> Option<u32> {
+pub fn physicalkey_to_scancode(physical_key: PhysicalKey) -> Option<u32> {
    let code = match physical_key {
        PhysicalKey::Code(code) => code,
        PhysicalKey::Unidentified(_) => return None,
@@ -481,7 +477,7 @@ pub(crate) fn physicalkey_to_scancode(physical_key: PhysicalKey) -> Option<u32>
    }
 }

-pub(crate) fn scancode_to_physicalkey(scancode: u32) -> PhysicalKey {
+pub fn scancode_to_physicalkey(scancode: u32) -> PhysicalKey {
    // Follows what Chromium and Firefox do:
    // https://chromium.googlesource.com/chromium/src.git/+/3e1a26c44c024d97dc9a4c09bbc6a2365398ca2c/ui/events/keycodes/dom/dom_code_data.inc
    // https://searchfox.org/mozilla-central/rev/c597e9c789ad36af84a0370d395be066b7dc94f4/widget/NativeKeyToDOMCodeName.h
--- a/src/platform_impl/apple/appkit/event_loop.rs
+++ b/src/platform_impl/apple/appkit/event_loop.rs
@@ -1,75 +1,36 @@
-use std::any::Any;
-use std::cell::Cell;
-use std::fmt;
-use std::panic::{catch_unwind, resume_unwind, RefUnwindSafe, UnwindSafe};
-use std::rc::{Rc, Weak};
+use std::rc::Rc;
 use std::sync::Arc;
 use std::time::{Duration, Instant};

-use objc2::rc::{autoreleasepool, Retained};
+use objc2::rc::{Retained, autoreleasepool};
 use objc2::runtime::ProtocolObject;
-use objc2::{available, MainThreadMarker};
+use objc2::{MainThreadMarker, available};
 use objc2_app_kit::{
    NSApplication, NSApplicationActivationPolicy, NSApplicationDidFinishLaunchingNotification,
    NSApplicationWillTerminateNotification, NSWindow,
 };
 use objc2_foundation::{NSNotificationCenter, NSObjectProtocol};
 use rwh_06::HasDisplayHandle;
+use winit_core::application::ApplicationHandler;
+use winit_core::cursor::{CustomCursor as CoreCustomCursor, CustomCursorSource};
+use winit_core::error::{EventLoopError, RequestError};
+use winit_core::event_loop::pump_events::PumpStatus;
+use winit_core::event_loop::{
+    ActiveEventLoop as RootActiveEventLoop, ControlFlow, DeviceEvents,
+    EventLoopProxy as CoreEventLoopProxy, OwnedDisplayHandle as CoreOwnedDisplayHandle,
+};
+use winit_core::monitor::MonitorHandle as CoreMonitorHandle;
+use winit_core::window::Theme;

-use super::super::notification_center::create_observer;
 use super::app::override_send_event;
 use super::app_state::AppState;
 use super::cursor::CustomCursor;
 use super::event::dummy_event;
 use super::monitor;
+use super::notification_center::create_observer;
 use super::observer::setup_control_flow_observers;
-use crate::application::ApplicationHandler;
-use crate::error::{EventLoopError, RequestError};
-use crate::event_loop::{
-    ActiveEventLoop as RootActiveEventLoop, ControlFlow, DeviceEvents,
-    EventLoopProxy as CoreEventLoopProxy, OwnedDisplayHandle as CoreOwnedDisplayHandle,
-};
-use crate::monitor::MonitorHandle as CoreMonitorHandle;
-use crate::platform::macos::ActivationPolicy;
-use crate::platform::pump_events::PumpStatus;
-use crate::platform_impl::Window;
-use crate::window::{CustomCursor as CoreCustomCursor, CustomCursorSource, Theme};
-
-#[derive(Default)]
-pub struct PanicInfo {
-    inner: Cell<Option<Box<dyn Any + Send + 'static>>>,
-}
-
-impl fmt::Debug for PanicInfo {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("PanicInfo").finish_non_exhaustive()
-    }
-}
-
-// WARNING:
-// As long as this struct is used through its `impl`, it is UnwindSafe.
-// (If `get_mut` is called on `inner`, unwind safety may get broken.)
-impl UnwindSafe for PanicInfo {}
-impl RefUnwindSafe for PanicInfo {}
-impl PanicInfo {
-    pub fn is_panicking(&self) -> bool {
-        let inner = self.inner.take();
-        let result = inner.is_some();
-        self.inner.set(inner);
-        result
-    }
-
-    /// Overwrites the current state if the current state is not panicking
-    pub fn set_panic(&self, p: Box<dyn Any + Send + 'static>) {
-        if !self.is_panicking() {
-            self.inner.set(Some(p));
-        }
-    }
-
-    pub fn take(&self) -> Option<Box<dyn Any + Send + 'static>> {
-        self.inner.take()
-    }
-}
+use crate::ActivationPolicy;
+use crate::window::Window;

 #[derive(Debug)]
 pub struct ActiveEventLoop {
@@ -102,8 +63,8 @@ impl RootActiveEventLoop for ActiveEventLoop {

    fn create_window(
        &self,
-        window_attributes: crate::window::WindowAttributes,
-    ) -> Result<Box<dyn crate::window::Window>, RequestError> {
+        window_attributes: winit_core::window::WindowAttributes,
+    ) -> Result<Box<dyn winit_core::window::Window>, RequestError> {
        Ok(Box::new(Window::new(self, window_attributes)?))
    }

@@ -122,7 +83,7 @@ impl RootActiveEventLoop for ActiveEventLoop {
        )
    }

-    fn primary_monitor(&self) -> Option<crate::monitor::MonitorHandle> {
+    fn primary_monitor(&self) -> Option<winit_core::monitor::MonitorHandle> {
        let monitor = monitor::primary_monitor();
        Some(CoreMonitorHandle(Arc::new(monitor)))
    }
@@ -182,7 +143,6 @@ pub struct EventLoop {
    app_state: Rc<AppState>,

    window_target: ActiveEventLoop,
-    panic_info: Rc<PanicInfo>,

    // Since macOS 10.11, we no longer need to remove the observers before they are deallocated;
    // the system instead cleans it up next time it would have posted a notification to it.
@@ -193,10 +153,10 @@ pub struct EventLoop {
 }

 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-pub(crate) struct PlatformSpecificEventLoopAttributes {
-    pub(crate) activation_policy: Option<ActivationPolicy>,
-    pub(crate) default_menu: bool,
-    pub(crate) activate_ignoring_other_apps: bool,
+pub struct PlatformSpecificEventLoopAttributes {
+    pub activation_policy: Option<ActivationPolicy>,
+    pub default_menu: bool,
+    pub activate_ignoring_other_apps: bool,
 }

 impl Default for PlatformSpecificEventLoopAttributes {
@@ -206,9 +166,7 @@ impl Default for PlatformSpecificEventLoopAttributes {
 }

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

@@ -224,7 +182,8 @@ impl EventLoop {
            activation_policy,
            attributes.default_menu,
            attributes.activate_ignoring_other_apps,
-        );
+        )
+        .ok_or_else(|| EventLoopError::RecreationAttempt)?;

        // Initialize the application (if it has not already been).
        let app = NSApplication::sharedApplication(mtm);
@@ -232,7 +191,7 @@ impl EventLoop {
        // Override `sendEvent:` on the application to forward to our application state.
        override_send_event(&app);

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

        let weak_app_state = Rc::downgrade(&app_state);
        let _did_finish_launching_observer = create_observer(
@@ -258,14 +217,12 @@ impl EventLoop {
            },
        );

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

        Ok(EventLoop {
            app,
            app_state: app_state.clone(),
            window_target: ActiveEventLoop { app_state, mtm },
-            panic_info,
            _did_finish_launching_observer,
            _will_terminate_observer,
        })
@@ -275,10 +232,6 @@ impl EventLoop {
        &self.window_target
    }

-    pub fn run_app<A: ApplicationHandler>(mut self, app: A) -> Result<(), EventLoopError> {
-        self.run_app_on_demand(app)
-    }
-
    // NB: we don't base this on `pump_events` because for `MacOs` we can't support
    // `pump_events` elegantly (we just ask to run the loop for a "short" amount of
    // time and so a layered implementation would end up using a lot of CPU due to
@@ -305,15 +258,6 @@ impl EventLoop {
                // NOTE: Make sure to not run the application re-entrantly, as that'd be confusing.
                self.app.run();

-                // While the app is running it's possible that we catch a panic
-                // to avoid unwinding across an objective-c ffi boundary, which
-                // will lead to us stopping the `NSApplication` and saving the
-                // `PanicInfo` so that we can resume the unwind at a controlled,
-                // safe point in time.
-                if let Some(panic) = self.panic_info.take() {
-                    resume_unwind(panic);
-                }
-
                self.app_state.internal_exit()
            })
        });
@@ -369,15 +313,6 @@ impl EventLoop {
                    self.app.run();
                }

-                // While the app is running it's possible that we catch a panic
-                // to avoid unwinding across an objective-c ffi boundary, which
-                // will lead to us stopping the application and saving the
-                // `PanicInfo` so that we can resume the unwind at a controlled,
-                // safe point in time.
-                if let Some(panic) = self.panic_info.take() {
-                    resume_unwind(panic);
-                }
-
                if self.app_state.exiting() {
                    self.app_state.internal_exit();
                    PumpStatus::Exit(0)
@@ -422,29 +357,3 @@ pub(super) fn notify_windows_of_exit(app: &NSApplication) {
        window.close();
    }
 }
-
-/// Catches panics that happen inside `f` and when a panic
-/// happens, stops the `sharedApplication`
-#[inline]
-pub fn stop_app_on_panic<F: FnOnce() -> R + UnwindSafe, R>(
-    mtm: MainThreadMarker,
-    panic_info: Weak<PanicInfo>,
-    f: F,
-) -> Option<R> {
-    match catch_unwind(f) {
-        Ok(r) => Some(r),
-        Err(e) => {
-            // It's important that we set the panic before requesting a `stop`
-            // because some callback are still called during the `stop` message
-            // and we need to know in those callbacks if the application is currently
-            // panicking
-            {
-                let panic_info = panic_info.upgrade().unwrap();
-                panic_info.set_panic(e);
-            }
-            let app = NSApplication::sharedApplication(mtm);
-            stop_app_immediately(&app);
-            None
-        },
-    }
-}
--- a/src/platform_impl/apple/appkit/ffi.rs
+++ b/src/platform_impl/apple/appkit/ffi.rs
@@ -6,13 +6,13 @@ use std::ffi::c_void;

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

 pub const IO16BitDirectPixels: &str = "-RRRRRGGGGGBBBBB";
 pub const IO32BitDirectPixels: &str = "--------RRRRRRRRGGGGGGGGBBBBBBBB";
-
 pub const kIO30BitDirectPixels: &str = "--RRRRRRRRRRGGGGGGGGGGBBBBBBBBBB";
+pub const kIO64BitDirectPixels: &str = "-16R16G16B16";

 // `CGDisplayCreateUUIDFromDisplayID` comes from the `ColorSync` framework.
 // However, that framework was only introduced "publicly" in macOS 10.13.
@@ -22,14 +22,14 @@ pub const kIO30BitDirectPixels: &str = "--RRRRRRRRRRGGGGGGGGGGBBBBBBBBBB";
 // `ApplicationServices`, see:
 // https://developer.apple.com/library/archive/documentation/MacOSX/Conceptual/OSX_Technology_Overview/SystemFrameworks/SystemFrameworks.html#//apple_ref/doc/uid/TP40001067-CH210-BBCFFIEG
 #[link(name = "ApplicationServices", kind = "framework")]
-extern "C" {
+unsafe extern "C" {
    pub fn CGDisplayCreateUUIDFromDisplayID(display: CGDirectDisplayID) -> *mut CFUUID;

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

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

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

    #[allow(non_snake_case)]
--- a/winit-appkit/src/lib.rs
+++ b/winit-appkit/src/lib.rs
@@ -17,13 +17,12 @@
 //! Instead, Winit guarantees that it will not register an application delegate, so the solution is
 //! to register your own application delegate, as outlined in the following example (see
 //! `objc2-app-kit` for more detailed information).
-#![cfg_attr(target_os = "macos", doc = "```")]
-#![cfg_attr(not(target_os = "macos"), doc = "```ignore")]
+//! ```
 //! use objc2::rc::Retained;
 //! use objc2::runtime::ProtocolObject;
-//! use objc2::{define_class, msg_send, DefinedClass, MainThreadMarker, MainThreadOnly};
+//! use objc2::{DefinedClass, MainThreadMarker, MainThreadOnly, define_class, msg_send};
 //! use objc2_app_kit::{NSApplication, NSApplicationDelegate};
-//! use objc2_foundation::{NSArray, NSURL, NSObject, NSObjectProtocol};
+//! use objc2_foundation::{NSArray, NSObject, NSObjectProtocol, NSURL};
 //! use winit::event_loop::EventLoop;
 //!
 //! define_class!(
@@ -64,17 +63,40 @@
 //!     Ok(())
 //! }
 //! ```
+#![cfg(target_vendor = "apple")] // TODO: Remove once `objc2` allows compiling on all platforms
+
+#[macro_use]
+mod util;
+
+mod app;
+mod app_state;
+mod cursor;
+mod event;
+mod event_loop;
+mod ffi;
+mod menu;
+mod monitor;
+mod notification_center;
+mod observer;
+mod view;
+mod window;
+mod window_delegate;

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

 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
+#[doc(inline)]
+pub use winit_core::application::macos::ApplicationHandlerExtMacOS;
+use winit_core::event_loop::ActiveEventLoop;
+use winit_core::monitor::MonitorHandle;
+use winit_core::window::{PlatformWindowAttributes, Window};

-use crate::application::ApplicationHandler;
-use crate::event_loop::{ActiveEventLoop, EventLoopBuilder};
-use crate::monitor::MonitorHandle;
-use crate::platform_impl::MonitorHandle as MacOsMonitorHandle;
-use crate::window::{Window, WindowAttributes, WindowId};
+pub use self::event::{physicalkey_to_scancode, scancode_to_physicalkey};
+use self::event_loop::ActiveEventLoop as AppKitActiveEventLoop;
+pub use self::event_loop::{EventLoop, PlatformSpecificEventLoopAttributes};
+use self::monitor::MonitorHandle as AppKitMonitorHandle;
+use self::window::Window as AppKitWindow;

 /// Additional methods on [`Window`] that are specific to MacOS.
 pub trait WindowExtMacOS {
@@ -170,109 +192,109 @@ pub trait WindowExtMacOS {
 impl WindowExtMacOS for dyn Window + '_ {
    #[inline]
    fn simple_fullscreen(&self) -> bool {
-        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<AppKitWindow>().unwrap();
        window.maybe_wait_on_main(|w| w.simple_fullscreen())
    }

    #[inline]
    fn set_simple_fullscreen(&self, fullscreen: bool) -> bool {
-        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<AppKitWindow>().unwrap();
        window.maybe_wait_on_main(move |w| w.set_simple_fullscreen(fullscreen))
    }

    #[inline]
    fn has_shadow(&self) -> bool {
-        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<AppKitWindow>().unwrap();
        window.maybe_wait_on_main(|w| w.has_shadow())
    }

    #[inline]
    fn set_has_shadow(&self, has_shadow: bool) {
-        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<AppKitWindow>().unwrap();
        window.maybe_wait_on_main(move |w| w.set_has_shadow(has_shadow));
    }

    #[inline]
    fn set_tabbing_identifier(&self, identifier: &str) {
-        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<AppKitWindow>().unwrap();
        window.maybe_wait_on_main(|w| w.set_tabbing_identifier(identifier))
    }

    #[inline]
    fn tabbing_identifier(&self) -> String {
-        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<AppKitWindow>().unwrap();
        window.maybe_wait_on_main(|w| w.tabbing_identifier())
    }

    #[inline]
    fn select_next_tab(&self) {
-        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<AppKitWindow>().unwrap();
        window.maybe_wait_on_main(|w| w.select_next_tab());
    }

    #[inline]
    fn select_previous_tab(&self) {
-        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<AppKitWindow>().unwrap();
        window.maybe_wait_on_main(|w| w.select_previous_tab());
    }

    #[inline]
    fn select_tab_at_index(&self, index: usize) {
-        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<AppKitWindow>().unwrap();
        window.maybe_wait_on_main(move |w| w.select_tab_at_index(index));
    }

    #[inline]
    fn num_tabs(&self) -> usize {
-        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<AppKitWindow>().unwrap();
        window.maybe_wait_on_main(|w| w.num_tabs())
    }

    #[inline]
    fn is_document_edited(&self) -> bool {
-        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<AppKitWindow>().unwrap();
        window.maybe_wait_on_main(|w| w.is_document_edited())
    }

    #[inline]
    fn set_document_edited(&self, edited: bool) {
-        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<AppKitWindow>().unwrap();
        window.maybe_wait_on_main(move |w| w.set_document_edited(edited));
    }

    #[inline]
    fn set_option_as_alt(&self, option_as_alt: OptionAsAlt) {
-        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<AppKitWindow>().unwrap();
        window.maybe_wait_on_main(move |w| w.set_option_as_alt(option_as_alt));
    }

    #[inline]
    fn option_as_alt(&self) -> OptionAsAlt {
-        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<AppKitWindow>().unwrap();
        window.maybe_wait_on_main(|w| w.option_as_alt())
    }

    #[inline]
    fn set_borderless_game(&self, borderless_game: bool) {
-        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<AppKitWindow>().unwrap();
        window.maybe_wait_on_main(|w| w.set_borderless_game(borderless_game))
    }

    #[inline]
    fn is_borderless_game(&self) -> bool {
-        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<AppKitWindow>().unwrap();
        window.maybe_wait_on_main(|w| w.is_borderless_game())
    }

    #[inline]
    fn set_unified_titlebar(&self, unified_titlebar: bool) {
-        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<AppKitWindow>().unwrap();
        window.maybe_wait_on_main(|w| w.set_unified_titlebar(unified_titlebar))
    }

    #[inline]
    fn unified_titlebar(&self) -> bool {
-        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<AppKitWindow>().unwrap();
        window.maybe_wait_on_main(|w| w.unified_titlebar())
    }
 }
@@ -292,7 +314,7 @@ pub enum ActivationPolicy {
    Prohibited,
 }

-/// Additional methods on [`WindowAttributes`] that are specific to MacOS.
+/// Window attributes that are specific to MacOS.
 ///
 /// **Note:** Properties dealing with the titlebar will be overwritten by the
 /// [`WindowAttributes::with_decorations`] method:
@@ -301,127 +323,158 @@ pub enum ActivationPolicy {
 /// - `with_titlebar_hidden`
 /// - `with_titlebar_buttons_hidden`
 /// - `with_fullsize_content_view`
-pub trait WindowAttributesExtMacOS {
+///
+/// [`WindowAttributes::with_decorations`]: crate::window::WindowAttributes::with_decorations
+#[derive(Clone, Debug, PartialEq)]
+pub struct WindowAttributesMacOS {
+    pub(crate) movable_by_window_background: bool,
+    pub(crate) titlebar_transparent: bool,
+    pub(crate) title_hidden: bool,
+    pub(crate) titlebar_hidden: bool,
+    pub(crate) titlebar_buttons_hidden: bool,
+    pub(crate) fullsize_content_view: bool,
+    pub(crate) disallow_hidpi: bool,
+    pub(crate) has_shadow: bool,
+    pub(crate) accepts_first_mouse: bool,
+    pub(crate) tabbing_identifier: Option<String>,
+    pub(crate) option_as_alt: OptionAsAlt,
+    pub(crate) borderless_game: bool,
+    pub(crate) unified_titlebar: bool,
+    pub(crate) panel: bool,
+}
+
+impl WindowAttributesMacOS {
    /// Enables click-and-drag behavior for the entire window, not just the titlebar.
-    fn with_movable_by_window_background(self, movable_by_window_background: bool) -> Self;
+    #[inline]
+    pub fn with_movable_by_window_background(mut self, movable_by_window_background: bool) -> Self {
+        self.movable_by_window_background = movable_by_window_background;
+        self
+    }
+
    /// Makes the titlebar transparent and allows the content to appear behind it.
-    fn with_titlebar_transparent(self, titlebar_transparent: bool) -> Self;
-    /// Hides the window title.
-    fn with_title_hidden(self, title_hidden: bool) -> Self;
+    #[inline]
+    pub fn with_titlebar_transparent(mut self, titlebar_transparent: bool) -> Self {
+        self.titlebar_transparent = titlebar_transparent;
+        self
+    }
+
    /// Hides the window titlebar.
-    fn with_titlebar_hidden(self, titlebar_hidden: bool) -> Self;
+    #[inline]
+    pub fn with_titlebar_hidden(mut self, titlebar_hidden: bool) -> Self {
+        self.titlebar_hidden = titlebar_hidden;
+        self
+    }
+
    /// Hides the window titlebar buttons.
-    fn with_titlebar_buttons_hidden(self, titlebar_buttons_hidden: bool) -> Self;
+    #[inline]
+    pub fn with_titlebar_buttons_hidden(mut self, titlebar_buttons_hidden: bool) -> Self {
+        self.titlebar_buttons_hidden = titlebar_buttons_hidden;
+        self
+    }
+
+    /// Hides the window title.
+    #[inline]
+    pub fn with_title_hidden(mut self, title_hidden: bool) -> Self {
+        self.title_hidden = title_hidden;
+        self
+    }
+
    /// Makes the window content appear behind the titlebar.
-    fn with_fullsize_content_view(self, fullsize_content_view: bool) -> Self;
-    fn with_disallow_hidpi(self, disallow_hidpi: bool) -> Self;
-    fn with_has_shadow(self, has_shadow: bool) -> Self;
+    #[inline]
+    pub fn with_fullsize_content_view(mut self, fullsize_content_view: bool) -> Self {
+        self.fullsize_content_view = fullsize_content_view;
+        self
+    }
+
+    #[inline]
+    pub fn with_disallow_hidpi(mut self, disallow_hidpi: bool) -> Self {
+        self.disallow_hidpi = disallow_hidpi;
+        self
+    }
+
+    #[inline]
+    pub fn with_has_shadow(mut self, has_shadow: bool) -> Self {
+        self.has_shadow = has_shadow;
+        self
+    }
+
    /// Window accepts click-through mouse events.
-    fn with_accepts_first_mouse(self, accepts_first_mouse: bool) -> Self;
+    #[inline]
+    pub fn with_accepts_first_mouse(mut self, accepts_first_mouse: bool) -> Self {
+        self.accepts_first_mouse = accepts_first_mouse;
+        self
+    }
+
    /// Defines the window tabbing identifier.
    ///
    /// <https://developer.apple.com/documentation/appkit/nswindow/1644704-tabbingidentifier>
-    fn with_tabbing_identifier(self, identifier: &str) -> Self;
+    #[inline]
+    pub fn with_tabbing_identifier(mut self, tabbing_identifier: &str) -> Self {
+        self.tabbing_identifier.replace(tabbing_identifier.to_string());
+        self
+    }
+
    /// Set how the <kbd>Option</kbd> keys are interpreted.
    ///
    /// See [`WindowExtMacOS::set_option_as_alt`] for details on what this means if set.
-    fn with_option_as_alt(self, option_as_alt: OptionAsAlt) -> Self;
+    #[inline]
+    pub fn with_option_as_alt(mut self, option_as_alt: OptionAsAlt) -> Self {
+        self.option_as_alt = option_as_alt;
+        self
+    }
+
    /// See [`WindowExtMacOS::set_borderless_game`] for details on what this means if set.
-    fn with_borderless_game(self, borderless_game: bool) -> Self;
+    #[inline]
+    pub fn with_borderless_game(mut self, borderless_game: bool) -> Self {
+        self.borderless_game = borderless_game;
+        self
+    }
+
    /// See [`WindowExtMacOS::set_unified_titlebar`] for details on what this means if set.
-    fn with_unified_titlebar(self, unified_titlebar: bool) -> Self;
+    #[inline]
+    pub fn with_unified_titlebar(mut self, unified_titlebar: bool) -> Self {
+        self.unified_titlebar = unified_titlebar;
+        self
+    }
+
    /// Use [`NSPanel`] window with [`NonactivatingPanel`] window style mask instead of
    /// [`NSWindow`].
    ///
    /// [`NSWindow`]: https://developer.apple.com/documentation/appkit/NSWindow?language=objc
    /// [`NSPanel`]: https://developer.apple.com/documentation/appkit/NSPanel?language=objc
    /// [`NonactivatingPanel`]: https://developer.apple.com/documentation/appkit/nswindow/stylemask-swift.struct/nonactivatingpanel?language=objc
-    fn with_panel(self, panel: bool) -> Self;
+    #[inline]
+    pub fn with_panel(mut self, panel: bool) -> Self {
+        self.panel = panel;
+        self
+    }
 }

-impl WindowAttributesExtMacOS for WindowAttributes {
+impl Default for WindowAttributesMacOS {
    #[inline]
-    fn with_movable_by_window_background(mut self, movable_by_window_background: bool) -> Self {
-        self.platform_specific.movable_by_window_background = movable_by_window_background;
-        self
+    fn default() -> Self {
+        Self {
+            movable_by_window_background: false,
+            titlebar_transparent: false,
+            title_hidden: false,
+            titlebar_hidden: false,
+            titlebar_buttons_hidden: false,
+            fullsize_content_view: false,
+            disallow_hidpi: false,
+            has_shadow: true,
+            accepts_first_mouse: true,
+            tabbing_identifier: None,
+            option_as_alt: Default::default(),
+            borderless_game: false,
+            unified_titlebar: false,
+            panel: false,
+        }
    }
+}

-    #[inline]
-    fn with_titlebar_transparent(mut self, titlebar_transparent: bool) -> Self {
-        self.platform_specific.titlebar_transparent = titlebar_transparent;
-        self
-    }
-
-    #[inline]
-    fn with_titlebar_hidden(mut self, titlebar_hidden: bool) -> Self {
-        self.platform_specific.titlebar_hidden = titlebar_hidden;
-        self
-    }
-
-    #[inline]
-    fn with_titlebar_buttons_hidden(mut self, titlebar_buttons_hidden: bool) -> Self {
-        self.platform_specific.titlebar_buttons_hidden = titlebar_buttons_hidden;
-        self
-    }
-
-    #[inline]
-    fn with_title_hidden(mut self, title_hidden: bool) -> Self {
-        self.platform_specific.title_hidden = title_hidden;
-        self
-    }
-
-    #[inline]
-    fn with_fullsize_content_view(mut self, fullsize_content_view: bool) -> Self {
-        self.platform_specific.fullsize_content_view = fullsize_content_view;
-        self
-    }
-
-    #[inline]
-    fn with_disallow_hidpi(mut self, disallow_hidpi: bool) -> Self {
-        self.platform_specific.disallow_hidpi = disallow_hidpi;
-        self
-    }
-
-    #[inline]
-    fn with_has_shadow(mut self, has_shadow: bool) -> Self {
-        self.platform_specific.has_shadow = has_shadow;
-        self
-    }
-
-    #[inline]
-    fn with_accepts_first_mouse(mut self, accepts_first_mouse: bool) -> Self {
-        self.platform_specific.accepts_first_mouse = accepts_first_mouse;
-        self
-    }
-
-    #[inline]
-    fn with_tabbing_identifier(mut self, tabbing_identifier: &str) -> Self {
-        self.platform_specific.tabbing_identifier.replace(tabbing_identifier.to_string());
-        self
-    }
-
-    #[inline]
-    fn with_option_as_alt(mut self, option_as_alt: OptionAsAlt) -> Self {
-        self.platform_specific.option_as_alt = option_as_alt;
-        self
-    }
-
-    #[inline]
-    fn with_borderless_game(mut self, borderless_game: bool) -> Self {
-        self.platform_specific.borderless_game = borderless_game;
-        self
-    }
-
-    #[inline]
-    fn with_unified_titlebar(mut self, unified_titlebar: bool) -> Self {
-        self.platform_specific.unified_titlebar = unified_titlebar;
-        self
-    }
-
-    #[inline]
-    fn with_panel(mut self, panel: bool) -> Self {
-        self.platform_specific.panel = panel;
-        self
+impl PlatformWindowAttributes for WindowAttributesMacOS {
+    fn box_clone(&self) -> Box<dyn PlatformWindowAttributes> {
+        Box::from(self.clone())
    }
 }

@@ -480,26 +533,6 @@ pub trait EventLoopBuilderExtMacOS {
    fn with_activate_ignoring_other_apps(&mut self, ignore: bool) -> &mut Self;
 }

-impl EventLoopBuilderExtMacOS for EventLoopBuilder {
-    #[inline]
-    fn with_activation_policy(&mut self, activation_policy: ActivationPolicy) -> &mut Self {
-        self.platform_specific.activation_policy = Some(activation_policy);
-        self
-    }
-
-    #[inline]
-    fn with_default_menu(&mut self, enable: bool) -> &mut Self {
-        self.platform_specific.default_menu = enable;
-        self
-    }
-
-    #[inline]
-    fn with_activate_ignoring_other_apps(&mut self, ignore: bool) -> &mut Self {
-        self.platform_specific.activate_ignoring_other_apps = ignore;
-        self
-    }
-}
-
 /// Additional methods on [`MonitorHandle`] that are specific to MacOS.
 pub trait MonitorHandleExtMacOS {
    /// Returns a pointer to the NSScreen representing this monitor.
@@ -508,7 +541,7 @@ pub trait MonitorHandleExtMacOS {

 impl MonitorHandleExtMacOS for MonitorHandle {
    fn ns_screen(&self) -> Option<*mut c_void> {
-        let monitor = self.cast_ref::<MacOsMonitorHandle>().unwrap();
+        let monitor = self.cast_ref::<AppKitMonitorHandle>().unwrap();
        // SAFETY: We only use the marker to get a pointer
        let mtm = unsafe { objc2::MainThreadMarker::new_unchecked() };
        monitor.ns_screen(mtm).map(|s| objc2::rc::Retained::as_ptr(&s) as _)
@@ -533,30 +566,26 @@ pub trait ActiveEventLoopExtMacOS {

 impl ActiveEventLoopExtMacOS for dyn ActiveEventLoop + '_ {
    fn hide_application(&self) {
-        let event_loop = self
-            .cast_ref::<crate::platform_impl::ActiveEventLoop>()
-            .expect("non macOS event loop on macOS");
+        let event_loop =
+            self.cast_ref::<AppKitActiveEventLoop>().expect("non macOS event loop on macOS");
        event_loop.hide_application()
    }

    fn hide_other_applications(&self) {
-        let event_loop = self
-            .cast_ref::<crate::platform_impl::ActiveEventLoop>()
-            .expect("non macOS event loop on macOS");
+        let event_loop =
+            self.cast_ref::<AppKitActiveEventLoop>().expect("non macOS event loop on macOS");
        event_loop.hide_other_applications()
    }

    fn set_allows_automatic_window_tabbing(&self, enabled: bool) {
-        let event_loop = self
-            .cast_ref::<crate::platform_impl::ActiveEventLoop>()
-            .expect("non macOS event loop on macOS");
+        let event_loop =
+            self.cast_ref::<AppKitActiveEventLoop>().expect("non macOS event loop on macOS");
        event_loop.set_allows_automatic_window_tabbing(enabled);
    }

    fn allows_automatic_window_tabbing(&self) -> bool {
-        let event_loop = self
-            .cast_ref::<crate::platform_impl::ActiveEventLoop>()
-            .expect("non macOS event loop on macOS");
+        let event_loop =
+            self.cast_ref::<AppKitActiveEventLoop>().expect("non macOS event loop on macOS");
        event_loop.allows_automatic_window_tabbing()
    }
 }
@@ -580,52 +609,3 @@ pub enum OptionAsAlt {
    #[default]
    None,
 }
-
-/// Additional events on [`ApplicationHandler`] that are specific to macOS.
-///
-/// This can be registered with [`ApplicationHandler::macos_handler`].
-pub trait ApplicationHandlerExtMacOS: ApplicationHandler {
-    /// The system interpreted a keypress as a standard key binding command.
-    ///
-    /// Examples include inserting tabs and newlines, or moving the insertion point, see
-    /// [`NSStandardKeyBindingResponding`] for the full list of key bindings. They are often text
-    /// editing related.
-    ///
-    /// This corresponds to the [`doCommandBySelector:`] method on `NSTextInputClient`.
-    ///
-    /// The `action` parameter contains the string representation of the selector. Examples include
-    /// `"insertBacktab:"`, `"indent:"` and `"noop:"`.
-    ///
-    /// # Example
-    ///
-    /// ```ignore
-    /// impl ApplicationHandlerExtMacOS for App {
-    ///     fn standard_key_binding(
-    ///         &mut self,
-    ///         event_loop: &dyn ActiveEventLoop,
-    ///         window_id: WindowId,
-    ///         action: &str,
-    ///     ) {
-    ///         match action {
-    ///             "moveBackward:" => self.cursor.position -= 1,
-    ///             "moveForward:" => self.cursor.position += 1,
-    ///             _ => {} // Ignore other actions
-    ///         }
-    ///     }
-    /// }
-    /// ```
-    ///
-    /// [`NSStandardKeyBindingResponding`]: https://developer.apple.com/documentation/appkit/nsstandardkeybindingresponding?language=objc
-    /// [`doCommandBySelector:`]: https://developer.apple.com/documentation/appkit/nstextinputclient/1438256-docommandbyselector?language=objc
-    #[doc(alias = "doCommandBySelector:")]
-    fn standard_key_binding(
-        &mut self,
-        event_loop: &dyn ActiveEventLoop,
-        window_id: WindowId,
-        action: &str,
-    ) {
-        let _ = event_loop;
-        let _ = window_id;
-        let _ = action;
-    }
-}
--- a/src/platform_impl/apple/appkit/menu.rs
+++ b/src/platform_impl/apple/appkit/menu.rs
@@ -1,8 +1,8 @@
 use objc2::rc::Retained;
 use objc2::runtime::Sel;
-use objc2::{sel, MainThreadMarker};
+use objc2::{MainThreadMarker, sel};
 use objc2_app_kit::{NSApplication, NSEventModifierFlags, NSMenu, NSMenuItem};
-use objc2_foundation::{ns_string, NSProcessInfo, NSString};
+use objc2_foundation::{NSBundle, NSProcessInfo, NSString, ns_string};

 struct KeyEquivalent<'a> {
    key: &'a NSString,
@@ -16,7 +16,10 @@ pub fn initialize(app: &NSApplication) {
    menubar.addItem(&app_menu_item);

    let app_menu = NSMenu::new(mtm);
-    let process_name = NSProcessInfo::processInfo().processName();
+    let process_name = match NSBundle::mainBundle().name() {
+        Some(bundle_name) => bundle_name,
+        None => NSProcessInfo::processInfo().processName(),
+    };

    // About menu item
    let about_item_title = ns_string!("About ").stringByAppendingString(&process_name);
@@ -79,7 +82,7 @@ pub fn initialize(app: &NSApplication) {
    app_menu.addItem(&quit_item);
    app_menu_item.setSubmenu(Some(&app_menu));

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

--- a/src/platform_impl/apple/appkit/monitor.rs
+++ b/src/platform_impl/apple/appkit/monitor.rs
@@ -6,22 +6,22 @@ use std::ptr::NonNull;
 use std::{fmt, ptr};

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

 use super::ffi;
 use super::util::cgerr;
-use crate::dpi::{LogicalPosition, PhysicalPosition, PhysicalSize};
-use crate::monitor::{MonitorHandleProvider, VideoMode};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 fn refresh_rate_millihertz(id: CGDirectDisplayID, mode: &NativeDisplayMode) -> Option<NonZeroU32> {
-    unsafe {
-        let refresh_rate = CGDisplayMode::refresh_rate(Some(&mode.0));
-        if refresh_rate > 0.0 {
-            return NonZeroU32::new((refresh_rate * 1000.0).round() as u32);
-        }
-
-        let mut display_link = std::ptr::null_mut();
-        #[allow(deprecated)]
-        if CVDisplayLink::create_with_cg_display(id, NonNull::from(&mut display_link))
-            != kCVReturnSuccess
-        {
-            return None;
-        }
-        let display_link = CFRetained::from_raw(NonNull::new(display_link).unwrap());
-        #[allow(deprecated)]
-        let time = display_link.nominal_output_video_refresh_period();
-
-        // This value is indefinite if an invalid display link was specified
-        if time.flags & CVTimeFlags::IsIndefinite.0 != 0 {
-            return None;
-        }
-
-        (time.timeScale as i64)
-            .checked_div(time.timeValue)
-            .map(|v| (v * 1000) as u32)
-            .and_then(NonZeroU32::new)
+    let refresh_rate = CGDisplayMode::refresh_rate(Some(&mode.0));
+    if refresh_rate > 0.0 {
+        return NonZeroU32::new((refresh_rate * 1000.0).round() as u32);
    }
+
+    let mut display_link = std::ptr::null_mut();
+    #[allow(deprecated)]
+    if unsafe { CVDisplayLink::create_with_cg_display(id, NonNull::from(&mut display_link)) }
+        != kCVReturnSuccess
+    {
+        return None;
+    }
+    let display_link = unsafe { CFRetained::from_raw(NonNull::new(display_link).unwrap()) };
+    #[allow(deprecated)]
+    let time = display_link.nominal_output_video_refresh_period();
+
+    // This value is indefinite if an invalid display link was specified
+    if time.flags & CVTimeFlags::IsIndefinite.0 != 0 {
+        return None;
+    }
+
+    (time.timeScale as i64)
+        .checked_div(time.timeValue)
+        .map(|v| (v * 1000) as u32)
+        .and_then(NonZeroU32::new)
 }

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

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

        let handle = MonitorHandle(CFUUID::new(None).unwrap());
        assert_eq!(handle.display_id(), 0);
--- a/src/platform_impl/apple/notification_center.rs
+++ b/src/platform_impl/apple/notification_center.rs
@@ -1,3 +1,4 @@
+// NOTE: This is symlinked to be contained in both the AppKit and UIKit implementations.
 use std::ptr::NonNull;

 use block2::RcBlock;
@@ -11,7 +12,7 @@ use objc2_foundation::{
 ///
 /// This is used in Winit as an alternative to declaring an application delegate, as we want to
 /// give the user full control over those.
-pub fn create_observer(
+pub(crate) fn create_observer(
    center: &NSNotificationCenter,
    name: &NSNotificationName,
    handler: impl Fn(&NSNotification) + 'static,
--- a/src/platform_impl/apple/appkit/observer.rs
+++ b/src/platform_impl/apple/appkit/observer.rs
@@ -4,61 +4,30 @@
 //! <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 objc2::MainThreadMarker;
 use objc2_core_foundation::{
-    kCFRunLoopCommonModes, kCFRunLoopDefaultMode, CFAbsoluteTimeGetCurrent, CFIndex, CFRetained,
-    CFRunLoop, CFRunLoopActivity, CFRunLoopObserver, CFRunLoopObserverCallBack,
-    CFRunLoopObserverContext, CFRunLoopTimer,
+    CFAbsoluteTimeGetCurrent, CFIndex, CFRetained, CFRunLoop, CFRunLoopActivity, CFRunLoopObserver,
+    CFRunLoopObserverCallBack, CFRunLoopObserverContext, CFRunLoopTimer, kCFRunLoopCommonModes,
+    kCFRunLoopDefaultMode,
 };
 use tracing::error;

 use super::app_state::AppState;
-use super::event_loop::{stop_app_on_panic, PanicInfo};
-
-unsafe fn control_flow_handler<F>(panic_info: *mut c_void, f: F)
-where
-    F: FnOnce(Weak<PanicInfo>) + UnwindSafe,
-{
-    let info_from_raw = unsafe { Weak::from_raw(panic_info as *mut PanicInfo) };
-    // Asserting unwind safety on this type should be fine because `PanicInfo` is
-    // `RefUnwindSafe` and `Rc<T>` is `UnwindSafe` if `T` is `RefUnwindSafe`.
-    let panic_info = AssertUnwindSafe(Weak::clone(&info_from_raw));
-    // `from_raw` takes ownership of the data behind the pointer.
-    // But if this scope takes ownership of the weak pointer, then
-    // the weak pointer will get free'd at the end of the scope.
-    // However we want to keep that weak reference around after the function.
-    std::mem::forget(info_from_raw);
-
-    let mtm = MainThreadMarker::new().unwrap();
-    stop_app_on_panic(mtm, Weak::clone(&panic_info), move || {
-        let _ = &panic_info;
-        f(panic_info.0)
-    });
-}

 // begin is queued with the highest priority to ensure it is processed before other observers
 extern "C-unwind" fn control_flow_begin_handler(
    _: *mut CFRunLoopObserver,
    activity: CFRunLoopActivity,
-    panic_info: *mut c_void,
+    _info: *mut c_void,
 ) {
-    unsafe {
-        control_flow_handler(panic_info, |panic_info| {
-            #[allow(non_upper_case_globals)]
-            match activity {
-                CFRunLoopActivity::AfterWaiting => {
-                    // trace!("Triggered `CFRunLoopAfterWaiting`");
-                    AppState::get(MainThreadMarker::new().unwrap()).wakeup(panic_info);
-                    // trace!("Completed `CFRunLoopAfterWaiting`");
-                },
-                _ => unreachable!(),
-            }
-        });
+    match activity {
+        CFRunLoopActivity::AfterWaiting => {
+            AppState::get(MainThreadMarker::new().unwrap()).wakeup();
+        },
+        _ => unreachable!(),
    }
 }

@@ -67,21 +36,14 @@ extern "C-unwind" fn control_flow_begin_handler(
 extern "C-unwind" fn control_flow_end_handler(
    _: *mut CFRunLoopObserver,
    activity: CFRunLoopActivity,
-    panic_info: *mut c_void,
+    _info: *mut c_void,
 ) {
-    unsafe {
-        control_flow_handler(panic_info, |panic_info| {
-            #[allow(non_upper_case_globals)]
-            match activity {
-                CFRunLoopActivity::BeforeWaiting => {
-                    // trace!("Triggered `CFRunLoopBeforeWaiting`");
-                    AppState::get(MainThreadMarker::new().unwrap()).cleared(panic_info);
-                    // trace!("Completed `CFRunLoopBeforeWaiting`");
-                },
-                CFRunLoopActivity::Exit => (), /* unimplemented!(), // not expected to ever happen */
-                _ => unreachable!(),
-            }
-        });
+    match activity {
+        CFRunLoopActivity::BeforeWaiting => {
+            AppState::get(MainThreadMarker::new().unwrap()).cleared();
+        },
+        CFRunLoopActivity::Exit => (), // unimplemented!(), // not expected to ever happen
+        _ => unreachable!(),
    }
 }

@@ -180,11 +142,11 @@ impl RunLoop {
    }
 }

-pub fn setup_control_flow_observers(mtm: MainThreadMarker, panic_info: Weak<PanicInfo>) {
+pub fn setup_control_flow_observers(mtm: MainThreadMarker) {
    let run_loop = RunLoop::main(mtm);
    unsafe {
        let mut context = CFRunLoopObserverContext {
-            info: Weak::into_raw(panic_info) as *mut _,
+            info: ptr::null_mut(),
            version: 0,
            retain: None,
            release: None,
--- a/src/platform_impl/apple/appkit/util.rs
+++ b/src/platform_impl/apple/appkit/util.rs
@@ -1,12 +1,14 @@
 use objc2_core_graphics::CGError;
 use tracing::trace;
+use winit_core::error::OsError;

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

 macro_rules! trace_scope {
    ($s:literal) => {
-        let _crate =
-            $crate::platform_impl::platform::appkit::util::TraceGuard::new(module_path!(), $s);
+        let _crate = $crate::util::TraceGuard::new(module_path!(), $s);
    };
 }

@@ -32,9 +34,5 @@ impl Drop for TraceGuard {

 #[track_caller]
 pub(crate) fn cgerr(err: CGError) -> Result<(), OsError> {
-    if err == CGError::Success {
-        Ok(())
-    } else {
-        Err(os_error!(format!("CGError {err:?}")))
-    }
+    if err == CGError::Success { Ok(()) } else { Err(os_error!(format!("CGError {err:?}"))) }
 }
--- a/src/platform_impl/apple/appkit/view.rs
+++ b/src/platform_impl/apple/appkit/view.rs
@@ -4,17 +4,25 @@ use std::collections::{HashMap, VecDeque};
 use std::ptr;
 use std::rc::Rc;

+use dpi::{LogicalPosition, LogicalSize};
 use objc2::rc::Retained;
 use objc2::runtime::{AnyObject, Sel};
-use objc2::{define_class, msg_send, DefinedClass, MainThreadMarker};
+use objc2::{DefinedClass, MainThreadMarker, define_class, msg_send};
 use objc2_app_kit::{
    NSApplication, NSCursor, NSEvent, NSEventPhase, NSResponder, NSTextInputClient,
    NSTrackingRectTag, NSView, NSWindow,
 };
+use objc2_core_foundation::CGRect;
 use objc2_foundation::{
    NSArray, NSAttributedString, NSAttributedStringKey, NSCopying, NSMutableAttributedString,
    NSNotFound, NSObject, NSPoint, NSRange, NSRect, NSSize, NSString, NSUInteger,
 };
+use winit_core::event::{
+    DeviceEvent, ElementState, Ime, KeyEvent, Modifiers, MouseButton, MouseScrollDelta,
+    PointerKind, PointerSource, TouchPhase, WindowEvent,
+};
+use winit_core::keyboard::{Key, KeyCode, KeyLocation, ModifiersState, NamedKey};
+use winit_core::window::ImeCapabilities;

 use super::app_state::AppState;
 use super::cursor::{default_cursor, invisible_cursor};
@@ -23,13 +31,7 @@ use super::event::{
    scancode_to_physicalkey,
 };
 use super::window::window_id;
-use crate::dpi::{LogicalPosition, LogicalSize};
-use crate::event::{
-    DeviceEvent, ElementState, Ime, KeyEvent, Modifiers, MouseButton, MouseScrollDelta,
-    PointerKind, PointerSource, TouchPhase, WindowEvent,
-};
-use crate::keyboard::{Key, KeyCode, KeyLocation, ModifiersState, NamedKey};
-use crate::platform::macos::OptionAsAlt;
+use crate::OptionAsAlt;

 #[derive(Debug)]
 struct CursorState {
@@ -124,7 +126,7 @@ pub struct ViewState {
    /// True iff the application wants IME events.
    ///
    /// Can be set using `set_ime_allowed`
-    ime_allowed: Cell<bool>,
+    ime_capabilities: Cell<Option<ImeCapabilities>>,

    /// True if the current key event should be forwarded
    /// to the application, even during IME
@@ -290,7 +292,7 @@ define_class!(
                self.queue_event(WindowEvent::Ime(Ime::Enabled));
            }

-            if unsafe { self.hasMarkedText() } {
+            if self.hasMarkedText() {
                self.ivars().ime_state.set(ImeState::Preedit);
            } else {
                // In case the preedit was cleared, set IME into the Ground state.
@@ -303,8 +305,8 @@ define_class!(
                None
            } else {
                // 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 sub_string_a = string.substringToIndex(selected_range.location);
+                let sub_string_b = string.substringToIndex(selected_range.end());
                let lowerbound_utf8 = sub_string_a.len();
                let upperbound_utf8 = sub_string_b.len();
                Some((lowerbound_utf8, upperbound_utf8))
@@ -360,9 +362,16 @@ define_class!(
            _actual_range: *mut NSRange,
        ) -> NSRect {
            trace_scope!("firstRectForCharacterRange:actualRange:");
+
+            // Guard when the view is no longer in a window during teardown.
+            let Some(window) = (**self).window() else {
+                return CGRect::ZERO;
+            };
+
+            // Return value is expected to be in screen coordinates, so we need a conversion
            let rect = NSRect::new(self.ivars().ime_position.get(), self.ivars().ime_size.get());
-            // Return value is expected to be in screen coordinates, so we need a conversion here
-            self.window().convertRectToScreen(self.convertRect_toView(rect, None))
+            let view_rect = self.convertRect_toView(rect, None);
+            window.convertRectToScreen(view_rect)
        }

        #[unsafe(method(insertText:replacementRange:))]
@@ -382,7 +391,7 @@ define_class!(
            let is_control = string.chars().next().is_some_and(|c| c.is_control());

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

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

-            if unsafe { self.hasMarkedText() } && self.ivars().ime_state.get() == ImeState::Preedit
-            {
+            if self.hasMarkedText() && self.ivars().ime_state.get() == ImeState::Preedit {
                // Leave preedit so that we also report the key-up for this key.
                self.ivars().ime_state.set(ImeState::Ground);
            }
@@ -456,9 +464,9 @@ define_class!(
            // we must send the `KeyboardInput` event during IME if it triggered
            // `doCommandBySelector`. (doCommandBySelector means that the keyboard input
            // is not handled by IME and should be handled by the application)
-            if self.ivars().ime_allowed.get() {
+            if self.ivars().ime_capabilities.get().is_some() {
                let events_for_nsview = NSArray::from_slice(&[&*event]);
-                unsafe { self.interpretKeyEvents(&events_for_nsview) };
+                self.interpretKeyEvents(&events_for_nsview);

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

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

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

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

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

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

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

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

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

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

@@ -797,7 +805,7 @@ impl WinitView {
            tracking_rect: Default::default(),
            ime_state: Default::default(),
            input_source: Default::default(),
-            ime_allowed: Default::default(),
+            ime_capabilities: Default::default(),
            forward_key_to_app: Default::default(),
            marked_text: Default::default(),
            accepts_first_mouse,
@@ -859,12 +867,13 @@ impl WinitView {
        }
    }

-    pub(super) fn set_ime_allowed(&self, ime_allowed: bool) {
-        if self.ivars().ime_allowed.get() == ime_allowed {
+    pub(super) fn set_ime_allowed(&self, capabilities: Option<ImeCapabilities>) {
+        if self.ivars().ime_capabilities.get().is_some() {
            return;
        }
-        self.ivars().ime_allowed.set(ime_allowed);
-        if self.ivars().ime_allowed.get() {
+        self.ivars().ime_capabilities.set(capabilities);
+
+        if capabilities.is_some() {
            return;
        }

@@ -877,6 +886,10 @@ impl WinitView {
        }
    }

+    pub(super) fn ime_capabilities(&self) -> Option<ImeCapabilities> {
+        self.ivars().ime_capabilities.get()
+    }
+
    pub(super) fn set_ime_cursor_area(&self, position: NSPoint, size: NSSize) {
        self.ivars().ime_position.set(position);
        self.ivars().ime_size.set(size);
@@ -917,8 +930,8 @@ impl WinitView {
        // later will work though, since the flags are attached to the event and contain valid
        // information.
        'send_event: {
-            if is_flags_changed_event && unsafe { ns_event.keyCode() } != 0 {
-                let scancode = unsafe { ns_event.keyCode() };
+            if is_flags_changed_event && ns_event.keyCode() != 0 {
+                let scancode = ns_event.keyCode();
                let physical_key = scancode_to_physicalkey(scancode as u32);

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

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

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

 // 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) -> Retained<NSEvent> {
-    let ev_mods = event_mods(event).state;
+    let ev_mods = event_mods(event).state();
    let ignore_alt_characters = match option_as_alt {
        OptionAsAlt::OnlyLeft if lalt_pressed(event) => true,
        OptionAsAlt::OnlyRight if ralt_pressed(event) => true,
@@ -1106,12 +1116,10 @@ fn replace_event(event: &NSEvent, option_as_alt: OptionAsAlt) -> Retained<NSEven
        && !ev_mods.meta_key();

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

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

 use dispatch2::MainThreadBound;
 use dpi::{Position, Size};
-use objc2::rc::{autoreleasepool, Retained};
-use objc2::{define_class, MainThreadMarker, Message};
+use objc2::rc::{Retained, autoreleasepool};
+use objc2::{MainThreadMarker, Message, define_class};
 use objc2_app_kit::{NSPanel, NSResponder, NSWindow};
 use objc2_foundation::NSObject;
+use winit_core::cursor::Cursor;
+use winit_core::error::RequestError;
+use winit_core::icon::Icon;
+use winit_core::monitor::{Fullscreen, MonitorHandle as CoreMonitorHandle};
+use winit_core::window::{
+    ImeCapabilities, ImeRequest, ImeRequestError, Theme, UserAttentionType, Window as CoreWindow,
+    WindowAttributes, WindowButtons, WindowId, WindowLevel,
+};

 use super::event_loop::ActiveEventLoop;
 use super::window_delegate::WindowDelegate;
-use crate::error::RequestError;
-use crate::monitor::{Fullscreen, MonitorHandle as CoreMonitorHandle};
-use crate::window::{
-    Cursor, Icon, ImePurpose, Theme, UserAttentionType, Window as CoreWindow, WindowAttributes,
-    WindowButtons, WindowId, WindowLevel,
-};

 #[derive(Debug)]
 pub(crate) struct Window {
@@ -91,7 +93,7 @@ impl rwh_06::HasWindowHandle for Window {
 }

 impl CoreWindow for Window {
-    fn id(&self) -> crate::window::WindowId {
+    fn id(&self) -> winit_core::window::WindowId {
        self.maybe_wait_on_main(|delegate| delegate.id())
    }

@@ -231,16 +233,12 @@ impl CoreWindow for Window {
        self.maybe_wait_on_main(|delegate| delegate.set_window_icon(window_icon));
    }

-    fn set_ime_cursor_area(&self, position: Position, size: Size) {
-        self.maybe_wait_on_main(|delegate| delegate.set_ime_cursor_area(position, size));
+    fn request_ime_update(&self, request: ImeRequest) -> Result<(), ImeRequestError> {
+        self.maybe_wait_on_main(|delegate| delegate.request_ime_update(request))
    }

-    fn set_ime_allowed(&self, allowed: bool) {
-        self.maybe_wait_on_main(|delegate| delegate.set_ime_allowed(allowed));
-    }
-
-    fn set_ime_purpose(&self, purpose: ImePurpose) {
-        self.maybe_wait_on_main(|delegate| delegate.set_ime_purpose(purpose));
+    fn ime_capabilities(&self) -> Option<ImeCapabilities> {
+        self.maybe_wait_on_main(|delegate| delegate.ime_capabilities())
    }

    fn focus_window(&self) {
@@ -279,7 +277,10 @@ impl CoreWindow for Window {
        self.maybe_wait_on_main(|delegate| delegate.set_cursor_position(position))
    }

-    fn set_cursor_grab(&self, mode: crate::window::CursorGrabMode) -> Result<(), RequestError> {
+    fn set_cursor_grab(
+        &self,
+        mode: winit_core::window::CursorGrabMode,
+    ) -> Result<(), RequestError> {
        self.maybe_wait_on_main(|delegate| delegate.set_cursor_grab(mode))
    }

@@ -293,7 +294,7 @@ impl CoreWindow for Window {

    fn drag_resize_window(
        &self,
-        direction: crate::window::ResizeDirection,
+        direction: winit_core::window::ResizeDirection,
    ) -> Result<(), RequestError> {
        Ok(self.maybe_wait_on_main(|delegate| delegate.drag_resize_window(direction))?)
    }
--- a/src/platform_impl/apple/appkit/window_delegate.rs
+++ b/src/platform_impl/apple/appkit/window_delegate.rs
@@ -6,97 +6,61 @@ use std::ptr;
 use std::rc::Rc;
 use std::sync::{Arc, Mutex};

-use objc2::rc::{autoreleasepool, Retained};
+use dpi::{
+    LogicalInsets, LogicalPosition, LogicalSize, PhysicalInsets, PhysicalPosition, PhysicalSize,
+    Position, Size,
+};
+use objc2::rc::{Retained, autoreleasepool};
 use objc2::runtime::{AnyObject, ProtocolObject};
 use objc2::{
-    available, define_class, msg_send, sel, ClassType, DefinedClass, MainThreadMarker,
-    MainThreadOnly, Message,
+    ClassType, DefinedClass, MainThreadMarker, MainThreadOnly, Message, available, define_class,
+    msg_send, sel,
 };
 use objc2_app_kit::{
    NSAppKitVersionNumber, NSAppKitVersionNumber10_12, NSAppearance, NSAppearanceCustomization,
    NSAppearanceNameAqua, NSApplication, NSApplicationPresentationOptions, NSBackingStoreType,
-    NSColor, NSDraggingDestination, NSDraggingInfo, NSFilenamesPboardType,
-    NSRequestUserAttentionType, NSScreen, NSToolbar, NSView, NSViewFrameDidChangeNotification,
-    NSWindow, NSWindowButton, NSWindowDelegate, NSWindowFullScreenButton, NSWindowLevel,
-    NSWindowOcclusionState, NSWindowOrderingMode, NSWindowSharingType, NSWindowStyleMask,
-    NSWindowTabbingMode, NSWindowTitleVisibility, NSWindowToolbarStyle,
+    NSColor, NSDraggingDestination, NSDraggingInfo, NSRequestUserAttentionType, NSScreen,
+    NSToolbar, NSView, NSViewFrameDidChangeNotification, NSWindow, NSWindowButton,
+    NSWindowDelegate, NSWindowLevel, NSWindowOcclusionState, NSWindowOrderingMode,
+    NSWindowSharingType, NSWindowStyleMask, NSWindowTabbingMode, NSWindowTitleVisibility,
+    NSWindowToolbarStyle,
 };
+#[allow(deprecated)]
+use objc2_app_kit::{NSFilenamesPboardType, NSWindowFullScreenButton};
 use objc2_core_foundation::{CGFloat, CGPoint};
 use objc2_core_graphics::{
-    kCGDisplayBlendNormal, kCGDisplayBlendSolidColor, kCGDisplayFadeReservationInvalidToken,
-    kCGFloatingWindowLevel, kCGNormalWindowLevel, CGAcquireDisplayFadeReservation,
-    CGAssociateMouseAndMouseCursorPosition, CGDisplayCapture, CGDisplayFade, CGDisplayRelease,
-    CGDisplaySetDisplayMode, CGReleaseDisplayFadeReservation,
+    CGAcquireDisplayFadeReservation, CGAssociateMouseAndMouseCursorPosition, CGDisplayCapture,
+    CGDisplayFade, CGDisplayRelease, CGDisplaySetDisplayMode, CGReleaseDisplayFadeReservation,
    CGRestorePermanentDisplayConfiguration, CGShieldingWindowLevel, CGWarpMouseCursorPosition,
+    kCGDisplayBlendNormal, kCGDisplayBlendSolidColor, kCGDisplayFadeReservationInvalidToken,
+    kCGFloatingWindowLevel, kCGNormalWindowLevel,
 };
 use objc2_foundation::{
-    ns_string, NSArray, NSDictionary, NSEdgeInsets, NSKeyValueChangeKey, NSKeyValueChangeNewKey,
+    NSArray, NSDictionary, NSEdgeInsets, NSKeyValueChangeKey, NSKeyValueChangeNewKey,
    NSKeyValueChangeOldKey, NSKeyValueObservingOptions, NSNotificationCenter, NSObject,
    NSObjectNSDelayedPerforming, NSObjectNSKeyValueObserverRegistration, NSObjectProtocol, NSPoint,
-    NSRect, NSSize, NSString,
+    NSRect, NSSize, NSString, ns_string,
 };
 use tracing::{trace, warn};
+use winit_core::cursor::Cursor;
+use winit_core::error::{NotSupportedError, RequestError};
+use winit_core::event::{SurfaceSizeWriter, WindowEvent};
+use winit_core::icon::Icon;
+use winit_core::monitor::{Fullscreen, MonitorHandle as CoreMonitorHandle, MonitorHandleProvider};
+use winit_core::window::{
+    CursorGrabMode, ImeCapabilities, ImeRequest, ImeRequestError, ResizeDirection, Theme,
+    UserAttentionType, WindowAttributes, WindowButtons, WindowId, WindowLevel,
+};

 use super::app_state::AppState;
-use super::cursor::{cursor_from_icon, CustomCursor};
-use super::monitor::{self, flip_window_screen_coordinates, get_display_id};
+use super::cursor::{CustomCursor, cursor_from_icon};
+use super::ffi;
+use super::monitor::{self, MonitorHandle, flip_window_screen_coordinates, get_display_id};
 use super::observer::RunLoop;
 use super::util::cgerr;
 use super::view::WinitView;
-use super::window::{window_id, WinitPanel, WinitWindow};
-use super::{ffi, MonitorHandle};
-use crate::dpi::{
-    LogicalInsets, LogicalPosition, LogicalSize, PhysicalInsets, PhysicalPosition, PhysicalSize,
-    Position, Size,
-};
-use crate::error::{NotSupportedError, RequestError};
-use crate::event::{SurfaceSizeWriter, WindowEvent};
-use crate::monitor::{Fullscreen, MonitorHandle as CoreMonitorHandle, MonitorHandleProvider};
-use crate::platform::macos::{OptionAsAlt, WindowExtMacOS};
-use crate::window::{
-    Cursor, CursorGrabMode, Icon, ImePurpose, ResizeDirection, Theme, UserAttentionType,
-    WindowAttributes, WindowButtons, WindowId, WindowLevel,
-};
-
-#[derive(Clone, Debug, PartialEq)]
-pub struct PlatformSpecificWindowAttributes {
-    pub movable_by_window_background: bool,
-    pub titlebar_transparent: bool,
-    pub title_hidden: bool,
-    pub titlebar_hidden: bool,
-    pub titlebar_buttons_hidden: bool,
-    pub fullsize_content_view: bool,
-    pub disallow_hidpi: bool,
-    pub has_shadow: bool,
-    pub accepts_first_mouse: bool,
-    pub tabbing_identifier: Option<String>,
-    pub option_as_alt: OptionAsAlt,
-    pub borderless_game: bool,
-    pub unified_titlebar: bool,
-    pub panel: bool,
-}
-
-impl Default for PlatformSpecificWindowAttributes {
-    #[inline]
-    fn default() -> Self {
-        Self {
-            movable_by_window_background: false,
-            titlebar_transparent: false,
-            title_hidden: false,
-            titlebar_hidden: false,
-            titlebar_buttons_hidden: false,
-            fullsize_content_view: false,
-            disallow_hidpi: false,
-            has_shadow: true,
-            accepts_first_mouse: true,
-            tabbing_identifier: None,
-            option_as_alt: Default::default(),
-            borderless_game: false,
-            unified_titlebar: false,
-            panel: false,
-        }
-    }
-}
+use super::window::{WinitPanel, WinitWindow, window_id};
+use crate::{OptionAsAlt, WindowAttributesMacOS, WindowExtMacOS};

 #[derive(Debug)]
 pub(crate) struct State {
@@ -388,18 +352,22 @@ define_class!(

            use std::path::PathBuf;

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

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

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

            use std::path::PathBuf;

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

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

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

-                trace!(old = %unsafe { old.name() }, new = %unsafe { new.name() }, "effectiveAppearance changed");
+                trace!(old = %old.name(), new = %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() {
+                if self.window().appearance().is_some() {
                    return;
                }

@@ -543,15 +515,14 @@ define_class!(

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

 fn new_window(
    app_state: &Rc<AppState>,
    attrs: &WindowAttributes,
+    macos_attrs: &WindowAttributesMacOS,
    mtm: MainThreadMarker,
 ) -> Option<Retained<NSWindow>> {
    autoreleasepool(|_| {
@@ -592,9 +563,7 @@ fn new_window(
            },
        };

-        let mut masks = if (!attrs.decorations && screen.is_none())
-            || attrs.platform_specific.titlebar_hidden
-        {
+        let mut masks = if (!attrs.decorations && screen.is_none()) || macos_attrs.titlebar_hidden {
            // Resizable without a titlebar or borders
            // if decorations is set to false, ignore pl_attrs
            //
@@ -622,7 +591,7 @@ fn new_window(
            masks &= !NSWindowStyleMask::Closable;
        }

-        if attrs.platform_specific.fullsize_content_view {
+        if macos_attrs.fullsize_content_view {
            // NOTE: If we decide to add an option to change this at runtime, we must emit a
            // `SurfaceResized` event to let applications know that the safe area changed.
            //
@@ -637,7 +606,7 @@ fn new_window(
        // confusing issues with the window not being properly activated.
        //
        // Winit ensures this by not allowing access to `ActiveEventLoop` before handling events.
-        let window: Retained<NSWindow> = if attrs.platform_specific.panel {
+        let window: Retained<NSWindow> = if macos_attrs.panel {
            masks |= NSWindowStyleMask::NonactivatingPanel;

            let window: Option<Retained<WinitPanel>> = unsafe {
@@ -673,7 +642,7 @@ fn new_window(
        window.setTitle(&NSString::from_str(&attrs.title));
        window.setAcceptsMouseMovedEvents(true);

-        if let Some(identifier) = &attrs.platform_specific.tabbing_identifier {
+        if let Some(identifier) = &macos_attrs.tabbing_identifier {
            window.setTabbingIdentifier(&NSString::from_str(identifier));
            window.setTabbingMode(NSWindowTabbingMode::Preferred);
        }
@@ -682,13 +651,13 @@ fn new_window(
            window.setSharingType(NSWindowSharingType::None);
        }

-        if attrs.platform_specific.titlebar_transparent {
+        if macos_attrs.titlebar_transparent {
            window.setTitlebarAppearsTransparent(true);
        }
-        if attrs.platform_specific.title_hidden {
+        if macos_attrs.title_hidden {
            window.setTitleVisibility(NSWindowTitleVisibility::Hidden);
        }
-        if attrs.platform_specific.titlebar_buttons_hidden {
+        if macos_attrs.titlebar_buttons_hidden {
            for titlebar_button in &[
                #[allow(deprecated)]
                NSWindowFullScreenButton,
@@ -701,16 +670,14 @@ fn new_window(
                }
            }
        }
-        if attrs.platform_specific.movable_by_window_background {
+        if macos_attrs.movable_by_window_background {
            window.setMovableByWindowBackground(true);
        }
-        if attrs.platform_specific.unified_titlebar {
-            unsafe {
-                // The toolbar style is ignored if there is no toolbar, so it is
-                // necessary to add one.
-                window.setToolbar(Some(&NSToolbar::new(mtm)));
-                window.setToolbarStyle(NSWindowToolbarStyle::Unified);
-            }
+        if macos_attrs.unified_titlebar {
+            // The toolbar style is ignored if there is no toolbar, so it is
+            // necessary to add one.
+            window.setToolbar(Some(&NSToolbar::new(mtm)));
+            window.setToolbarStyle(NSWindowToolbarStyle::Unified);
        }

        if !attrs.enabled_buttons.contains(WindowButtons::MAXIMIZE) {
@@ -719,7 +686,7 @@ fn new_window(
            }
        }

-        if !attrs.platform_specific.has_shadow {
+        if !macos_attrs.has_shadow {
            window.setHasShadow(false);
        }
        if attrs.position.is_none() {
@@ -728,8 +695,8 @@ fn new_window(

        let view = WinitView::new(
            app_state,
-            attrs.platform_specific.accepts_first_mouse,
-            attrs.platform_specific.option_as_alt,
+            macos_attrs.accepts_first_mouse,
+            macos_attrs.option_as_alt,
            mtm,
        );

@@ -737,7 +704,7 @@ fn new_window(
        // macos 10.14 and `true` after 10.15, we should set it to `YES` or `NO` to avoid
        // always the default system value in favour of the user's code
        #[allow(deprecated)]
-        view.setWantsBestResolutionOpenGLSurface(!attrs.platform_specific.disallow_hidpi);
+        view.setWantsBestResolutionOpenGLSurface(!macos_attrs.disallow_hidpi);

        // On Mojave, views automatically become layer-backed shortly after being added to
        // a window. Changing the layer-backedness of a view breaks the association between
@@ -759,7 +726,7 @@ fn new_window(
        view.setPostsFrameChangedNotifications(true);
        // `setPostsFrameChangedNotifications` posts the notification immediately, so register the
        // observer _after_, again so that the event isn't triggered initially.
-        let notification_center = unsafe { NSNotificationCenter::defaultCenter() };
+        let notification_center = NSNotificationCenter::defaultCenter();
        unsafe {
            notification_center.addObserver_selector_name_object(
                &view,
@@ -772,10 +739,11 @@ fn new_window(
        if attrs.transparent {
            window.setOpaque(false);
            // See `set_transparent` for details on why we do this.
-            window.setBackgroundColor(unsafe { Some(&NSColor::clearColor()) });
+            window.setBackgroundColor(Some(&NSColor::clearColor()));
        }

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

        Some(window)
@@ -785,13 +753,19 @@ fn new_window(
 impl WindowDelegate {
    pub(super) fn new(
        app_state: &Rc<AppState>,
-        attrs: WindowAttributes,
+        mut attrs: WindowAttributes,
        mtm: MainThreadMarker,
    ) -> Result<Retained<Self>, RequestError> {
-        let window = new_window(app_state, &attrs, mtm)
+        let macos_attrs = attrs
+            .platform
+            .take()
+            .and_then(|attrs| attrs.cast::<WindowAttributesMacOS>().ok())
+            .unwrap_or_default();
+
+        let window = new_window(app_state, &attrs, &macos_attrs, mtm)
            .ok_or_else(|| os_error!("couldn't create `NSWindow`"))?;

-        match attrs.parent_window.map(|handle| handle.0) {
+        match attrs.parent_window() {
            Some(rwh_06::RawWindowHandle::AppKit(handle)) => {
                // SAFETY: Caller ensures the pointer is valid or NULL
                // Unwrap is fine, since the pointer comes from `NonNull`.
@@ -823,7 +797,7 @@ impl WindowDelegate {
        let scale_factor = window.backingScaleFactor() as _;

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

        let delegate = mtm.alloc().set_ivars(State {
@@ -843,7 +817,7 @@ impl WindowDelegate {
            standard_frame: Cell::new(None),
            is_simple_fullscreen: Cell::new(false),
            saved_style: Cell::new(None),
-            is_borderless_game: Cell::new(attrs.platform_specific.borderless_game),
+            is_borderless_game: Cell::new(macos_attrs.borderless_game),
        });
        let delegate: Retained<WindowDelegate> = unsafe { msg_send![super(delegate), init] };

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1508,25 +1477,23 @@ impl WindowDelegate {
                self.ivars().save_presentation_opts.replace(Some(app.presentationOptions()));
            }

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

+            cgerr(CGDisplayCapture(display_id)).unwrap();
+
            let monitor = monitor.cast_ref::<MonitorHandle>().unwrap();
            let video_mode =
                match monitor.video_mode_handles().find(|mode| &mode.mode == video_mode) {
@@ -1534,25 +1501,25 @@ impl WindowDelegate {
                    None => return,
                };

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

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

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

-                let window_level = unsafe { CGShieldingWindowLevel() } as NSWindowLevel + 1;
+                let window_level = CGShieldingWindowLevel() as NSWindowLevel + 1;
                self.window().setLevel(window_level);
            },
            (Some(Fullscreen::Exclusive(monitor, _)), Some(Fullscreen::Borderless(_))) => {
@@ -1707,26 +1674,50 @@ impl WindowDelegate {
        // https://developer.apple.com/library/content/documentation/Cocoa/Conceptual/WinPanel/Tasks/SettingWindowTitle.html
    }

-    #[inline]
-    pub fn set_ime_cursor_area(&self, spot: Position, size: Size) {
-        let scale_factor = self.scale_factor();
-        let logical_spot = spot.to_logical(scale_factor);
-        let logical_spot = NSPoint::new(logical_spot.x, logical_spot.y);
+    pub fn request_ime_update(&self, request: ImeRequest) -> Result<(), ImeRequestError> {
+        let current_caps = self.view().ime_capabilities();
+        let request_data = match request {
+            ImeRequest::Enable(enable) => {
+                let (capabilities, request_data) = enable.into_raw();
+                if current_caps.is_some() {
+                    return Err(ImeRequestError::AlreadyEnabled);
+                }
+                self.view().set_ime_allowed(Some(capabilities));
+                request_data
+            },
+            ImeRequest::Update(request_data) => {
+                if current_caps.is_none() {
+                    return Err(ImeRequestError::NotEnabled);
+                }
+                request_data
+            },
+            ImeRequest::Disable => {
+                self.view().set_ime_allowed(None);
+                return Ok(());
+            },
+        };

-        let size = size.to_logical(scale_factor);
-        let size = NSSize::new(size.width, size.height);
+        if let Some((spot, size)) = request_data.cursor_area {
+            if self.view().ime_capabilities().unwrap().cursor_area() {
+                let scale_factor = self.scale_factor();
+                let logical_spot = spot.to_logical(scale_factor);
+                let logical_spot = NSPoint::new(logical_spot.x, logical_spot.y);

-        self.view().set_ime_cursor_area(logical_spot, size);
+                let size = size.to_logical(scale_factor);
+                let size = NSSize::new(size.width, size.height);
+                self.view().set_ime_cursor_area(logical_spot, size);
+            } else {
+                warn!("discarding IME cursor area update without capability enabled.");
+            }
+        }
+
+        Ok(())
    }

-    #[inline]
-    pub fn set_ime_allowed(&self, allowed: bool) {
-        self.view().set_ime_allowed(allowed);
+    pub fn ime_capabilities(&self) -> Option<ImeCapabilities> {
+        self.view().ime_capabilities()
    }

-    #[inline]
-    pub fn set_ime_purpose(&self, _purpose: ImePurpose) {}
-
    #[inline]
    pub fn focus_window(&self) {
        let mtm = MainThreadMarker::from(self);
@@ -1806,9 +1797,8 @@ impl WindowDelegate {
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -2064,11 +2045,7 @@ pub fn appearance_to_theme(appearance: &NSAppearance) -> Theme {
        dark_appearance_name(),
    ]));
    if let Some(best_match) = best_match {
-        if *best_match == *dark_appearance_name() {
-            Theme::Dark
-        } else {
-            Theme::Light
-        }
+        if *best_match == *dark_appearance_name() { Theme::Dark } else { Theme::Light }
    } else {
        warn!(?appearance, "failed to determine the theme of the appearance");
        // Default to light in this case
--- a/winit-common/Cargo.toml
+++ b/winit-common/Cargo.toml
@@ -0,0 +1,42 @@
+[package]
+description = "Winit implementation helpers"
+documentation = "https://docs.rs/winit-common"
+edition.workspace = true
+license.workspace = true
+name = "winit-common"
+repository.workspace = true
+rust-version.workspace = true
+version.workspace = true
+
+[features]
+# Event Handler
+event-handler = []
+
+# XKB
+wayland = ["dep:memmap2"]
+x11 = ["xkbcommon-dl?/x11", "dep:x11-dl"]
+xkb = ["dep:xkbcommon-dl", "dep:smol_str"]
+
+# CoreFoundation
+core-foundation = ["dep:objc2", "dep:objc2-core-foundation"]
+
+[dependencies]
+smol_str = { workspace = true, optional = true }
+tracing.workspace = true
+winit-core.workspace = true
+
+# XKB
+memmap2 = { workspace = true, optional = true }
+x11-dl = { workspace = true, optional = true }
+xkbcommon-dl = { workspace = true, optional = true }
+
+# CoreFoundation
+objc2 = { workspace = true, optional = true }
+objc2-core-foundation = { workspace = true, optional = true, features = [
+    "std",
+    "CFRunLoop",
+    "CFString",
+] }
+
+[package.metadata.docs.rs]
+all-features = true
--- a/winit-common/LICENSE
+++ b/winit-common/LICENSE
@@ -0,0 +1 @@
+../LICENSE
--- a/winit-common/README.md
+++ b/winit-common/README.md
@@ -0,0 +1 @@
+../README.md
--- a/winit-common/src/core_foundation/event_loop_proxy.rs
+++ b/winit-common/src/core_foundation/event_loop_proxy.rs
@@ -3,10 +3,9 @@ use std::sync::Arc;

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

 /// A waker that signals a `CFRunLoopSource` on the main thread.
 ///
@@ -15,7 +14,7 @@ use crate::event_loop::EventLoopProxyProvider;
 ///
 /// See <https://developer.apple.com/documentation/corefoundation/cfrunloopsource?language=objc>.
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub(crate) struct EventLoopProxy {
+pub struct EventLoopProxy {
    source: CFRetained<CFRunLoopSource>,
    /// Cached value of `CFRunLoopGetMain`.
    main_loop: CFRetained<CFRunLoop>,
@@ -29,7 +28,7 @@ impl EventLoopProxy {
    /// Create a new proxy, registering it to be performed on the main thread.
    ///
    /// The provided closure should call `proxy_wake_up` on the application.
-    pub(crate) fn new<F: Fn() + 'static>(mtm: MainThreadMarker, signaller: F) -> Self {
+    pub fn new<F: Fn() + 'static>(mtm: MainThreadMarker, signaller: F) -> Self {
        // We use an `Arc` here to make sure that the reference-counting of the signal container is
        // atomic (`Retained`/`CFRetained` would be valid alternatives too).
        let signaller = Arc::new(signaller);
@@ -100,8 +99,7 @@ impl EventLoopProxy {

    // FIXME(madsmtm): Use this on macOS too.
    // More difficult there, since the user can re-start the event loop.
-    #[cfg_attr(target_os = "macos", allow(dead_code))]
-    pub(crate) fn invalidate(&self) {
+    pub fn invalidate(&self) {
        // NOTE: We do NOT fire this on `Drop`, since we want the proxy to be cloneable, such that
        // we only need to register a single source even if there's multiple proxies in use.
        self.source.invalidate();
--- a/winit-common/src/core_foundation/mod.rs
+++ b/winit-common/src/core_foundation/mod.rs
@@ -0,0 +1,3 @@
+mod event_loop_proxy;
+
+pub use event_loop_proxy::*;
--- a/src/platform_impl/apple/event_handler.rs
+++ b/src/platform_impl/apple/event_handler.rs
@@ -1,12 +1,12 @@
 use std::cell::RefCell;
 use std::{fmt, mem};

-use crate::application::ApplicationHandler;
+use winit_core::application::ApplicationHandler;

 /// A helper type for storing a reference to `ApplicationHandler`, allowing interior mutable access
 /// to it within the execution of a closure.
 #[derive(Default)]
-pub(crate) struct EventHandler {
+pub struct EventHandler {
    /// This can be in the following states:
    /// - Not registered by the event loop, or terminated (None).
    /// - Present (Some(handler)).
@@ -26,7 +26,7 @@ impl fmt::Debug for EventHandler {
 }

 impl EventHandler {
-    pub(crate) fn new() -> Self {
+    pub fn new() -> Self {
        Self { inner: RefCell::new(None) }
    }

@@ -35,7 +35,7 @@ impl EventHandler {
    /// This is similar to using the `scoped-tls` or `scoped-tls-hkt` crates
    /// to store the handler in a thread local, such that it can be accessed
    /// from within the closure.
-    pub(crate) fn set<'handler, R>(
+    pub fn set<'handler, R>(
        &self,
        app: Box<dyn ApplicationHandler + 'handler>,
        closure: impl FnOnce() -> R,
@@ -104,18 +104,17 @@ impl EventHandler {
        // soundness.
    }

-    #[cfg(target_os = "macos")]
-    pub(crate) fn in_use(&self) -> bool {
+    pub fn in_use(&self) -> bool {
        self.inner.try_borrow().is_err()
    }

-    pub(crate) fn ready(&self) -> bool {
+    pub fn ready(&self) -> bool {
        matches!(self.inner.try_borrow().as_deref(), Ok(Some(_)))
    }

-    pub(crate) fn handle(&self, callback: impl FnOnce(&mut (dyn ApplicationHandler + '_))) {
+    pub fn handle(&self, callback: impl FnOnce(&mut (dyn ApplicationHandler + '_))) {
        match self.inner.try_borrow_mut().as_deref_mut() {
-            Ok(Some(ref mut user_app)) => {
+            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.
@@ -137,7 +136,7 @@ impl EventHandler {
        }
    }

-    pub(crate) fn terminate(&self) {
+    pub fn terminate(&self) {
        match self.inner.try_borrow_mut().as_deref_mut() {
            Ok(data @ Some(_)) => {
                let handler = data.take();
--- a/winit-common/src/lib.rs
+++ b/winit-common/src/lib.rs
@@ -0,0 +1,8 @@
+//! Winit implementation helpers.
+
+#[cfg(feature = "core-foundation")]
+pub mod core_foundation;
+#[cfg(feature = "event-handler")]
+pub mod event_handler;
+#[cfg(feature = "xkb")]
+pub mod xkb;
--- a/src/platform_impl/linux/common/xkb/compose.rs
+++ b/src/platform_impl/linux/common/xkb/compose.rs
@@ -12,7 +12,7 @@ use xkbcommon_dl::{
    xkb_compose_status, xkb_compose_table, xkb_keysym_t,
 };

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

 #[derive(Debug)]
 pub struct XkbComposeTable {
--- a/src/platform_impl/linux/common/xkb/keymap.rs
+++ b/src/platform_impl/linux/common/xkb/keymap.rs
@@ -4,20 +4,22 @@ use std::ffi::c_char;
 use std::ops::Deref;
 use std::ptr::{self, NonNull};

-#[cfg(x11_platform)]
+use winit_core::keyboard::{
+    Key, KeyCode, KeyLocation, NamedKey, NativeKey, NativeKeyCode, PhysicalKey,
+};
+#[cfg(feature = "x11")]
 use x11_dl::xlib_xcb::xcb_connection_t;
 use xkb::XKB_MOD_INVALID;
 use xkbcommon_dl::{
    self as xkb, xkb_keycode_t, xkb_keymap, xkb_keymap_compile_flags, xkb_keysym_t,
    xkb_layout_index_t, xkb_mod_index_t,
 };
-#[cfg(wayland_platform)]
+#[cfg(feature = "wayland")]
 use {memmap2::MmapOptions, std::os::unix::io::OwnedFd};

-use crate::keyboard::{Key, KeyCode, KeyLocation, NamedKey, NativeKey, NativeKeyCode, PhysicalKey};
-#[cfg(x11_platform)]
-use crate::platform_impl::common::xkb::XKBXH;
-use crate::platform_impl::common::xkb::{XkbContext, XKBH};
+#[cfg(feature = "x11")]
+use super::XKBXH;
+use super::{XKBH, XkbContext};

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

 impl XkbKeymap {
-    #[cfg(wayland_platform)]
+    #[cfg(feature = "wayland")]
    pub fn from_fd(context: &XkbContext, fd: OwnedFd, size: usize) -> Option<Self> {
        let map = unsafe { MmapOptions::new().len(size).map_copy_read_only(&fd).ok()? };

@@ -962,7 +998,7 @@ impl XkbKeymap {
        Some(Self::new_inner(keymap, 0))
    }

-    #[cfg(x11_platform)]
+    #[cfg(feature = "x11")]
    pub fn from_x11_keymap(
        context: &XkbContext,
        xcb: *mut xcb_connection_t,
@@ -995,7 +1031,7 @@ impl XkbKeymap {
        Self { keymap, _mods_indices: mods_indices, _core_keyboard_id }
    }

-    #[cfg(x11_platform)]
+    #[cfg(feature = "x11")]
    pub fn mods_indices(&self) -> ModsIndices {
        self._mods_indices
    }
@@ -1016,11 +1052,7 @@ impl XkbKeymap {
                &mut keysyms,
            );

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

@@ -1047,7 +1079,7 @@ impl Deref for XkbKeymap {
 }

 /// Modifier index in the keymap.
-#[cfg_attr(not(x11_platform), allow(dead_code))]
+#[cfg_attr(not(feature = "x11"), allow(dead_code))]
 #[derive(Default, Debug, Clone, Copy)]
 pub struct ModsIndices {
    pub shift: Option<xkb_mod_index_t>,
@@ -1064,10 +1096,6 @@ fn mod_index_for_name(keymap: NonNull<xkb_keymap>, name: &[u8]) -> Option<xkb_mo
    unsafe {
        let mod_index =
            (XKBH.xkb_keymap_mod_get_index)(keymap.as_ptr(), name.as_ptr() as *const c_char);
-        if mod_index == XKB_MOD_INVALID {
-            None
-        } else {
-            Some(mod_index)
-        }
+        if mod_index == XKB_MOD_INVALID { None } else { Some(mod_index) }
    }
 }
--- a/src/platform_impl/linux/common/xkb/mod.rs
+++ b/src/platform_impl/linux/common/xkb/mod.rs
@@ -1,31 +1,29 @@
 use std::ops::Deref;
 use std::os::raw::c_char;
-#[cfg(wayland_platform)]
+#[cfg(feature = "wayland")]
 use std::os::unix::io::OwnedFd;
 use std::ptr::{self, NonNull};
-use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::LazyLock;
+use std::sync::atomic::{AtomicBool, Ordering};

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

-use crate::event::{ElementState, KeyEvent};
-use crate::keyboard::{Key, KeyLocation};
-
 mod compose;
 mod keymap;
 mod state;

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

@@ -51,7 +49,7 @@ pub enum Error {
 #[derive(Debug)]
 pub struct Context {
    // NOTE: field order matters.
-    #[cfg(x11_platform)]
+    #[cfg(feature = "x11")]
    pub core_keyboard_id: i32,
    state: Option<XkbState>,
    keymap: Option<XkbKeymap>,
@@ -85,7 +83,7 @@ impl Context {
            keymap: None,
            compose_state1,
            compose_state2,
-            #[cfg(x11_platform)]
+            #[cfg(feature = "x11")]
            core_keyboard_id: 0,
            _compose_table: compose_table,
            context,
@@ -126,23 +124,23 @@ impl Context {
        self.keymap.as_mut()
    }

-    #[cfg(wayland_platform)]
+    #[cfg(feature = "wayland")]
    pub fn set_keymap_from_fd(&mut self, fd: OwnedFd, size: usize) {
        let keymap = XkbKeymap::from_fd(&self.context, fd, size);
        let state = keymap.as_ref().and_then(XkbState::new_wayland);
        if keymap.is_none() || state.is_none() {
-            warn!("failed to update xkb keymap");
+            tracing::warn!("failed to update xkb keymap");
        }
        self.state = state;
        self.keymap = keymap;
    }

-    #[cfg(x11_platform)]
+    #[cfg(feature = "x11")]
    pub fn set_keymap_from_x11(&mut self, xcb: *mut xcb_connection_t) {
        let keymap = XkbKeymap::from_x11_keymap(&self.context, xcb, self.core_keyboard_id);
        let state = keymap.as_ref().and_then(|keymap| XkbState::new_x11(xcb, keymap));
        if keymap.is_none() || state.is_none() {
-            warn!("failed to update xkb keymap");
+            tracing::warn!("failed to update xkb keymap");
        }
        self.state = state;
        self.keymap = keymap;
@@ -161,7 +159,7 @@ impl Context {
    /// Key builder context with the user provided xkb state.
    ///
    /// Should be used when the original context must not be altered.
-    #[cfg(x11_platform)]
+    #[cfg(feature = "x11")]
    pub fn key_context_with_state<'a>(
        &'a mut self,
        state: &'a mut XkbState,
@@ -312,11 +310,7 @@ impl<'a, 'b> KeyEventResults<'a, 'b> {
    fn keysym_to_key(&self, keysym: u32) -> Result<(Key, KeyLocation), (Key, KeyLocation)> {
        let location = keymap::keysym_location(keysym);
        let key = keymap::keysym_to_key(keysym);
-        if matches!(key, Key::Unidentified(_)) {
-            Err((key, location))
-        } else {
-            Ok((key, location))
-        }
+        if matches!(key, Key::Unidentified(_)) { Err((key, location)) } else { Ok((key, location)) }
    }

    pub fn text(&mut self) -> Option<SmolStr> {
--- a/src/platform_impl/linux/common/xkb/state.rs
+++ b/src/platform_impl/linux/common/xkb/state.rs
@@ -4,16 +4,16 @@ use std::os::raw::c_char;
 use std::ptr::NonNull;

 use smol_str::SmolStr;
-#[cfg(x11_platform)]
+#[cfg(feature = "x11")]
 use x11_dl::xlib_xcb::xcb_connection_t;
 use xkbcommon_dl::{
    self as xkb, xkb_keycode_t, xkb_keysym_t, xkb_layout_index_t, xkb_state, xkb_state_component,
 };

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

 #[derive(Debug)]
 pub struct XkbState {
@@ -22,13 +22,13 @@ pub struct XkbState {
 }

 impl XkbState {
-    #[cfg(wayland_platform)]
+    #[cfg(feature = "wayland")]
    pub fn new_wayland(keymap: &XkbKeymap) -> Option<Self> {
        let state = NonNull::new(unsafe { (XKBH.xkb_state_new)(keymap.as_ptr()) })?;
        Some(Self::new_inner(state))
    }

-    #[cfg(x11_platform)]
+    #[cfg(feature = "x11")]
    pub fn new_x11(xcb: *mut xcb_connection_t, keymap: &XkbKeymap) -> Option<Self> {
        let state = unsafe {
            (XKBXH.xkb_x11_state_new_from_device)(keymap.as_ptr(), xcb, keymap._core_keyboard_id)
@@ -52,7 +52,7 @@ impl XkbState {
        unsafe { (XKBH.xkb_state_key_get_layout)(self.state.as_ptr(), key) }
    }

-    #[cfg(x11_platform)]
+    #[cfg(feature = "x11")]
    pub fn depressed_modifiers(&mut self) -> xkb::xkb_mod_mask_t {
        unsafe {
            (XKBH.xkb_state_serialize_mods)(
@@ -62,7 +62,7 @@ impl XkbState {
        }
    }

-    #[cfg(x11_platform)]
+    #[cfg(feature = "x11")]
    pub fn latched_modifiers(&mut self) -> xkb::xkb_mod_mask_t {
        unsafe {
            (XKBH.xkb_state_serialize_mods)(
@@ -72,7 +72,7 @@ impl XkbState {
        }
    }

-    #[cfg(x11_platform)]
+    #[cfg(feature = "x11")]
    pub fn locked_modifiers(&mut self) -> xkb::xkb_mod_mask_t {
        unsafe {
            (XKBH.xkb_state_serialize_mods)(
@@ -153,12 +153,13 @@ impl Drop for XkbState {
    }
 }

-/// Represents the current state of the keyboard modifiers
+/// Represents the current logical state of the keyboard modifiers
 ///
 /// Each field of this struct represents a modifier and is `true` if this modifier is active.
 ///
-/// For some modifiers, this means that the key is currently pressed, others are toggled
-/// (like caps lock).
+/// For some modifiers, this means that the key is logically pressed, others are toggled (like Caps
+/// Lock). But physically the key can be in any state (for example, released Shift when
+/// it's active as a sticky modifier or released Caps Lock when it's toggled on)
 #[derive(Copy, Clone, Debug, Default, PartialEq, Eq)]
 pub struct ModifiersState {
    /// The "control" key
@@ -177,13 +178,13 @@ pub struct ModifiersState {
    pub num_lock: bool,
 }

-impl From<ModifiersState> for crate::keyboard::ModifiersState {
-    fn from(mods: ModifiersState) -> crate::keyboard::ModifiersState {
-        let mut to_mods = crate::keyboard::ModifiersState::empty();
-        to_mods.set(crate::keyboard::ModifiersState::SHIFT, mods.shift);
-        to_mods.set(crate::keyboard::ModifiersState::CONTROL, mods.ctrl);
-        to_mods.set(crate::keyboard::ModifiersState::ALT, mods.alt);
-        to_mods.set(crate::keyboard::ModifiersState::META, mods.logo);
+impl From<ModifiersState> for winit_core::keyboard::ModifiersState {
+    fn from(mods: ModifiersState) -> winit_core::keyboard::ModifiersState {
+        let mut to_mods = winit_core::keyboard::ModifiersState::empty();
+        to_mods.set(winit_core::keyboard::ModifiersState::SHIFT, mods.shift);
+        to_mods.set(winit_core::keyboard::ModifiersState::CONTROL, mods.ctrl);
+        to_mods.set(winit_core::keyboard::ModifiersState::ALT, mods.alt);
+        to_mods.set(winit_core::keyboard::ModifiersState::META, mods.logo);
        to_mods
    }
 }
--- a/winit-core/Cargo.toml
+++ b/winit-core/Cargo.toml
@@ -0,0 +1,39 @@
+[package]
+authors = ["The winit contributors", "Kirill Chibisov <contact@kchibisov.com>"]
+categories = ["gui"]
+description = "winit core API."
+documentation = "https://docs.rs/winit-core"
+edition.workspace = true
+keywords = ["windowing"]
+license.workspace = true
+name = "winit-core"
+readme = "README.md"
+repository.workspace = true
+rust-version.workspace = true
+version.workspace = true
+
+[features]
+serde = [
+    "dep:serde",
+    "bitflags/serde",
+    "cursor-icon/serde",
+    "dpi/serde",
+    "keyboard-types/serde",
+    "smol_str/serde",
+]
+
+[dependencies]
+bitflags.workspace = true
+cursor-icon.workspace = true
+dpi.workspace = true
+keyboard-types.workspace = true
+rwh_06.workspace = true
+serde = { workspace = true, optional = true }
+smol_str.workspace = true
+
+# `wasm32-unknown-unknown` and `wasm32-none`, but not `wasm32-wasi`.
+[target.'cfg(all(target_family = "wasm", any(target_os = "unknown", target_os = "none")))'.dependencies]
+web-time.workspace = true
+
+[dev-dependencies]
+winit.workspace = true
--- a/winit-core/LICENSE
+++ b/winit-core/LICENSE
@@ -0,0 +1 @@
+../LICENSE
--- a/winit-core/README.md
+++ b/winit-core/README.md
@@ -0,0 +1 @@
+../README.md
--- a/winit-core/src/application/macos.rs
+++ b/winit-core/src/application/macos.rs
@@ -0,0 +1,52 @@
+use crate::application::ApplicationHandler;
+use crate::event_loop::ActiveEventLoop;
+use crate::window::WindowId;
+
+/// Additional events on [`ApplicationHandler`] that are specific to macOS.
+///
+/// This can be registered with [`ApplicationHandler::macos_handler`].
+pub trait ApplicationHandlerExtMacOS: ApplicationHandler {
+    /// The system interpreted a keypress as a standard key binding command.
+    ///
+    /// Examples include inserting tabs and newlines, or moving the insertion point, see
+    /// [`NSStandardKeyBindingResponding`] for the full list of key bindings. They are often text
+    /// editing related.
+    ///
+    /// This corresponds to the [`doCommandBySelector:`] method on `NSTextInputClient`.
+    ///
+    /// The `action` parameter contains the string representation of the selector. Examples include
+    /// `"insertBacktab:"`, `"indent:"` and `"noop:"`.
+    ///
+    /// # Example
+    ///
+    /// ```ignore
+    /// impl ApplicationHandlerExtMacOS for App {
+    ///     fn standard_key_binding(
+    ///         &mut self,
+    ///         event_loop: &dyn ActiveEventLoop,
+    ///         window_id: WindowId,
+    ///         action: &str,
+    ///     ) {
+    ///         match action {
+    ///             "moveBackward:" => self.cursor.position -= 1,
+    ///             "moveForward:" => self.cursor.position += 1,
+    ///             _ => {} // Ignore other actions
+    ///         }
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// [`NSStandardKeyBindingResponding`]: https://developer.apple.com/documentation/appkit/nsstandardkeybindingresponding?language=objc
+    /// [`doCommandBySelector:`]: https://developer.apple.com/documentation/appkit/nstextinputclient/1438256-docommandbyselector?language=objc
+    #[doc(alias = "doCommandBySelector:")]
+    fn standard_key_binding(
+        &mut self,
+        event_loop: &dyn ActiveEventLoop,
+        window_id: WindowId,
+        action: &str,
+    ) {
+        let _ = event_loop;
+        let _ = window_id;
+        let _ = action;
+    }
+}
--- a/winit-core/src/application/mod.rs
+++ b/winit-core/src/application/mod.rs
@@ -2,21 +2,11 @@

 use crate::event::{DeviceEvent, DeviceId, StartCause, WindowEvent};
 use crate::event_loop::ActiveEventLoop;
-#[cfg(macos_platform)]
-use crate::platform::macos::ApplicationHandlerExtMacOS;
 use crate::window::WindowId;

+pub mod macos;
+
 /// The handler of application-level events.
-///
-/// See [the top-level docs] for example usage, and [`EventLoopProvider::run_app`] for an overview
-/// of when events are delivered.
-///
-/// This is [dropped] when the event loop is shut down. Note that this only works if you're passing
-/// the entire state to [`EventLoopProvider::run_app`] (passing `&mut app` won't work).
-///
-/// [the top-level docs]: crate
-/// [`EventLoopProvider::run_app`]: crate::event_loop::EventLoopProvider::run_app
-/// [dropped]: std::ops::Drop
 pub trait ApplicationHandler {
    /// Emitted when new events arrive from the OS to be processed.
    ///
@@ -135,8 +125,9 @@ pub trait ApplicationHandler {
    /// use std::thread;
    /// use std::time::Duration;
    ///
-    /// use winit::application::ApplicationHandler;
-    /// use winit::event_loop::{ActiveEventLoop, EventLoop, EventLoopProvider};
+    /// use winit::event_loop::EventLoop;
+    /// use winit_core::application::ApplicationHandler;
+    /// use winit_core::event_loop::ActiveEventLoop;
    ///
    /// struct MyApp {
    ///     receiver: mpsc::Receiver<u64>,
@@ -210,9 +201,7 @@ pub trait ApplicationHandler {

    /// Emitted when the OS sends an event to a device.
    ///
-    /// For this to be called, it must be enabled with [`EventLoopProvider::listen_device_events`].
-    ///
-    /// [`EventLoopProvider::listen_device_events`]: crate::event_loop::EventLoopProvider::listen_device_events
+    /// Whether device events are delivered depends on the backend in use.
    fn device_event(
        &mut self,
        event_loop: &dyn ActiveEventLoop,
@@ -350,9 +339,8 @@ pub trait ApplicationHandler {
    /// The macOS-specific handler.
    ///
    /// The return value from this should not change at runtime.
-    #[cfg(macos_platform)]
    #[inline(always)]
-    fn macos_handler(&mut self) -> Option<&mut dyn ApplicationHandlerExtMacOS> {
+    fn macos_handler(&mut self) -> Option<&mut dyn macos::ApplicationHandlerExtMacOS> {
        None
    }
 }
@@ -419,9 +407,8 @@ impl<A: ?Sized + ApplicationHandler> ApplicationHandler for &mut A {
        (**self).memory_warning(event_loop);
    }

-    #[cfg(macos_platform)]
    #[inline]
-    fn macos_handler(&mut self) -> Option<&mut dyn ApplicationHandlerExtMacOS> {
+    fn macos_handler(&mut self) -> Option<&mut dyn macos::ApplicationHandlerExtMacOS> {
        (**self).macos_handler()
    }
 }
@@ -488,9 +475,8 @@ impl<A: ?Sized + ApplicationHandler> ApplicationHandler for Box<A> {
        (**self).memory_warning(event_loop);
    }

-    #[cfg(macos_platform)]
    #[inline]
-    fn macos_handler(&mut self) -> Option<&mut dyn ApplicationHandlerExtMacOS> {
+    fn macos_handler(&mut self) -> Option<&mut dyn macos::ApplicationHandlerExtMacOS> {
        (**self).macos_handler()
    }
 }
--- a/winit-core/src/as_any.rs
+++ b/winit-core/src/as_any.rs
@@ -31,6 +31,7 @@ impl<T: Any> AsAny for T {
    }
 }

+#[macro_export]
 macro_rules! impl_dyn_casting {
    ($trait:ident) => {
        impl dyn $trait + '_ {
@@ -54,8 +55,7 @@ macro_rules! impl_dyn_casting {
            ///
            /// Returns `Err` with `self` if the object was not from that backend.
            pub fn cast<T: $trait>(self: Box<Self>) -> Result<Box<T>, Box<Self>> {
-                let reference: &dyn std::any::Any = self.__as_any();
-                if reference.is::<T>() {
+                if self.cast_ref::<T>().is_some() {
                    let this: Box<dyn std::any::Any> = self.__into_any();
                    // Unwrap is okay, we just checked the type of `self` is `T`.
                    Ok(this.downcast::<T>().unwrap())
@@ -67,4 +67,26 @@ macro_rules! impl_dyn_casting {
    };
 }

-pub(crate) use impl_dyn_casting;
+pub use impl_dyn_casting;
+
+#[cfg(test)]
+mod tests {
+    use super::AsAny;
+
+    struct Foo;
+    trait FooTrait: AsAny {}
+    impl FooTrait for Foo {}
+    impl_dyn_casting!(FooTrait);
+
+    #[test]
+    fn dyn_casting() {
+        let foo_owned: Box<dyn FooTrait> = Box::new(Foo);
+        assert!(foo_owned.cast::<Foo>().is_ok());
+
+        let mut foo = Foo;
+        let foo_ref: &mut dyn FooTrait = &mut foo;
+        assert!((foo_ref).cast_ref::<Foo>().is_some());
+        assert!((&&&&foo_ref).cast_ref::<Foo>().is_some());
+        assert!(foo_ref.cast_mut::<Foo>().is_some());
+    }
+}
--- a/winit-core/src/cursor.rs
+++ b/winit-core/src/cursor.rs
@@ -5,9 +5,10 @@ use std::ops::Deref;
 use std::sync::Arc;
 use std::time::Duration;

-use cursor_icon::CursorIcon;
+#[doc(inline)]
+pub use cursor_icon::CursorIcon;

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

 /// The maximum width and height for a cursor when using [`CustomCursorSource::from_rgba`].
 pub const MAX_CURSOR_SIZE: u16 = 2048;
@@ -50,10 +51,10 @@ impl From<CustomCursor> for Cursor {
 /// # Example
 ///
 /// ```no_run
-/// # use winit::event_loop::ActiveEventLoop;
-/// # use winit::window::Window;
+/// # use winit_core::event_loop::ActiveEventLoop;
+/// # use winit_core::window::Window;
 /// # fn scope(event_loop: &dyn ActiveEventLoop, window: &dyn Window) {
-/// use winit::window::CustomCursorSource;
+/// use winit_core::cursor::CustomCursorSource;
 ///
 /// let w = 10;
 /// let h = 10;
@@ -75,7 +76,7 @@ impl From<CustomCursor> for Cursor {
 /// # }
 /// ```
 #[derive(Clone, Debug)]
-pub struct CustomCursor(pub(crate) Arc<dyn CustomCursorProvider>);
+pub struct CustomCursor(pub Arc<dyn CustomCursorProvider>);

 pub trait CustomCursorProvider: AsAny + fmt::Debug + Send + Sync {
    /// Whether a cursor was backed by animation.
@@ -235,7 +236,6 @@ impl fmt::Display for BadAnimation {
 impl Error for BadAnimation {}

 #[derive(Debug, Clone, Eq, Hash, PartialEq)]
-#[allow(dead_code)]
 pub struct CursorImage {
    pub(crate) rgba: Vec<u8>,
    pub(crate) width: u16,
@@ -277,6 +277,30 @@ impl CursorImage {

        Ok(CursorImage { rgba, width, height, hotspot_x, hotspot_y })
    }
+
+    pub fn buffer(&self) -> &[u8] {
+        self.rgba.as_slice()
+    }
+
+    pub fn buffer_mut(&mut self) -> &mut [u8] {
+        self.rgba.as_mut_slice()
+    }
+
+    pub fn width(&self) -> u16 {
+        self.width
+    }
+
+    pub fn height(&self) -> u16 {
+        self.height
+    }
+
+    pub fn hotspot_x(&self) -> u16 {
+        self.hotspot_x
+    }
+
+    pub fn hotspot_y(&self) -> u16 {
+        self.hotspot_y
+    }
 }

 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -297,4 +321,16 @@ impl CursorAnimation {

        Ok(Self { duration, cursors })
    }
+
+    pub fn duration(&self) -> Duration {
+        self.duration
+    }
+
+    pub fn cursors(&self) -> &[CustomCursor] {
+        self.cursors.as_slice()
+    }
+
+    pub fn into_raw(self) -> (Duration, Vec<CustomCursor>) {
+        (self.duration, self.cursors)
+    }
 }
--- a/winit-core/src/error.rs
+++ b/winit-core/src/error.rs
@@ -19,7 +19,13 @@ pub enum EventLoopError {
 impl fmt::Display for EventLoopError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
-            Self::RecreationAttempt => write!(f, "EventLoop can't be recreated"),
+            Self::RecreationAttempt => {
+                write!(
+                    f,
+                    "EventLoop can't be recreated, only a single instance of it is supported (for \
+                     cross-platform compatibility)"
+                )
+            },
            Self::Os(err) => err.fmt(f),
            Self::ExitFailure(status) => write!(f, "Exit Failure: {status}"),
            Self::NotSupported(err) => err.fmt(f),
@@ -29,11 +35,7 @@ impl fmt::Display for EventLoopError {

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

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

@@ -100,7 +98,7 @@ pub struct NotSupportedError {
 }

 impl NotSupportedError {
-    pub(crate) fn new(reason: &'static str) -> Self {
+    pub fn new(reason: &'static str) -> Self {
        Self { reason }
    }
 }
@@ -121,8 +119,7 @@ pub struct OsError {
 }

 impl OsError {
-    #[allow(dead_code)]
-    pub(crate) fn new(
+    pub fn new(
        line: u32,
        file: &'static str,
        error: impl Into<Box<dyn Error + Send + Sync + 'static>>,
@@ -144,7 +141,5 @@ impl Error for OsError {

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

+use dpi::{PhysicalPosition, PhysicalSize};
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 use smol_str::SmolStr;
-#[cfg(web_platform)]
-use web_time::Instant;

-use crate::dpi::{PhysicalPosition, PhysicalSize};
+use crate::Instant;
 use crate::error::RequestError;
 use crate::event_loop::AsyncRequestSerial;
 use crate::keyboard::{self, ModifiersKeyState, ModifiersKeys, ModifiersState};
@@ -46,10 +46,6 @@ pub enum StartCause {
 #[derive(Debug, Clone, PartialEq)]
 pub enum WindowEvent {
    /// The activation token was delivered back and now could be used.
-    #[cfg_attr(not(any(x11_platform, wayland_platform)), allow(rustdoc::broken_intra_doc_links))]
-    /// Delivered in response to [`request_activation_token`].
-    ///
-    /// [`request_activation_token`]: crate::platform::startup_notify::WindowExtStartupNotify::request_activation_token
    ActivationTokenDone { serial: AsyncRequestSerial, token: ActivationToken },

    /// The size of the window's surface has changed.
@@ -271,7 +267,7 @@ pub enum WindowEvent {
    ///
    /// ## Platform-specific
    ///
-    /// - Only available on **macOS** and **iOS**.
+    /// - Only available on **macOS**, **iOS**, and **Wayland**.
    /// - On iOS, not recognized by default. It must be enabled when needed.
    PinchGesture {
        device_id: Option<DeviceId>,
@@ -287,7 +283,7 @@ pub enum WindowEvent {
    ///
    /// ## Platform-specific
    ///
-    /// - Only available on **iOS**.
+    /// - Only available on **iOS** and **Wayland**.
    /// - On iOS, not recognized by default. It must be enabled when needed.
    PanGesture {
        device_id: Option<DeviceId>,
@@ -323,7 +319,7 @@ pub enum WindowEvent {
    ///
    /// ## Platform-specific
    ///
-    /// - Only available on **macOS** and **iOS**.
+    /// - Only available on **macOS**, **iOS**, and **Wayland**.
    /// - On iOS, not recognized by default. It must be enabled when needed.
    RotationGesture {
        device_id: Option<DeviceId>,
@@ -442,6 +438,7 @@ pub enum PointerKind {
    ///
    /// **macOS:** Unsupported.
    Touch(FingerId),
+    TabletTool(TabletToolKind),
    Unknown,
 }

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

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

 impl ButtonSource {
-    /// Convert any [`ButtonSource`] to an equivalent [`MouseButton`]. If a pointer type has no
+    /// Try to convert a [`ButtonSource`] to an equivalent [`MouseButton`]. If a pointer type has no
    /// special handling in an application, this method can be used to handle it like any generic
    /// mouse input.
-    pub fn mouse_button(self) -> MouseButton {
+    pub fn mouse_button(self) -> Option<MouseButton> {
        match self {
-            ButtonSource::Mouse(mouse) => mouse,
-            ButtonSource::Touch { .. } => MouseButton::Left,
-            ButtonSource::Unknown(button) => match button {
-                0 => MouseButton::Left,
-                1 => MouseButton::Middle,
-                2 => MouseButton::Right,
-                3 => MouseButton::Back,
-                4 => MouseButton::Forward,
-                _ => MouseButton::Other(button),
-            },
+            ButtonSource::Mouse(mouse) => Some(mouse),
+            ButtonSource::Touch { .. } => Some(MouseButton::Left),
+            ButtonSource::TabletTool { button, .. } => button.into(),
+            ButtonSource::Unknown(_) => None,
        }
    }
 }
@@ -563,16 +570,14 @@ impl DeviceId {
    /// Convert the [`DeviceId`] into the underlying integer.
    ///
    /// This is useful if you need to pass the ID across an FFI boundary, or store it in an atomic.
-    #[allow(dead_code)]
-    pub(crate) const fn into_raw(self) -> i64 {
+    pub const fn into_raw(self) -> i64 {
        self.0
    }

    /// Construct a [`DeviceId`] from the underlying integer.
    ///
    /// This should only be called with integers returned from [`DeviceId::into_raw`].
-    #[allow(dead_code)]
-    pub(crate) const fn from_raw(id: i64) -> Self {
+    pub const fn from_raw(id: i64) -> Self {
        Self(id)
    }
 }
@@ -588,16 +593,14 @@ impl FingerId {
    /// Convert the [`FingerId`] into the underlying integer.
    ///
    /// This is useful if you need to pass the ID across an FFI boundary, or store it in an atomic.
-    #[allow(dead_code)]
-    pub(crate) const fn into_raw(self) -> usize {
+    pub const fn into_raw(self) -> usize {
        self.0
    }

    /// Construct a [`FingerId`] from the underlying integer.
    ///
    /// This should only be called with integers returned from [`FingerId::into_raw`].
-    #[allow(dead_code)]
-    pub(crate) const fn from_raw(id: usize) -> Self {
+    pub const fn from_raw(id: usize) -> Self {
        Self(id)
    }
 }
@@ -622,17 +625,8 @@ pub enum DeviceEvent {
    /// ## Platform-specific
    ///
    /// **Web:** Only returns raw data, not OS accelerated, if [`CursorGrabMode::Locked`] is used
-    /// and browser support is available, see
-    #[cfg_attr(
-        web_platform,
-        doc = "[`ActiveEventLoopExtWeb::is_cursor_lock_raw()`][crate::platform::web::ActiveEventLoopExtWeb::is_cursor_lock_raw()]."
-    )]
-    #[cfg_attr(
-        not(web_platform),
-        doc = "`ActiveEventLoopExtWeb::is_cursor_lock_raw()`."
-    )]
+    /// and browser support is available.
    ///
-    #[rustfmt::skip]
    /// [`CursorGrabMode::Locked`]: crate::window::CursorGrabMode::Locked
    PointerMotion {
        /// (x, y) change in position in unspecified units.
@@ -765,12 +759,12 @@ pub struct KeyEvent {
    ///
    /// # Example
    ///
-    /// In games, you often want to ignore repated key events - this can be
+    /// In games, you often want to ignore repeated key events - this can be
    /// done by ignoring events where this property is set.
    ///
    /// ```no_run
-    /// use winit::event::{ElementState, KeyEvent, WindowEvent};
-    /// use winit::keyboard::{KeyCode, PhysicalKey};
+    /// use winit_core::event::{ElementState, KeyEvent, WindowEvent};
+    /// use winit_core::keyboard::{KeyCode, PhysicalKey};
    /// # let window_event = WindowEvent::RedrawRequested; // To make the example compile
    /// match window_event {
    ///     WindowEvent::KeyboardInput {
@@ -790,9 +784,10 @@ pub struct KeyEvent {
    /// ```
    pub repeat: bool,

-    /// Similar to [`text`][Self::text], except that this is affected by <kbd>Ctrl</kbd>.
+    /// Similar to [`text`][Self::text], except that this is affected by <kbd>Ctrl</kbd> and may
+    /// produce ASCII control characters.
    ///
-    /// For example, pressing <kbd>Ctrl</kbd>+<kbd>a</kbd> produces `Some("\x01")`.
+    /// For example, pressing <kbd>Ctrl</kbd>+<kbd>space</kbd> produces `Some("\x00")`.
    ///
    /// ## Platform-specific
    ///
@@ -825,54 +820,59 @@ pub struct KeyEvent {
 pub struct Modifiers {
    pub(crate) state: ModifiersState,

-    // NOTE: Currently pressed modifiers keys.
+    // NOTE: Currently active modifiers keys (logically, but not necessarily physically, pressed).
    //
    // The field providing a metadata, it shouldn't be used as a source of truth.
    pub(crate) pressed_mods: ModifiersKeys,
 }

 impl Modifiers {
-    /// The state of the modifiers.
+    /// Create a new modifiers from state and pressed mods.
+    pub fn new(state: ModifiersState, pressed_mods: ModifiersKeys) -> Self {
+        Self { state, pressed_mods }
+    }
+
+    /// The logical state of the modifiers.
    pub fn state(&self) -> ModifiersState {
        self.state
    }

-    /// The state of the left shift key.
+    /// The logical state of the left shift key.
    pub fn lshift_state(&self) -> ModifiersKeyState {
        self.mod_state(ModifiersKeys::LSHIFT)
    }

-    /// The state of the right shift key.
+    /// The logical state of the right shift key.
    pub fn rshift_state(&self) -> ModifiersKeyState {
        self.mod_state(ModifiersKeys::RSHIFT)
    }

-    /// The state of the left alt key.
+    /// The logical state of the left alt key.
    pub fn lalt_state(&self) -> ModifiersKeyState {
        self.mod_state(ModifiersKeys::LALT)
    }

-    /// The state of the right alt key.
+    /// The logical state of the right alt key.
    pub fn ralt_state(&self) -> ModifiersKeyState {
        self.mod_state(ModifiersKeys::RALT)
    }

-    /// The state of the left control key.
+    /// The logical state of the left control key.
    pub fn lcontrol_state(&self) -> ModifiersKeyState {
        self.mod_state(ModifiersKeys::LCONTROL)
    }

-    /// The state of the right control key.
+    /// The logical state of the right control key.
    pub fn rcontrol_state(&self) -> ModifiersKeyState {
        self.mod_state(ModifiersKeys::RCONTROL)
    }

-    /// The state of the left super key.
+    /// The logical state of the left super key.
    pub fn lsuper_state(&self) -> ModifiersKeyState {
        self.mod_state(ModifiersKeys::LMETA)
    }

-    /// The state of the right super key.
+    /// The logical state of the right super key.
    pub fn rsuper_state(&self) -> ModifiersKeyState {
        self.mod_state(ModifiersKeys::RMETA)
    }
@@ -894,6 +894,8 @@ impl From<ModifiersState> for Modifiers {

 /// Describes [input method](https://en.wikipedia.org/wiki/Input_method) events.
 ///
+/// The `Ime` events must be applied in the order they arrive.
+///
 /// This is also called a "composition event".
 ///
 /// Most keypresses using a latin-like keyboard layout simply generate a
@@ -950,7 +952,7 @@ pub enum Ime {
    /// position. When it's `None`, the cursor should be hidden. When `String` is an empty string
    /// this indicates that preedit was cleared.
    ///
-    /// The cursor position is byte-wise indexed.
+    /// The cursor position is byte-wise indexed, assuming UTF-8.
    Preedit(String, Option<(usize, usize)>),

    /// Notifies when text should be inserted into the editor widget.
@@ -958,6 +960,20 @@ pub enum Ime {
    /// Right before this event winit will send empty [`Self::Preedit`] event.
    Commit(String),

+    /// Delete text surrounding the cursor or selection.
+    ///
+    /// This event does not affect either the pre-edit string.
+    /// This means that the application must first remove the pre-edit,
+    /// then execute the deletion, then insert the removed text back.
+    ///
+    /// This event assumes text is stored in UTF-8.
+    DeleteSurrounding {
+        /// Bytes to remove before the selection
+        before_bytes: usize,
+        /// Bytes to remove after the selection
+        after_bytes: usize,
+    },
+
    /// Notifies when the IME was disabled.
    ///
    /// After receiving this event you won't get any more [`Preedit`][Self::Preedit] or
@@ -980,6 +996,7 @@ pub enum TouchPhase {
 /// Describes the force of a touch event
 #[derive(Debug, Clone, Copy, PartialEq)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[doc(alias = "Pressure")]
 pub enum Force {
    /// On iOS, the force is calibrated so that the same number corresponds to
    /// roughly the same amount of pressure on the screen regardless of the
@@ -990,7 +1007,7 @@ pub enum Force {
        ///
        /// The force reported by Apple Pencil is measured along the axis of the
        /// pencil. If you want a force perpendicular to the device, you need to
-        /// calculate this value using the `altitude_angle` value.
+        /// calculate this value using the [`TabletToolAngle::altitude`] value.
        force: f64,
        /// The maximum possible force for a touch.
        ///
@@ -1011,9 +1028,17 @@ impl Force {
    /// Instead of normalizing the force, you should prefer to handle
    /// [`Force::Calibrated`] so that the amount of force the user has to apply is
    /// consistent across devices.
-    pub fn normalized(&self) -> f64 {
+    ///
+    /// Passing in a [`TabletToolAngle`], returns the perpendicular force.
+    pub fn normalized(&self, angle: Option<TabletToolAngle>) -> f64 {
        match self {
-            Force::Calibrated { force, max_possible_force } => force / max_possible_force,
+            Force::Calibrated { force, max_possible_force } => {
+                let force = match angle {
+                    Some(TabletToolAngle { altitude, .. }) => force / altitude.sin(),
+                    None => *force,
+                };
+                force / max_possible_force
+            },
            Force::Normalized(force) => *force,
        }
    }
@@ -1025,6 +1050,260 @@ pub type AxisId = u32;
 /// Identifier for a specific button on some device.
 pub type ButtonId = u32;

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

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

+impl From<TabletToolButton> for Option<MouseButton> {
+    fn from(tool: TabletToolButton) -> Self {
+        Some(match tool {
+            TabletToolButton::Contact => MouseButton::Left,
+            TabletToolButton::Barrel => MouseButton::Right,
+            TabletToolButton::Other(1) => MouseButton::Middle,
+            TabletToolButton::Other(3) => MouseButton::Back,
+            TabletToolButton::Other(4) => MouseButton::Forward,
+            TabletToolButton::Other(_) => return None,
+        })
+    }
+}
+
 /// Describes a difference in the mouse scroll wheel state.
 #[derive(Debug, Clone, Copy, PartialEq)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
@@ -1091,8 +1485,7 @@ pub struct SurfaceSizeWriter {
 }

 impl SurfaceSizeWriter {
-    #[cfg(not(orbital_platform))]
-    pub(crate) fn new(new_surface_size: Weak<Mutex<PhysicalSize<u32>>>) -> Self {
+    pub fn new(new_surface_size: Weak<Mutex<PhysicalSize<u32>>>) -> Self {
        Self { new_surface_size }
    }

@@ -1108,6 +1501,15 @@ impl SurfaceSizeWriter {
            Err(RequestError::Ignored)
        }
    }
+
+    /// Get the currently stashed surface size.
+    pub fn surface_size(&self) -> Result<PhysicalSize<u32>, RequestError> {
+        if let Some(inner) = self.new_surface_size.upgrade() {
+            Ok(*inner.lock().unwrap())
+        } else {
+            Err(RequestError::Ignored)
+        }
+    }
 }

 impl PartialEq for SurfaceSizeWriter {
@@ -1122,7 +1524,8 @@ impl Eq for SurfaceSizeWriter {}
 mod tests {
    use std::collections::{BTreeSet, HashSet};

-    use crate::dpi::PhysicalPosition;
+    use dpi::PhysicalPosition;
+
    use crate::event;

    macro_rules! foreach_event {
@@ -1178,7 +1581,7 @@ mod tests {
                primary: true,
                state: event::ElementState::Pressed,
                position: (0, 0).into(),
-                button: event::MouseButton::Other(0).into(),
+                button: event::ButtonSource::Unknown(0),
            });
            with_window_event(PointerButton {
                device_id: None,
@@ -1231,16 +1634,85 @@ mod tests {
        });
    }

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

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

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

    #[allow(clippy::clone_on_copy)]
--- a/winit-core/src/event_loop/mod.rs
+++ b/winit-core/src/event_loop/mod.rs
@@ -1,132 +1,39 @@
-//! The [`EventLoop`] struct and assorted supporting types, including
-//! [`ControlFlow`].
-//!
-//! If you want to send custom events to the event loop, use
-//! [`EventLoop::create_proxy`] to acquire an [`EventLoopProxy`] and call its
-//! [`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::sync::atomic::{AtomicUsize, Ordering};
+pub mod never_return;
+pub mod pump_events;
+pub mod register;
+pub mod run_on_demand;
+
+use std::fmt::{self, Debug};
 use std::sync::Arc;
-#[cfg(not(web_platform))]
-use std::time::{Duration, Instant};
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::time::Duration;

 use rwh_06::{DisplayHandle, HandleError, HasDisplayHandle};
-#[cfg(web_platform)]
-use web_time::{Duration, Instant};

-use crate::application::ApplicationHandler;
-use crate::error::{EventLoopError, RequestError};
+use crate::Instant;
+use crate::as_any::AsAny;
+use crate::cursor::{CustomCursor, CustomCursorSource};
+use crate::error::RequestError;
 use crate::monitor::MonitorHandle;
-pub use crate::platform::event_loop::*;
-use crate::utils::{impl_dyn_casting, AsAny};
-use crate::window::{CustomCursor, CustomCursorSource, Theme, Window, WindowAttributes};
-
-/// Common interface to describe event loop.
-pub trait EventLoopProvider: AsAny + fmt::Debug {
-    /// Run the application with the event loop on the calling thread.
-    ///
-    /// ## Event loop flow
-    ///
-    /// This function internally handles the different parts of a traditional event-handling loop.
-    /// You can imagine this method as being implemented like this:
-    ///
-    /// ```rust,ignore
-    /// let mut start_cause = StartCause::Init;
-    ///
-    /// // Run the event loop.
-    /// while !event_loop.exiting() {
-    ///     // Wake up.
-    ///     app.new_events(event_loop, start_cause);
-    ///
-    ///     // Indicate that surfaces can now safely be created.
-    ///     if start_cause == StartCause::Init {
-    ///         app.can_create_surfaces(event_loop);
-    ///     }
-    ///
-    ///     // Handle proxy wake-up event.
-    ///     if event_loop.proxy_wake_up_set() {
-    ///         event_loop.proxy_wake_up_clear();
-    ///         app.proxy_wake_up(event_loop);
-    ///     }
-    ///
-    ///     // Handle actions done by the user / system such as moving the cursor, resizing the
-    ///     // window, changing the window theme, etc.
-    ///     for event in event_loop.events() {
-    ///         match event {
-    ///             window event => app.window_event(event_loop, window_id, event),
-    ///             device event => app.device_event(event_loop, device_id, event),
-    ///         }
-    ///     }
-    ///
-    ///     // Handle redraws.
-    ///     for window_id in event_loop.pending_redraws() {
-    ///         app.window_event(event_loop, window_id, WindowEvent::RedrawRequested);
-    ///     }
-    ///
-    ///     // Done handling events, wait until we're woken up again.
-    ///     app.about_to_wait(event_loop);
-    ///     start_cause = event_loop.wait_if_necessary();
-    /// }
-    ///
-    /// // Finished running, drop application state.
-    /// drop(app);
-    /// ```
-    ///
-    /// This is of course a very coarse-grained overview, and leaves out timing details like
-    /// [`ControlFlow::WaitUntil`] and life-cycle methods like [`ApplicationHandler::resumed`], but
-    /// it should give you an idea of how things fit together.
-    ///
-    /// ## Platform-specific
-    ///
-    /// - **iOS:** Will never return to the caller and so values not passed to this function will
-    ///   *not* be dropped before the process exits.
-    /// - **Web:** Will _act_ as if it never returns to the caller by throwing a Javascript
-    ///   exception (that Rust doesn't see) that will also mean that the rest of the function is
-    ///   never executed and any values not passed to this function will *not* be dropped.
-    ///
-    ///   Web applications are recommended to use
-    #[cfg_attr(
-        web_platform,
-        doc = "  [`EventLoopExtWeb::spawn_app()`][crate::platform::web::EventLoopExtWeb::spawn_app()]"
-    )]
-    #[cfg_attr(not(web_platform), doc = "  `EventLoopExtWeb::spawn_app()`")]
-    ///   [^1] instead of [`run_app()`] to avoid the need for the Javascript exception trick, and to
-    ///   make   it clearer that the event loop runs asynchronously (via the browser's own,
-    ///   internal, event   loop) and doesn't block the current thread of execution like it does
-    ///   on other platforms.
-    ///
-    ///   This function won't be available with `target_feature = "exception-handling"`.
-    ///
-    /// [^1]: `spawn_app()` is only available on the Web platform.
-    ///
-    /// [`set_control_flow()`]: ActiveEventLoop::set_control_flow()
-    /// [`run_app()`]: Self::run_app()
-    fn run_app(self, app: impl ApplicationHandler) -> Result<(), EventLoopError>
-    where
-        Self: Sized;
+use crate::window::{Theme, Window, WindowAttributes};

+pub trait ActiveEventLoop: AsAny + fmt::Debug {
    /// Creates an [`EventLoopProxy`] that can be used to dispatch user events
    /// to the main event loop, possibly from another thread.
    fn create_proxy(&self) -> EventLoopProxy;

-    /// Gets a persistent reference to the underlying platform display.
+    /// Create the window.
    ///
-    /// See the [`OwnedDisplayHandle`] type for more information.
-    fn owned_display_handle(&self) -> OwnedDisplayHandle;
-
-    /// Change if or when [`DeviceEvent`]s are captured.
+    /// Possible causes of error include denied permission, incompatible system, and lack of memory.
    ///
-    /// See [`ActiveEventLoop::listen_device_events`] for details.
+    /// ## Platform-specific
    ///
-    /// [`DeviceEvent`]: crate::event::DeviceEvent
-    fn listen_device_events(&self, allowed: DeviceEvents);
-
-    /// Sets the [`ControlFlow`].
-    fn set_control_flow(&self, control_flow: ControlFlow);
+    /// - **Web:** The window is created but not inserted into the Web page automatically. Please
+    ///   see the Web platform module for more information.
+    fn create_window(
+        &self,
+        window_attributes: WindowAttributes,
+    ) -> Result<Box<dyn Window>, RequestError>;

    /// Create custom cursor.
    ///
@@ -137,9 +44,169 @@ pub trait EventLoopProvider: AsAny + fmt::Debug {
        &self,
        custom_cursor: CustomCursorSource,
    ) -> Result<CustomCursor, RequestError>;
+
+    /// Returns the list of all the monitors available on the system.
+    ///
+    /// ## Platform-specific
+    ///
+    /// **Web:** Only returns the current monitor without `detailed monitor permissions`.
+    fn available_monitors(&self) -> Box<dyn Iterator<Item = MonitorHandle>>;
+
+    /// Returns the primary monitor of the system.
+    ///
+    /// Returns `None` if it can't identify any monitor as a primary one.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **Wayland:** Always returns `None`.
+    /// - **Web:** Always returns `None` without `detailed monitor permissions`.
+    fn primary_monitor(&self) -> Option<MonitorHandle>;
+
+    /// Change if or when [`DeviceEvent`]s are captured.
+    ///
+    /// Since the [`DeviceEvent`] capture can lead to high CPU usage for unfocused windows, winit
+    /// will ignore them by default for unfocused windows on Linux/BSD. This method allows changing
+    /// this at runtime to explicitly capture them again.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **Wayland / macOS / iOS / Android / Orbital:** Unsupported.
+    ///
+    /// [`DeviceEvent`]: crate::event::DeviceEvent
+    fn listen_device_events(&self, allowed: DeviceEvents);
+
+    /// Returns the current system theme.
+    ///
+    /// Returns `None` if it cannot be determined on the current platform.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **iOS / Android / Wayland / x11 / Orbital:** Unsupported.
+    fn system_theme(&self) -> Option<Theme>;
+
+    /// Sets the [`ControlFlow`].
+    fn set_control_flow(&self, control_flow: ControlFlow);
+
+    /// Gets the current [`ControlFlow`].
+    fn control_flow(&self) -> ControlFlow;
+
+    /// Stop the event loop.
+    ///
+    /// ## Platform-specific
+    ///
+    /// ### iOS
+    ///
+    /// It is not possible to programmatically exit/quit an application on iOS, so this function is
+    /// a no-op there. See also [this technical Q&A][qa1561].
+    ///
+    /// [qa1561]: https://developer.apple.com/library/archive/qa/qa1561/_index.html
+    fn exit(&self);
+
+    /// Returns whether the [`ActiveEventLoop`] is about to stop.
+    ///
+    /// Set by [`exit()`][Self::exit].
+    fn exiting(&self) -> bool;
+
+    /// Gets a persistent reference to the underlying platform display.
+    ///
+    /// See the [`OwnedDisplayHandle`] type for more information.
+    fn owned_display_handle(&self) -> OwnedDisplayHandle;
+
+    /// Get the raw-window-handle handle.
+    fn rwh_06_handle(&self) -> &dyn HasDisplayHandle;
 }

-impl_dyn_casting!(EventLoopProvider);
+impl HasDisplayHandle for dyn ActiveEventLoop + '_ {
+    fn display_handle(&self) -> Result<DisplayHandle<'_>, HandleError> {
+        self.rwh_06_handle().display_handle()
+    }
+}
+
+impl_dyn_casting!(ActiveEventLoop);
+
+/// Control the [`ActiveEventLoop`], possibly from a different thread, without referencing it
+/// directly.
+#[derive(Clone, Debug)]
+pub struct EventLoopProxy {
+    pub(crate) proxy: Arc<dyn EventLoopProxyProvider>,
+}
+
+impl EventLoopProxy {
+    /// Wake up the [`ActiveEventLoop`], 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`]: crate::application::ApplicationHandler::proxy_wake_up
+    /// [`ApplicationHandler::proxy_wake_up()`]: crate::application::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.proxy.wake_up();
+    }
+
+    pub fn new(proxy: Arc<dyn EventLoopProxyProvider>) -> Self {
+        Self { proxy }
+    }
+}
+
+pub trait EventLoopProxyProvider: Send + Sync + Debug {
+    /// See [`EventLoopProxy::wake_up`] for details.
+    fn wake_up(&self);
+}
+
+/// A proxy for the underlying display handle.
+///
+/// The purpose of this type is to provide a cheaply cloneable handle to the underlying
+/// display handle. This is often used by graphics APIs to connect to the underlying APIs.
+/// It is difficult to keep a handle to the underlying event loop type or the [`ActiveEventLoop`]
+/// type. In contrast, this type involves no lifetimes and can be persisted for as long as
+/// needed.
+///
+/// For all platforms, this is one of the following:
+///
+/// - A zero-sized type that is likely optimized out.
+/// - A reference-counted pointer to the underlying type.
+#[derive(Clone)]
+pub struct OwnedDisplayHandle {
+    pub(crate) handle: Arc<dyn HasDisplayHandle>,
+}
+
+impl OwnedDisplayHandle {
+    pub fn new(handle: Arc<dyn HasDisplayHandle>) -> Self {
+        Self { handle }
+    }
+}
+
+impl HasDisplayHandle for OwnedDisplayHandle {
+    fn display_handle(&self) -> Result<DisplayHandle<'_>, HandleError> {
+        self.handle.display_handle()
+    }
+}
+
+impl fmt::Debug for OwnedDisplayHandle {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("OwnedDisplayHandle").finish_non_exhaustive()
+    }
+}
+
+impl PartialEq for OwnedDisplayHandle {
+    fn eq(&self, other: &Self) -> bool {
+        match (self.display_handle(), other.display_handle()) {
+            (Ok(lhs), Ok(rhs)) => lhs == rhs,
+            _ => false,
+        }
+    }
+}
+
+impl Eq for OwnedDisplayHandle {}

 /// Set through [`ActiveEventLoop::set_control_flow()`].
 ///
@@ -186,205 +253,6 @@ impl ControlFlow {
    }
 }

-pub trait ActiveEventLoop: AsAny + fmt::Debug {
-    /// Creates an [`EventLoopProxy`] that can be used to dispatch user events
-    /// to the main event loop, possibly from another thread.
-    fn create_proxy(&self) -> EventLoopProxy;
-
-    /// Create the window.
-    ///
-    /// Possible causes of error include denied permission, incompatible system, and lack of memory.
-    ///
-    /// ## Platform-specific
-    ///
-    /// - **Web:** The window is created but not inserted into the Web page automatically. Please
-    ///   see the Web platform module for more information.
-    fn create_window(
-        &self,
-        window_attributes: WindowAttributes,
-    ) -> Result<Box<dyn Window>, RequestError>;
-
-    /// Create custom cursor.
-    ///
-    /// ## Platform-specific
-    ///
-    /// **iOS / Android / Orbital:** Unsupported.
-    fn create_custom_cursor(
-        &self,
-        custom_cursor: CustomCursorSource,
-    ) -> Result<CustomCursor, RequestError>;
-
-    /// Returns the list of all the monitors available on the system.
-    ///
-    /// ## Platform-specific
-    ///
-    /// **Web:** Only returns the current monitor without
-    #[cfg_attr(
-        web_platform,
-        doc = "[detailed monitor permissions][crate::platform::web::ActiveEventLoopExtWeb::request_detailed_monitor_permission]."
-    )]
-    #[cfg_attr(not(web_platform), doc = "detailed monitor permissions.")]
-    fn available_monitors(&self) -> Box<dyn Iterator<Item = MonitorHandle>>;
-
-    /// Returns the primary monitor of the system.
-    ///
-    /// Returns `None` if it can't identify any monitor as a primary one.
-    ///
-    /// ## Platform-specific
-    ///
-    /// - **Wayland:** Always returns `None`.
-    /// - **Web:** Always returns `None` without
-    #[cfg_attr(
-        web_platform,
-        doc = "  [detailed monitor permissions][crate::platform::web::ActiveEventLoopExtWeb::request_detailed_monitor_permission]."
-    )]
-    #[cfg_attr(not(web_platform), doc = "  detailed monitor permissions.")]
-    fn primary_monitor(&self) -> Option<MonitorHandle>;
-
-    /// Change if or when [`DeviceEvent`]s are captured.
-    ///
-    /// Since the [`DeviceEvent`] capture can lead to high CPU usage for unfocused windows, winit
-    /// will ignore them by default for unfocused windows on Linux/BSD. This method allows changing
-    /// this at runtime to explicitly capture them again.
-    ///
-    /// ## Platform-specific
-    ///
-    /// - **Wayland / macOS / iOS / Android / Orbital:** Unsupported.
-    ///
-    /// [`DeviceEvent`]: crate::event::DeviceEvent
-    fn listen_device_events(&self, allowed: DeviceEvents);
-
-    /// Returns the current system theme.
-    ///
-    /// Returns `None` if it cannot be determined on the current platform.
-    ///
-    /// ## Platform-specific
-    ///
-    /// - **iOS / Android / Wayland / x11 / Orbital:** Unsupported.
-    fn system_theme(&self) -> Option<Theme>;
-
-    /// Sets the [`ControlFlow`].
-    fn set_control_flow(&self, control_flow: ControlFlow);
-
-    /// Gets the current [`ControlFlow`].
-    fn control_flow(&self) -> ControlFlow;
-
-    /// Stop the event loop.
-    ///
-    /// ## Platform-specific
-    ///
-    /// ### iOS
-    ///
-    /// It is not possible to programmatically exit/quit an application on iOS, so this function is
-    /// a no-op there. See also [this technical Q&A][qa1561].
-    ///
-    /// [qa1561]: https://developer.apple.com/library/archive/qa/qa1561/_index.html
-    fn exit(&self);
-
-    /// Returns whether the [`EventLoop`] is about to stop.
-    ///
-    /// Set by [`exit()`][Self::exit].
-    fn exiting(&self) -> bool;
-
-    /// Gets a persistent reference to the underlying platform display.
-    ///
-    /// See the [`OwnedDisplayHandle`] type for more information.
-    fn owned_display_handle(&self) -> OwnedDisplayHandle;
-
-    /// Get the raw-window-handle handle.
-    fn rwh_06_handle(&self) -> &dyn HasDisplayHandle;
-}
-
-impl HasDisplayHandle for dyn ActiveEventLoop + '_ {
-    fn display_handle(&self) -> Result<DisplayHandle<'_>, HandleError> {
-        self.rwh_06_handle().display_handle()
-    }
-}
-
-impl_dyn_casting!(ActiveEventLoop);
-
-/// A proxy for the underlying display handle.
-///
-/// The purpose of this type is to provide a cheaply cloneable handle to the underlying
-/// display handle. This is often used by graphics APIs to connect to the underlying APIs.
-/// It is difficult to keep a handle to the [`EventLoop`] type or the [`ActiveEventLoop`]
-/// type. In contrast, this type involves no lifetimes and can be persisted for as long as
-/// needed.
-///
-/// For all platforms, this is one of the following:
-///
-/// - A zero-sized type that is likely optimized out.
-/// - A reference-counted pointer to the underlying type.
-#[derive(Clone)]
-pub struct OwnedDisplayHandle {
-    pub(crate) handle: Arc<dyn HasDisplayHandle>,
-}
-
-impl OwnedDisplayHandle {
-    pub(crate) fn new(handle: Arc<dyn HasDisplayHandle>) -> Self {
-        Self { handle }
-    }
-}
-
-impl HasDisplayHandle for OwnedDisplayHandle {
-    fn display_handle(&self) -> Result<DisplayHandle<'_>, HandleError> {
-        self.handle.display_handle()
-    }
-}
-
-impl fmt::Debug for OwnedDisplayHandle {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("OwnedDisplayHandle").finish_non_exhaustive()
-    }
-}
-
-impl PartialEq for OwnedDisplayHandle {
-    fn eq(&self, other: &Self) -> bool {
-        match (self.display_handle(), other.display_handle()) {
-            (Ok(lhs), Ok(rhs)) => lhs == rhs,
-            _ => false,
-        }
-    }
-}
-
-impl Eq for OwnedDisplayHandle {}
-
-pub(crate) trait EventLoopProxyProvider: Send + Sync + fmt::Debug {
-    /// See [`EventLoopProxy::wake_up`] for details.
-    fn wake_up(&self);
-}
-
-/// Control the [`EventLoop`], possibly from a different thread, without referencing it directly.
-#[derive(Clone, Debug)]
-pub struct EventLoopProxy {
-    pub(crate) proxy: Arc<dyn EventLoopProxyProvider>,
-}
-
-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.proxy.wake_up();
-    }
-
-    pub(crate) fn new(proxy: Arc<dyn EventLoopProxyProvider>) -> Self {
-        Self { proxy }
-    }
-}
-
 /// Control when device events are captured.
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Default)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -413,9 +281,7 @@ pub struct AsyncRequestSerial {
 }

 impl AsyncRequestSerial {
-    // TODO(kchibisov): Remove `cfg` when the clipboard will be added.
-    #[allow(dead_code)]
-    pub(crate) fn get() -> Self {
+    pub fn get() -> Self {
        static CURRENT_SERIAL: AtomicUsize = AtomicUsize::new(0);
        // NOTE: We rely on wrap around here, while the user may just request
        // in the loop usize::MAX times that's issue is considered on them.
--- a/winit-core/src/event_loop/never_return.rs
+++ b/winit-core/src/event_loop/never_return.rs
@@ -0,0 +1,14 @@
+use crate::application::ApplicationHandler;
+
+/// Additional methods on `EventLoop` for platforms whose run method never return.
+pub trait EventLoopExtNeverReturn {
+    /// Run the event loop and call `process::exit` once finished.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **iOS**: This registers the callbacks with the system and calls `UIApplicationMain`.
+    /// - **macOS**: Unimplemented (TODO: Should call `NSApplicationMain`).
+    /// - **Android/Orbital/Wayland/Windows/X11**: Unsupported.
+    /// - **Web**: Impossible to support properly.
+    fn run_app_never_return<A: ApplicationHandler + 'static>(self, app: A) -> !;
+}
--- a/winit-core/src/event_loop/pump_events.rs
+++ b/winit-core/src/event_loop/pump_events.rs
@@ -1,8 +1,8 @@
 use std::time::Duration;

 use crate::application::ApplicationHandler;
-use crate::event_loop::EventLoop;

+#[allow(rustdoc::broken_intra_doc_links)] // FIXME(madsmtm): Fix these.
 /// Additional methods on [`EventLoop`] for pumping events within an external event loop
 pub trait EventLoopExtPumpEvents {
    /// Pump the `EventLoop` to check for and dispatch pending events.
@@ -99,23 +99,11 @@ 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(
+    fn pump_app_events<A: ApplicationHandler>(
        &mut self,
        timeout: Option<Duration>,
-        app: impl ApplicationHandler,
-    ) -> PumpStatus
-    where
-        Self: Sized;
-}
-
-impl EventLoopExtPumpEvents for EventLoop {
-    fn pump_app_events(
-        &mut self,
-        timeout: Option<Duration>,
-        app: impl ApplicationHandler,
-    ) -> PumpStatus {
-        self.event_loop.pump_app_events(timeout, app)
-    }
+        app: A,
+    ) -> PumpStatus;
 }

 /// The return status for `pump_events`
--- a/winit-core/src/event_loop/register.rs
+++ b/winit-core/src/event_loop/register.rs
@@ -0,0 +1,17 @@
+use crate::application::ApplicationHandler;
+
+/// Additional methods on `EventLoop` that registers it with the system event loop.
+pub trait EventLoopExtRegister {
+    /// Initialize and register the application with the system's event loop, such that the
+    /// callbacks will be run later.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **Web**: Once the event loop has been destroyed, it's possible to reinitialize another
+    ///   event loop by calling this function again. This can be useful if you want to recreate the
+    ///   event loop while the WebAssembly module is still loaded. For example, this can be used to
+    ///   recreate the event loop when switching between tabs on a single page application.
+    /// - **iOS/macOS**: Unimplemented.
+    /// - **Android/Orbital/Wayland/Windows/X11**: Unsupported.
+    fn register_app<A: ApplicationHandler + 'static>(self, app: A);
+}
--- a/winit-core/src/event_loop/run_on_demand.rs
+++ b/winit-core/src/event_loop/run_on_demand.rs
@@ -1,19 +1,18 @@
 use crate::application::ApplicationHandler;
 use crate::error::EventLoopError;
-use crate::event_loop::EventLoop;
 #[cfg(doc)]
 use crate::{
-    event_loop::ActiveEventLoop, platform::pump_events::EventLoopExtPumpEvents, window::Window,
+    event_loop::{ActiveEventLoop, pump_events::EventLoopExtPumpEvents},
+    window::Window,
 };

 /// Additional methods on [`EventLoop`] to return control flow to the caller.
 pub trait EventLoopExtRunOnDemand {
    /// Run the application with the event loop on the calling thread.
    ///
-    /// Unlike [`EventLoopProvider::run_app()`], this function accepts non-`'static` (i.e.
-    /// non-`move`) closures and it is possible to return control back to the caller without
-    /// consuming the `EventLoop` (by using [`exit()`]) and
-    /// so the event loop can be re-run after it has exit.
+    /// Unlike [`EventLoop::run_app`], this function accepts non-`'static` (i.e. non-`move`)
+    /// state and it is possible to return control back to the caller without consuming the
+    /// `EventLoop` (by using [`exit()`]) and so the event loop can be re-run after it has exit.
    ///
    /// It's expected that each run of the loop will be for orthogonal instantiations of your
    /// Winit application, but internally each instantiation may re-use some common window
@@ -30,18 +29,11 @@ pub trait EventLoopExtRunOnDemand {
    ///
    /// # Caveats
    /// - This extension isn't available on all platforms, since it's not always possible to return
-    ///   to the caller (specifically this is impossible on iOS and Web - though with the Web
-    ///   backend it is possible to use
-    #[cfg_attr(
-        web_platform,
-        doc = "  [`EventLoopExtWeb::spawn_app()`][crate::platform::web::EventLoopExtWeb::spawn_app()]"
-    )]
-    #[cfg_attr(not(web_platform), doc = "  `EventLoopExtWeb::spawn_app()`")]
-    ///   [^1] more than once instead).
+    ///   to the caller (specifically this is impossible on iOS and Web).
    /// - No [`Window`] state can be carried between separate runs of the event loop.
    ///
-    /// You are strongly encouraged to use [`EventLoopProvider::run_app()`] for portability, unless
-    /// you specifically need the ability to re-run a single event loop more than once
+    /// You are strongly encouraged to use [`EventLoop::run_app()`] for portability, unless you
+    /// specifically need the ability to re-run a single event loop more than once
    ///
    /// # Supported Platforms
    /// - Windows
@@ -56,31 +48,7 @@ pub trait EventLoopExtRunOnDemand {
    ///   are delivered via callbacks based on an event loop that is internal to the browser itself.
    /// - **iOS:** It's not possible to stop and start an `UIApplication` repeatedly on iOS.
    ///
-    /// [^1]: `spawn_app()` is only available on the Web platforms.
-    ///
    /// [`exit()`]: ActiveEventLoop::exit()
    /// [`set_control_flow()`]: ActiveEventLoop::set_control_flow()
-    /// [`EventLoopProvider::run_app()`]: crate::event_loop::EventLoopProvider::run_app
-    fn run_app_on_demand(&mut self, app: impl ApplicationHandler) -> Result<(), EventLoopError>
-    where
-        Self: Sized;
+    fn run_app_on_demand<A: ApplicationHandler>(&mut self, app: A) -> Result<(), EventLoopError>;
 }
-
-impl EventLoopExtRunOnDemand for EventLoop {
-    fn run_app_on_demand(&mut self, app: impl ApplicationHandler) -> Result<(), EventLoopError> {
-        self.event_loop.run_app_on_demand(app)
-    }
-}
-
-/// ```compile_fail
-/// use winit::event_loop::EventLoop;
-/// use winit::platform::run_on_demand::EventLoopExtRunOnDemand;
-///
-/// let mut event_loop = EventLoop::new().unwrap();
-/// event_loop.run_on_demand(|_, _| {
-///     // Attempt to run the event loop re-entrantly; this must fail.
-///     event_loop.run_on_demand(|_, _| {});
-/// });
-/// ```
-#[allow(dead_code)]
-fn test_run_on_demand_cannot_access_event_loop() {}
--- a/winit-core/src/icon.rs
+++ b/winit-core/src/icon.rs
@@ -1,30 +1,29 @@
 use std::error::Error;
+use std::ops::Deref;
 use std::sync::Arc;
 use std::{fmt, io, mem};

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

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

 /// An icon used for the window titlebar, taskbar, etc.
-#[allow(dead_code)]
 #[derive(Debug, Clone)]
-pub struct Icon(pub(crate) Arc<dyn IconProvider>);
+pub struct Icon(pub Arc<dyn IconProvider>);

 // TODO remove that once split.
 pub trait IconProvider: AsAny + fmt::Debug + Send + Sync {}

-impl_dyn_casting!(IconProvider);
+impl Deref for Icon {
+    type Target = dyn IconProvider;

-#[repr(C)]
-#[derive(Debug)]
-pub(crate) struct Pixel {
-    pub(crate) r: u8,
-    pub(crate) g: u8,
-    pub(crate) b: u8,
-    pub(crate) a: u8,
+    fn deref(&self) -> &Self::Target {
+        self.0.as_ref()
+    }
 }

+impl_dyn_casting!(IconProvider);
+
 #[derive(Debug)]
 /// An error produced when using [`RgbaIcon::new`] with invalid arguments.
 pub enum BadIcon {
@@ -61,7 +60,7 @@ impl fmt::Display for BadIcon {

 impl Error for BadIcon {}

-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct RgbaIcon {
    pub(crate) width: u32,
    pub(crate) height: u32,
--- a/winit-core/src/keyboard.rs
+++ b/winit-core/src/keyboard.rs
@@ -0,0 +1,473 @@
+//! Types related to the keyboard.
+
+use bitflags::bitflags;
+pub use keyboard_types::{Code as KeyCode, Location as KeyLocation, NamedKey};
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+pub use smol_str::SmolStr;
+
+/// Contains the platform-native physical key identifier
+///
+/// The exact values vary from platform to platform (which is part of why this is a per-platform
+/// enum), but the values are primarily tied to the key's physical location on the keyboard.
+///
+/// This enum is primarily used to store raw keycodes when Winit doesn't map a given native
+/// physical key identifier to a meaningful [`KeyCode`] variant. In the presence of identifiers we
+/// haven't mapped for you yet, this lets you use use [`KeyCode`] to:
+///
+/// - Correctly match key press and release events.
+/// - On non-Web platforms, support assigning keybinds to virtually any key through a UI.
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub enum NativeKeyCode {
+    Unidentified,
+    /// An Android "scancode".
+    Android(u32),
+    /// A macOS "scancode".
+    MacOS(u16),
+    /// A Windows "scancode".
+    Windows(u16),
+    /// An XKB "keycode".
+    Xkb(u32),
+}
+
+impl std::fmt::Debug for NativeKeyCode {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        use NativeKeyCode::{Android, MacOS, Unidentified, Windows, Xkb};
+        let mut debug_tuple;
+        match self {
+            Unidentified => {
+                debug_tuple = f.debug_tuple("Unidentified");
+            },
+            Android(code) => {
+                debug_tuple = f.debug_tuple("Android");
+                debug_tuple.field(&format_args!("0x{code:04X}"));
+            },
+            MacOS(code) => {
+                debug_tuple = f.debug_tuple("MacOS");
+                debug_tuple.field(&format_args!("0x{code:04X}"));
+            },
+            Windows(code) => {
+                debug_tuple = f.debug_tuple("Windows");
+                debug_tuple.field(&format_args!("0x{code:04X}"));
+            },
+            Xkb(code) => {
+                debug_tuple = f.debug_tuple("Xkb");
+                debug_tuple.field(&format_args!("0x{code:04X}"));
+            },
+        }
+        debug_tuple.finish()
+    }
+}
+
+/// Contains the platform-native logical key identifier
+///
+/// Exactly what that means differs from platform to platform, but the values are to some degree
+/// tied to the currently active keyboard layout. The same key on the same keyboard may also report
+/// different values on different platforms, which is one of the reasons this is a per-platform
+/// enum.
+///
+/// This enum is primarily used to store raw keysym when Winit doesn't map a given native logical
+/// key identifier to a meaningful [`Key`] variant. This lets you use [`Key`], and let the user
+/// define keybinds which work in the presence of identifiers we haven't mapped for you yet.
+#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub enum NativeKey {
+    Unidentified,
+    /// An Android "keycode", which is similar to a "virtual-key code" on Windows.
+    Android(u32),
+    /// A macOS "scancode". There does not appear to be any direct analogue to either keysyms or
+    /// "virtual-key" codes in macOS, so we report the scancode instead.
+    MacOS(u16),
+    /// A Windows "virtual-key code".
+    Windows(u16),
+    /// An XKB "keysym".
+    Xkb(u32),
+    /// A "key value string".
+    Web(SmolStr),
+}
+
+impl std::fmt::Debug for NativeKey {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        use NativeKey::{Android, MacOS, Unidentified, Web, Windows, Xkb};
+        let mut debug_tuple;
+        match self {
+            Unidentified => {
+                debug_tuple = f.debug_tuple("Unidentified");
+            },
+            Android(code) => {
+                debug_tuple = f.debug_tuple("Android");
+                debug_tuple.field(&format_args!("0x{code:04X}"));
+            },
+            MacOS(code) => {
+                debug_tuple = f.debug_tuple("MacOS");
+                debug_tuple.field(&format_args!("0x{code:04X}"));
+            },
+            Windows(code) => {
+                debug_tuple = f.debug_tuple("Windows");
+                debug_tuple.field(&format_args!("0x{code:04X}"));
+            },
+            Xkb(code) => {
+                debug_tuple = f.debug_tuple("Xkb");
+                debug_tuple.field(&format_args!("0x{code:04X}"));
+            },
+            Web(code) => {
+                debug_tuple = f.debug_tuple("Web");
+                debug_tuple.field(code);
+            },
+        }
+        debug_tuple.finish()
+    }
+}
+
+impl From<NativeKeyCode> for NativeKey {
+    #[inline]
+    fn from(code: NativeKeyCode) -> Self {
+        match code {
+            NativeKeyCode::Unidentified => NativeKey::Unidentified,
+            NativeKeyCode::Android(x) => NativeKey::Android(x),
+            NativeKeyCode::MacOS(x) => NativeKey::MacOS(x),
+            NativeKeyCode::Windows(x) => NativeKey::Windows(x),
+            NativeKeyCode::Xkb(x) => NativeKey::Xkb(x),
+        }
+    }
+}
+
+impl PartialEq<NativeKey> for NativeKeyCode {
+    #[allow(clippy::cmp_owned)] // uses less code than direct match; target is stack allocated
+    #[inline]
+    fn eq(&self, rhs: &NativeKey) -> bool {
+        NativeKey::from(*self) == *rhs
+    }
+}
+
+impl PartialEq<NativeKeyCode> for NativeKey {
+    #[inline]
+    fn eq(&self, rhs: &NativeKeyCode) -> bool {
+        rhs == self
+    }
+}
+
+/// Represents the location of a physical key.
+///
+/// Winit will not emit [`KeyCode::Unidentified`] when it cannot recognize the key, instead it will
+/// emit [`PhysicalKey::Unidentified`] with additional data about the key.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub enum PhysicalKey {
+    /// A known key code
+    Code(KeyCode),
+    /// This variant is used when the key cannot be translated to a [`KeyCode`]
+    ///
+    /// The native keycode is provided (if available) so you're able to more reliably match
+    /// key-press and key-release events by hashing the [`PhysicalKey`]. It is also possible to use
+    /// this for keybinds for non-standard keys, but such keybinds are tied to a given platform.
+    Unidentified(NativeKeyCode),
+}
+
+impl From<KeyCode> for PhysicalKey {
+    #[inline]
+    fn from(code: KeyCode) -> Self {
+        PhysicalKey::Code(code)
+    }
+}
+
+impl From<PhysicalKey> for KeyCode {
+    #[inline]
+    fn from(key: PhysicalKey) -> Self {
+        match key {
+            PhysicalKey::Code(code) => code,
+            PhysicalKey::Unidentified(_) => KeyCode::Unidentified,
+        }
+    }
+}
+
+impl From<NativeKeyCode> for PhysicalKey {
+    #[inline]
+    fn from(code: NativeKeyCode) -> Self {
+        PhysicalKey::Unidentified(code)
+    }
+}
+
+impl PartialEq<KeyCode> for PhysicalKey {
+    #[inline]
+    fn eq(&self, rhs: &KeyCode) -> bool {
+        match self {
+            PhysicalKey::Code(code) => code == rhs,
+            _ => false,
+        }
+    }
+}
+
+impl PartialEq<PhysicalKey> for KeyCode {
+    #[inline]
+    fn eq(&self, rhs: &PhysicalKey) -> bool {
+        rhs == self
+    }
+}
+
+impl PartialEq<NativeKeyCode> for PhysicalKey {
+    #[inline]
+    fn eq(&self, rhs: &NativeKeyCode) -> bool {
+        match self {
+            PhysicalKey::Unidentified(code) => code == rhs,
+            _ => false,
+        }
+    }
+}
+
+impl PartialEq<PhysicalKey> for NativeKeyCode {
+    #[inline]
+    fn eq(&self, rhs: &PhysicalKey) -> bool {
+        rhs == self
+    }
+}
+
+/// Key represents the meaning of a keypress.
+///
+/// This is a superset of the UI Events Specification's [`KeyboardEvent.key`] with
+/// additions:
+/// - All simple variants are wrapped under the `Named` variant
+/// - The `Unidentified` variant here, can still identify a key through it's `NativeKeyCode`.
+/// - The `Dead` variant here, can specify the character which is inserted when pressing the
+///   dead-key twice.
+///
+/// [`KeyboardEvent.key`]: https://w3c.github.io/uievents-key/
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub enum Key<Str = SmolStr> {
+    /// A simple (unparameterised) action
+    Named(NamedKey),
+
+    /// A key string that corresponds to the character typed by the user, taking into account the
+    /// user’s current locale setting, and any system-level keyboard mapping overrides that are in
+    /// effect.
+    Character(Str),
+
+    /// This variant is used when the key cannot be translated to any other variant.
+    ///
+    /// The native key is provided (if available) in order to allow the user to specify keybindings
+    /// for keys which are not defined by this API, mainly through some sort of UI.
+    Unidentified(NativeKey),
+
+    /// Contains the text representation of the dead-key when available.
+    ///
+    /// ## Platform-specific
+    /// - **Web:** Always contains `None`
+    Dead(Option<char>),
+}
+
+impl From<NamedKey> for Key {
+    #[inline]
+    fn from(action: NamedKey) -> Self {
+        Key::Named(action)
+    }
+}
+
+impl From<NativeKey> for Key {
+    #[inline]
+    fn from(code: NativeKey) -> Self {
+        Key::Unidentified(code)
+    }
+}
+
+impl<Str> PartialEq<NamedKey> for Key<Str> {
+    #[inline]
+    fn eq(&self, rhs: &NamedKey) -> bool {
+        match self {
+            Key::Named(a) => a == rhs,
+            _ => false,
+        }
+    }
+}
+
+impl<Str: PartialEq<str>> PartialEq<str> for Key<Str> {
+    #[inline]
+    fn eq(&self, rhs: &str) -> bool {
+        match self {
+            Key::Character(s) => s == rhs,
+            _ => false,
+        }
+    }
+}
+
+impl<Str: PartialEq<str>> PartialEq<&str> for Key<Str> {
+    #[inline]
+    fn eq(&self, rhs: &&str) -> bool {
+        self == *rhs
+    }
+}
+
+impl<Str> PartialEq<NativeKey> for Key<Str> {
+    #[inline]
+    fn eq(&self, rhs: &NativeKey) -> bool {
+        match self {
+            Key::Unidentified(code) => code == rhs,
+            _ => false,
+        }
+    }
+}
+
+impl<Str> PartialEq<Key<Str>> for NativeKey {
+    #[inline]
+    fn eq(&self, rhs: &Key<Str>) -> bool {
+        rhs == self
+    }
+}
+
+impl Key<SmolStr> {
+    /// Convert `Key::Character(SmolStr)` to `Key::Character(&str)` so you can more easily match on
+    /// `Key`. All other variants remain unchanged.
+    pub fn as_ref(&self) -> Key<&str> {
+        match self {
+            Key::Named(a) => Key::Named(*a),
+            Key::Character(ch) => Key::Character(ch.as_str()),
+            Key::Dead(d) => Key::Dead(*d),
+            Key::Unidentified(u) => Key::Unidentified(u.clone()),
+        }
+    }
+}
+
+impl Key {
+    /// Convert a key to its approximate textual equivalent.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # #[cfg(target_family = "wasm")]
+    /// # wasm_bindgen_test::wasm_bindgen_test_configure!(run_in_browser);
+    /// # #[cfg_attr(target_family = "wasm", wasm_bindgen_test::wasm_bindgen_test)]
+    /// # fn main() {
+    /// use winit_core::keyboard::{Key, NamedKey};
+    ///
+    /// assert_eq!(Key::Character("a".into()).to_text(), Some("a"));
+    /// assert_eq!(Key::Named(NamedKey::Enter).to_text(), Some("\r"));
+    /// assert_eq!(Key::Named(NamedKey::F20).to_text(), None);
+    /// # }
+    /// ```
+    pub fn to_text(&self) -> Option<&str> {
+        match self {
+            Key::Named(action) => match action {
+                NamedKey::Enter => Some("\r"),
+                NamedKey::Backspace => Some("\x08"),
+                NamedKey::Tab => Some("\t"),
+                NamedKey::Escape => Some("\x1b"),
+                _ => None,
+            },
+            Key::Character(ch) => Some(ch.as_str()),
+            _ => None,
+        }
+    }
+}
+
+bitflags! {
+    /// Represents the current logical state of the keyboard modifiers
+    ///
+    /// Each flag represents a modifier and is set if this modifier is active.
+    ///
+    /// Note that the modifier key can be physically released with the modifier
+    /// still being marked as active, as in the case of sticky modifiers.
+    /// See [`ModifiersKeyState`] for more details on what "sticky" means.
+    #[derive(Default, Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+    pub struct ModifiersState: u32 {
+        /// The "shift" key.
+        const SHIFT = 0b100;
+        /// The "control" key.
+        const CONTROL = 0b100 << 3;
+        /// The "alt" key.
+        const ALT = 0b100 << 6;
+        /// This is the "windows" key on PC and "command" key on Mac.
+        const META = 0b100 << 9;
+        #[deprecated = "use META instead"]
+        const SUPER = Self::META.bits();
+    }
+}
+
+impl ModifiersState {
+    /// Returns whether the shift modifier is active.
+    pub fn shift_key(&self) -> bool {
+        self.intersects(Self::SHIFT)
+    }
+
+    /// Returns whether the control modifier is active.
+    pub fn control_key(&self) -> bool {
+        self.intersects(Self::CONTROL)
+    }
+
+    /// Returns whether the alt modifier is active.
+    pub fn alt_key(&self) -> bool {
+        self.intersects(Self::ALT)
+    }
+
+    /// Returns whether the meta modifier is active.
+    pub fn meta_key(&self) -> bool {
+        self.intersects(Self::META)
+    }
+}
+
+/// The logical state of the particular modifiers key.
+///
+/// NOTE: while the modifier can only be in a binary active/inactive state, it might be helpful to
+/// note the context re. how its state changes by physical key events.
+///
+/// `↓` / `↑` denote physical press/release[^1]:
+///
+/// | Type              | Activated           | Deactivated | Comment |
+/// | ----------------- | :-----------------: | :---------: | ------- |
+/// | __Regular__       | `↓`                 | `↑`         | Active while being held |
+/// | __Sticky__        | `↓`                 | `↓` unless lock is enabled<br>`↓`/`↑`[^2] __non__-sticky key | Temporarily "stuck"; other `Sticky` keys have no effect |
+/// | __Sticky Locked__ | `↓` <br>if `Sticky` | `↓`         | Similar to `Toggle`, but deactivating `↓` turns on `Regular` effect |
+/// | __Toggle__        | `↓`                 | `↓`         | `↑` from the activating `↓` has no effect |
+///
+/// `Sticky` effect avoids the need to press and hold multiple modifiers for a single shortcut and
+/// is usually a platform-wide option that affects modifiers _commonly_ used in shortcuts:
+/// <kbd>Shift</kbd>, <kbd>Control</kbd>, <kbd>Alt</kbd>, <kbd>Meta</kbd>.
+///
+/// `Toggle` type is typically a property of a modifier, for example, <kbd>Caps Lock</kbd>.
+///
+/// These active states are __not__ differentiated here.
+///
+/// [^1]: For virtual/on-screen keyboards physical press/release can be a mouse click or a finger tap or a voice command.
+/// [^2]: platform-dependent
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub enum ModifiersKeyState {
+    /// The particular modifier is active or logically, but not necessarily physically, pressed.
+    Pressed,
+    /// The state of the key is unknown.
+    ///
+    /// Can include cases when the key is active or logically pressed, for example, when a sticky
+    /// **Shift** is active, the OS might not preserve information that it was activated by
+    /// RightShift, so the state of [`ModifiersKeys::RSHIFT`] will be unknown while the state
+    /// of [`ModifiersState::SHIFT`] will be active.
+    #[default]
+    Unknown,
+}
+
+// NOTE: the exact modifier key is not used to represent modifiers state in the
+// first place due to a fact that modifiers state could be changed without any
+// key being pressed and on some platforms like Wayland/X11 which key resulted
+// in modifiers change is hidden, also, not that it really matters.
+//
+// The reason this API is even exposed is mostly to provide a way for users
+// to treat modifiers differently based on their position, which is required
+// on macOS due to their AltGr/Option situation.
+bitflags! {
+    #[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash)]
+    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+    pub struct ModifiersKeys: u8 {
+        const LSHIFT   = 0b0000_0001;
+        const RSHIFT   = 0b0000_0010;
+        const LCONTROL = 0b0000_0100;
+        const RCONTROL = 0b0000_1000;
+        const LALT     = 0b0001_0000;
+        const RALT     = 0b0010_0000;
+        const LMETA    = 0b0100_0000;
+        const RMETA    = 0b1000_0000;
+        #[deprecated = "use LMETA instead"]
+        const LSUPER   = Self::LMETA.bits();
+        #[deprecated = "use RMETA instead"]
+        const RSUPER   = Self::RMETA.bits();
+    }
+}
--- a/winit-core/src/lib.rs
+++ b/winit-core/src/lib.rs
@@ -0,0 +1,29 @@
+//! # Core types for Winit
+//!
+//! Platform-agnostic types and traits useful when implementing Winit backends,
+//! or otherwise interfacing with Winit from library code.
+//!
+//! See the [`winit`] crate for the full user-facing API.
+//!
+//! [`winit`]: https://docs.rs/winit
+
+#[macro_use]
+pub mod as_any;
+pub mod cursor;
+#[macro_use]
+pub mod error;
+pub mod application;
+pub mod event;
+pub mod event_loop;
+pub mod icon;
+pub mod keyboard;
+pub mod monitor;
+pub mod window;
+
+// `Instant` is not actually available on `wasm32-unknown-unknown`, the `std` implementation there
+// is a stub. And `wasm32-none` doesn't even have `std`. Instead, we use `web_time::Instant`.
+#[cfg(not(all(target_family = "wasm", any(target_os = "unknown", target_os = "none"))))]
+pub(crate) use std::time::Instant;
+
+#[cfg(all(target_family = "wasm", any(target_os = "unknown", target_os = "none")))]
+pub(crate) use web_time::Instant;
--- a/winit-core/src/monitor.rs
+++ b/winit-core/src/monitor.rs
@@ -11,8 +11,9 @@ use std::num::{NonZeroU16, NonZeroU32};
 use std::ops::Deref;
 use std::sync::Arc;

-use crate::dpi::{PhysicalPosition, PhysicalSize};
-use crate::utils::{impl_dyn_casting, AsAny};
+use dpi::{PhysicalPosition, PhysicalSize};
+
+use crate::as_any::AsAny;

 /// Handle to a monitor.
 ///
@@ -28,24 +29,13 @@ use crate::utils::{impl_dyn_casting, AsAny};
 ///
 /// ## Platform-specific
 ///
-/// **Web:** A [`MonitorHandle`] created without
-#[cfg_attr(
-    web_platform,
-    doc = "[detailed monitor permissions][crate::platform::web::ActiveEventLoopExtWeb::request_detailed_monitor_permission]."
-)]
-#[cfg_attr(not(web_platform), doc = "detailed monitor permissions.")]
+/// **Web:** A [`MonitorHandle`] created without `detailed monitor permissions`
 /// will always represent the current monitor the browser window is in instead of a specific
-/// monitor. See
-#[cfg_attr(
-    web_platform,
-    doc = "[`MonitorHandleExtWeb::is_detailed()`][crate::platform::web::MonitorHandleExtWeb::is_detailed]"
-)]
-#[cfg_attr(not(web_platform), doc = "`MonitorHandleExtWeb::is_detailed()`")]
-/// to check.
+/// monitor.
 ///
 /// [`Window`]: crate::window::Window
 #[derive(Debug, Clone)]
-pub struct MonitorHandle(pub(crate) Arc<dyn MonitorHandleProvider>);
+pub struct MonitorHandle(pub Arc<dyn MonitorHandleProvider>);

 impl Deref for MonitorHandle {
    type Target = dyn MonitorHandleProvider;
@@ -87,14 +77,10 @@ pub trait MonitorHandleProvider: AsAny + fmt::Debug + Send + Sync {
    ///
    /// Returns `None` if the monitor doesn't exist anymore or the name couldn't be obtained.
    ///
+    ///
    /// ## Platform-specific
    ///
-    /// **Web:** Always returns [`None`] without
-    #[cfg_attr(
-        web_platform,
-        doc = "[detailed monitor permissions][crate::platform::web::ActiveEventLoopExtWeb::request_detailed_monitor_permission]."
-    )]
-    #[cfg_attr(not(web_platform), doc = "detailed monitor permissions.")]
+    /// **Web:** Always returns [`None`] without `detailed monitor permissions`.
    fn name(&self) -> Option<Cow<'_, str>>;

    /// Returns the top-left corner position of the monitor in desktop coordinates.
@@ -105,12 +91,7 @@ pub trait MonitorHandleProvider: AsAny + fmt::Debug + Send + Sync {
    ///
    /// ## Platform-specific
    ///
-    /// **Web:** Always returns [`None`] without
-    #[cfg_attr(
-        web_platform,
-        doc = "[detailed monitor permissions][crate::platform::web::ActiveEventLoopExtWeb::request_detailed_monitor_permission]."
-    )]
-    #[cfg_attr(not(web_platform), doc = "detailed monitor permissions.")]
+    /// **Web:** Always returns [`None`] without `detailed monitor permissions`.
    fn position(&self) -> Option<PhysicalPosition<i32>>;

    /// Returns the scale factor of the underlying monitor. To map logical pixels to physical
@@ -118,19 +99,9 @@ pub trait MonitorHandleProvider: AsAny + fmt::Debug + Send + Sync {
    ///
    /// See the [`dpi`] module for more information.
    ///
-    /// ## Platform-specific
-    ///
-    /// - **X11:** Can be overridden using the `WINIT_X11_SCALE_FACTOR` environment variable.
    /// - **Wayland:** May differ from [`Window::scale_factor`].
-    /// - **Android:** Always returns 1.0.
-    /// - **Web:** Always returns `0.0` without
-    #[cfg_attr(
-        web_platform,
-        doc = "  [detailed monitor permissions][crate::platform::web::ActiveEventLoopExtWeb::request_detailed_monitor_permission]."
-    )]
-    #[cfg_attr(not(web_platform), doc = "  detailed monitor permissions.")]
+    /// - **Web:** Always returns `0.0` without `detailed_monitor_permissions`.
    ///
-    #[rustfmt::skip]
    /// [`Window::scale_factor`]: crate::window::Window::scale_factor
    fn scale_factor(&self) -> f64;

@@ -161,6 +132,14 @@ pub struct VideoMode {
 }

 impl VideoMode {
+    pub fn new(
+        size: PhysicalSize<u32>,
+        bit_depth: Option<NonZeroU16>,
+        refresh_rate_millihertz: Option<NonZeroU32>,
+    ) -> Self {
+        Self { size, bit_depth, refresh_rate_millihertz }
+    }
+
    /// Returns the resolution of this video mode. This **must not** be used to create your
    /// rendering surface. Use [`Window::surface_size()`] instead.
    ///
@@ -172,6 +151,13 @@ impl VideoMode {
    /// Returns the bit depth of this video mode, as in how many bits you have
    /// available per color. This is generally 24 bits or 32 bits on modern
    /// systems, depending on whether the alpha channel is counted or not.
+    ///
+    /// # Platform-specific
+    ///
+    /// - **macOS**: Video modes do not control the bit depth of the monitor, so this often defaults
+    ///   to 32.
+    /// - **iOS**: Always returns `None`.
+    /// - **Wayland**: Always returns `None`.
    pub fn bit_depth(&self) -> Option<NonZeroU16> {
        self.bit_depth
    }
--- a/winit-core/src/window.rs
+++ b/winit-core/src/window.rs
--- a/winit-orbital/Cargo.toml
+++ b/winit-orbital/Cargo.toml
@@ -0,0 +1,25 @@
+[package]
+description = "Winit's Orbital/Redox backend"
+documentation = "https://docs.rs/winit-orbital"
+edition.workspace = true
+license.workspace = true
+name = "winit-orbital"
+repository.workspace = true
+rust-version.workspace = true
+version.workspace = true
+
+[features]
+serde = ["dep:serde", "bitflags/serde", "smol_str/serde", "dpi/serde"]
+
+[dependencies]
+bitflags.workspace = true
+dpi.workspace = true
+rwh_06.workspace = true
+serde = { workspace = true, optional = true }
+smol_str.workspace = true
+tracing.workspace = true
+winit-core.workspace = true
+
+# Platform-specific
+orbclient.workspace = true
+redox_syscall.workspace = true
--- a/winit-orbital/LICENSE
+++ b/winit-orbital/LICENSE
@@ -0,0 +1 @@
+../LICENSE
--- a/winit-orbital/README.md
+++ b/winit-orbital/README.md
@@ -0,0 +1 @@
+../README.md
--- a/src/platform_impl/orbital/event_loop.rs
+++ b/src/platform_impl/orbital/event_loop.rs
@@ -1,6 +1,7 @@
 use std::cell::Cell;
 use std::collections::VecDeque;
-use std::sync::{mpsc, Arc, Mutex};
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{Arc, Mutex, mpsc};
 use std::time::Instant;
 use std::{iter, mem, slice};

@@ -10,24 +11,23 @@ use orbclient::{
    MoveEvent, QuitEvent, ResizeEvent, ScrollEvent, TextInputEvent,
 };
 use smol_str::SmolStr;
-
-use super::{PlatformSpecificEventLoopAttributes, RedoxSocket, TimeSocket, WindowProperties};
-use crate::application::ApplicationHandler;
-use crate::error::{EventLoopError, NotSupportedError, RequestError};
-use crate::event::{self, Ime, Modifiers, StartCause};
-use crate::event_loop::{
+use winit_core::application::ApplicationHandler;
+use winit_core::cursor::{CustomCursor, CustomCursorSource};
+use winit_core::error::{EventLoopError, NotSupportedError, RequestError};
+use winit_core::event::{self, Ime, Modifiers, StartCause};
+use winit_core::event_loop::{
    ActiveEventLoop as RootActiveEventLoop, ControlFlow, DeviceEvents,
    EventLoopProxy as CoreEventLoopProxy, EventLoopProxyProvider,
    OwnedDisplayHandle as CoreOwnedDisplayHandle,
 };
-use crate::keyboard::{
+use winit_core::keyboard::{
    Key, KeyCode, KeyLocation, ModifiersKeys, ModifiersState, NamedKey, NativeKey, NativeKeyCode,
    PhysicalKey,
 };
-use crate::platform_impl::Window;
-use crate::window::{
-    CustomCursor as RootCustomCursor, CustomCursorSource, Theme, Window as CoreWindow, WindowId,
-};
+use winit_core::window::{Theme, Window as CoreWindow, WindowId};
+
+use crate::window::Window;
+use crate::{RedoxSocket, TimeSocket, WindowProperties};

 fn convert_scancode(scancode: u8) -> (PhysicalKey, Option<NamedKey>) {
    // Key constants from https://docs.rs/orbclient/latest/orbclient/event/index.html
@@ -133,11 +133,7 @@ fn convert_scancode(scancode: u8) -> (PhysicalKey, Option<NamedKey>) {
 }

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

 bitflags! {
@@ -268,7 +264,7 @@ impl EventState {
        pressed_mods
            .set(ModifiersKeys::RMETA, self.keyboard.contains(KeyboardModifierState::RMETA));

-        Modifiers { state, pressed_mods }
+        Modifiers::new(state, pressed_mods)
    }
 }

@@ -280,7 +276,13 @@ pub struct EventLoop {
 }

 impl EventLoop {
-    pub(crate) fn new(_: &PlatformSpecificEventLoopAttributes) -> Result<Self, EventLoopError> {
+    pub fn new(_: &PlatformSpecificEventLoopAttributes) -> Result<Self, EventLoopError> {
+        static EVENT_LOOP_CREATED: AtomicBool = AtomicBool::new(false);
+        if EVENT_LOOP_CREATED.swap(true, Ordering::Relaxed) {
+            // For better cross-platformness.
+            return Err(EventLoopError::RecreationAttempt);
+        }
+
        // 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);
@@ -479,7 +481,10 @@ impl EventLoop {
        }
    }

-    pub fn run_app<A: ApplicationHandler>(mut self, mut app: A) -> Result<(), EventLoopError> {
+    pub fn run_app_on_demand<A: ApplicationHandler>(
+        &mut self,
+        mut app: A,
+    ) -> Result<(), EventLoopError> {
        let mut start_cause = StartCause::Init;
        loop {
            app.new_events(&self.window_target, start_cause);
@@ -694,19 +699,16 @@ impl RootActiveEventLoop for ActiveEventLoop {

    fn create_window(
        &self,
-        window_attributes: crate::window::WindowAttributes,
+        window_attributes: winit_core::window::WindowAttributes,
    ) -> Result<Box<dyn CoreWindow>, RequestError> {
        Ok(Box::new(Window::new(self, window_attributes)?))
    }

-    fn create_custom_cursor(
-        &self,
-        _: CustomCursorSource,
-    ) -> Result<RootCustomCursor, RequestError> {
+    fn create_custom_cursor(&self, _: CustomCursorSource) -> Result<CustomCursor, RequestError> {
        Err(NotSupportedError::new("create_custom_cursor is not supported").into())
    }

-    fn available_monitors(&self) -> Box<dyn Iterator<Item = crate::monitor::MonitorHandle>> {
+    fn available_monitors(&self) -> Box<dyn Iterator<Item = winit_core::monitor::MonitorHandle>> {
        Box::new(iter::empty())
    }

@@ -714,7 +716,7 @@ impl RootActiveEventLoop for ActiveEventLoop {
        None
    }

-    fn primary_monitor(&self) -> Option<crate::monitor::MonitorHandle> {
+    fn primary_monitor(&self) -> Option<winit_core::monitor::MonitorHandle> {
        None
    }

@@ -761,3 +763,6 @@ impl rwh_06::HasDisplayHandle for OwnedDisplayHandle {
        unsafe { Ok(rwh_06::DisplayHandle::borrow_raw(raw)) }
    }
 }
+
+#[derive(Default, Debug, Copy, Clone, PartialEq, Eq, Hash)]
+pub struct PlatformSpecificEventLoopAttributes {}
--- a/src/platform_impl/orbital/mod.rs
+++ b/src/platform_impl/orbital/mod.rs
@@ -1,12 +1,18 @@
-#![cfg(target_os = "redox")]
+//! # Orbital / Redox OS
+//!
+//! Redox OS has some functionality not yet present that will be implemented
+//! when its orbital display server provides it.

 use std::{fmt, str};

-pub(crate) use self::event_loop::{ActiveEventLoop, EventLoop};
-pub use self::window::Window;
+pub use self::event_loop::{EventLoop, PlatformSpecificEventLoopAttributes};

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

 #[derive(Debug)]
 struct RedoxSocket {
@@ -15,7 +21,7 @@ struct RedoxSocket {

 impl RedoxSocket {
    fn event() -> syscall::Result<Self> {
-        Self::open_raw("event:")
+        Self::open_raw("/scheme/event")
    }

    fn orbital(properties: &WindowProperties<'_>) -> syscall::Result<Self> {
@@ -33,20 +39,12 @@ impl RedoxSocket {

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

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

    fn fpath<'a>(&self, buf: &'a mut [u8]) -> syscall::Result<&'a str> {
@@ -62,11 +60,11 @@ impl Drop for RedoxSocket {
 }

 #[derive(Debug)]
-pub struct TimeSocket(RedoxSocket);
+struct TimeSocket(RedoxSocket);

 impl TimeSocket {
    fn open() -> syscall::Result<Self> {
-        RedoxSocket::open_raw("time:4").map(Self)
+        RedoxSocket::open_raw("/scheme/time/4").map(Self)
    }

    // Read current time.
@@ -88,12 +86,6 @@ impl TimeSocket {
    }
 }

-#[derive(Default, Debug, Copy, Clone, PartialEq, Eq, Hash)]
-pub(crate) struct PlatformSpecificEventLoopAttributes {}
-
-#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
-pub struct PlatformSpecificWindowAttributes;
-
 struct WindowProperties<'a> {
    flags: &'a str,
    x: i32,
@@ -121,7 +113,7 @@ impl fmt::Display for WindowProperties<'_> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(
            f,
-            "orbital:{}/{}/{}/{}/{}/{}",
+            "/scheme/orbital/{}/{}/{}/{}/{}/{}",
            self.flags, self.x, self.y, self.w, self.h, self.title
        )
    }
--- a/src/platform_impl/orbital/window.rs
+++ b/src/platform_impl/orbital/window.rs
@@ -2,13 +2,14 @@ use std::collections::VecDeque;
 use std::iter;
 use std::sync::{Arc, Mutex};

-use super::event_loop::EventLoopProxy;
-use super::{ActiveEventLoop, RedoxSocket, WindowProperties};
-use crate::cursor::Cursor;
-use crate::dpi::{PhysicalInsets, PhysicalPosition, PhysicalSize, Position, Size};
-use crate::error::{NotSupportedError, RequestError};
-use crate::monitor::{Fullscreen, MonitorHandle as CoreMonitorHandle};
-use crate::window::{self, ImePurpose, Window as CoreWindow, WindowId};
+use dpi::{PhysicalInsets, PhysicalPosition, PhysicalSize, Position, Size};
+use winit_core::cursor::Cursor;
+use winit_core::error::{NotSupportedError, RequestError};
+use winit_core::monitor::{Fullscreen, MonitorHandle as CoreMonitorHandle};
+use winit_core::window::{self, Window as CoreWindow, WindowId};
+
+use crate::event_loop::{ActiveEventLoop, EventLoopProxy};
+use crate::{RedoxSocket, WindowProperties};

 // These values match the values uses in the `window_new` function in orbital:
 // https://gitlab.redox-os.org/redox-os/orbital/-/blob/master/src/scheme.rs
@@ -18,6 +19,7 @@ const ORBITAL_FLAG_FRONT: char = 'f';
 const ORBITAL_FLAG_HIDDEN: char = 'h';
 const ORBITAL_FLAG_BORDERLESS: char = 'l';
 const ORBITAL_FLAG_MAXIMIZED: char = 'm';
+const ORBITAL_FLAG_FULLSCREEN: char = 'M';
 const ORBITAL_FLAG_RESIZABLE: char = 'r';
 const ORBITAL_FLAG_TRANSPARENT: char = 't';

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

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

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

-        // TODO: fullscreen
-
        if attrs.transparent {
            flag_str.push(ORBITAL_FLAG_TRANSPARENT);
        }
@@ -160,6 +163,10 @@ impl CoreWindow for Window {
        WindowId::from_raw(self.window_socket.fd)
    }

+    fn ime_capabilities(&self) -> Option<window::ImeCapabilities> {
+        None
+    }
+
    #[inline]
    fn primary_monitor(&self) -> Option<CoreMonitorHandle> {
        None
@@ -318,10 +325,28 @@ impl CoreWindow for Window {
        self.get_flag(ORBITAL_FLAG_MAXIMIZED).unwrap_or(false)
    }

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

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

    #[inline]
@@ -351,16 +376,11 @@ impl CoreWindow for Window {
    }

    #[inline]
-    fn set_window_icon(&self, _window_icon: Option<crate::icon::Icon>) {}
+    fn set_window_icon(&self, _window_icon: Option<winit_core::icon::Icon>) {}

-    #[inline]
-    fn set_ime_cursor_area(&self, _position: Position, _size: Size) {}
-
-    #[inline]
-    fn set_ime_allowed(&self, _allowed: bool) {}
-
-    #[inline]
-    fn set_ime_purpose(&self, _purpose: ImePurpose) {}
+    fn request_ime_update(&self, _: window::ImeRequest) -> Result<(), window::ImeRequestError> {
+        Err(window::ImeRequestError::NotSupported)
+    }

    #[inline]
    fn focus_window(&self) {}
@@ -485,3 +505,6 @@ impl Drop for Window {
        self.event_loop_proxy.wake_socket.wake().unwrap();
    }
 }
+
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+pub struct PlatformSpecificWindowAttributes;
--- a/winit-uikit/Cargo.toml
+++ b/winit-uikit/Cargo.toml
@@ -0,0 +1,76 @@
+[package]
+description = "Winit's UIKit (iOS/tvOS/visionOS) backend"
+documentation = "https://docs.rs/winit-uikit"
+edition.workspace = true
+license.workspace = true
+name = "winit-uikit"
+repository.workspace = true
+rust-version.workspace = true
+version.workspace = true
+
+[features]
+serde = ["dep:serde", "bitflags/serde", "smol_str/serde", "dpi/serde"]
+
+[dependencies]
+bitflags.workspace = true
+dpi.workspace = true
+rwh_06.workspace = true
+serde = { workspace = true, optional = true }
+smol_str.workspace = true
+tracing.workspace = true
+winit-core.workspace = true
+
+# Platform-specific
+[target.'cfg(target_vendor = "apple")'.dependencies]
+block2.workspace = true
+dispatch2.workspace = true
+objc2.workspace = true
+objc2-core-foundation = { workspace = true, features = [
+    "std",
+    "CFCGTypes",
+    "CFBase",
+    "CFRunLoop",
+    "CFString",
+] }
+objc2-foundation = { workspace = true, features = [
+    "std",
+    "block2",
+    "objc2-core-foundation",
+    "NSArray",
+    "NSEnumerator",
+    "NSGeometry",
+    "NSObjCRuntime",
+    "NSOperation",
+    "NSString",
+    "NSThread",
+    "NSSet",
+] }
+objc2-ui-kit = { workspace = true, features = [
+    "std",
+    "objc2-core-foundation",
+    "UIApplication",
+    "UIDevice",
+    "UIEvent",
+    "UIGeometry",
+    "UIGestureRecognizer",
+    "UITextInput",
+    "UITextInputTraits",
+    "UIOrientation",
+    "UIPanGestureRecognizer",
+    "UIPinchGestureRecognizer",
+    "UIResponder",
+    "UIRotationGestureRecognizer",
+    "UIScreen",
+    "UIScreenMode",
+    "UITapGestureRecognizer",
+    "UITouch",
+    "UITraitCollection",
+    "UIView",
+    "UIViewController",
+    "UIWindow",
+] }
+winit-common = { workspace = true, features = ["core-foundation", "event-handler"] }
+
+[package.metadata.docs.rs]
+all-features = true
+targets = ["aarch64-apple-ios", "aarch64-apple-ios-macabi"]
--- a/winit-uikit/LICENSE
+++ b/winit-uikit/LICENSE
@@ -0,0 +1 @@
+../LICENSE
--- a/winit-uikit/README.md
+++ b/winit-uikit/README.md
@@ -0,0 +1 @@
+../README.md
--- a/src/platform_impl/apple/uikit/app_state.rs
+++ b/src/platform_impl/apple/uikit/app_state.rs
@@ -1,30 +1,30 @@
 #![deny(unused_results)]

-use std::cell::{OnceCell, RefCell, RefMut};
+use std::cell::{Cell, OnceCell};
 use std::collections::HashSet;
 use std::os::raw::c_void;
 use std::sync::{Arc, Mutex};
 use std::time::Instant;
-use std::{mem, ptr};
+use std::{fmt, ptr};

 use dispatch2::MainThreadBound;
-use objc2::rc::Retained;
+use dpi::PhysicalSize;
 use objc2::MainThreadMarker;
+use objc2::rc::Retained;
 use objc2_core_foundation::{
-    kCFRunLoopCommonModes, CFAbsoluteTimeGetCurrent, CFRetained, CFRunLoop, CFRunLoopTimer, CGRect,
-    CGSize,
+    CFAbsoluteTimeGetCurrent, CFRetained, CFRunLoop, CFRunLoopTimer, CGRect, CGSize,
+    kCFRunLoopCommonModes,
 };
 use objc2_ui_kit::{UIApplication, UICoordinateSpace, UIView};
+use winit_common::core_foundation::EventLoopProxy;
+use winit_common::event_handler::EventHandler;
+use winit_core::application::ApplicationHandler;
+use winit_core::event::{StartCause, SurfaceSizeWriter, WindowEvent};
+use winit_core::event_loop::ControlFlow;
+use winit_core::window::WindowId;

-use super::super::event_handler::EventHandler;
-use super::super::event_loop_proxy::EventLoopProxy;
-use super::window::WinitUIWindow;
-use super::ActiveEventLoop;
-use crate::application::ApplicationHandler;
-use crate::dpi::PhysicalSize;
-use crate::event::{StartCause, SurfaceSizeWriter, WindowEvent};
-use crate::event_loop::ControlFlow;
-use crate::window::WindowId;
+use crate::event_loop::ActiveEventLoop;
+use crate::window::WinitUIWindow;

 macro_rules! bug {
    ($($msg:tt)*) => {
@@ -32,12 +32,6 @@ macro_rules! bug {
    };
 }

-macro_rules! bug_assert {
-    ($test:expr, $($msg:tt)*) => {
-        assert!($test, "winit iOS bug, file an issue: {}", format!($($msg)*))
-    };
-}
-
 /// Get the global event handler for the application.
 ///
 /// This is stored separately from AppState, since AppState needs to be accessible while the handler
@@ -71,131 +65,90 @@ impl EventWrapper {
 }

 // this is the state machine for the app lifecycle
-#[derive(Debug)]
+#[derive(Clone, Copy, Debug)]
 #[must_use = "dropping `AppStateImpl` without inspecting it is probably a bug"]
 enum AppStateImpl {
-    Initial {
-        queued_gpu_redraws: HashSet<Retained<WinitUIWindow>>,
-    },
-    ProcessingEvents {
-        queued_gpu_redraws: HashSet<Retained<WinitUIWindow>>,
-        active_control_flow: ControlFlow,
-    },
-    ProcessingRedraws {
-        active_control_flow: ControlFlow,
-    },
-    Waiting {
-        start: Instant,
-    },
+    Initial,
+    ProcessingEvents { active_control_flow: ControlFlow },
+    ProcessingRedraws { active_control_flow: ControlFlow },
+    Waiting { start: Instant },
    PollFinished,
    Terminated,
 }

 pub(crate) struct AppState {
-    // This should never be `None`, except for briefly during a state transition.
-    app_state: Option<AppStateImpl>,
-    control_flow: ControlFlow,
+    state: Cell<AppStateImpl>,
+    control_flow: Cell<ControlFlow>,
    waker: EventLoopWaker,
    event_loop_proxy: Arc<EventLoopProxy>,
-    queued_events: Vec<EventWrapper>,
+    queued_events: Cell<Vec<EventWrapper>>,
+    queued_gpu_redraws: Cell<HashSet<Retained<WinitUIWindow>>>,
 }

+impl fmt::Debug for AppState {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("AppState")
+            .field("control_flow", &self.control_flow)
+            .field("waker", &self.waker)
+            .field("event_loop_proxy", &self.event_loop_proxy)
+            .field("queued_events", &"Cell<...>")
+            .field("queued_gpu_redraws", &"Cell<...>")
+            .finish_non_exhaustive()
+    }
+}
+
+// SAFETY: Creating `MainThreadBound` in a `const` context,
+// where there is no concept of the main thread.
+static GLOBAL: MainThreadBound<OnceCell<AppState>> =
+    MainThreadBound::new(OnceCell::new(), unsafe { MainThreadMarker::new_unchecked() });
+
 impl AppState {
-    pub(crate) fn get_mut(mtm: MainThreadMarker) -> RefMut<'static, AppState> {
-        // basically everything in UIKit requires the main thread, so it's pointless to use the
-        // std::sync APIs.
-        // must be mut because plain `static` requires `Sync`
-        static mut APP_STATE: RefCell<Option<AppState>> = RefCell::new(None);
-
-        #[allow(unknown_lints)] // New lint below
-        #[allow(static_mut_refs)] // TODO: Use `MainThreadBound` instead.
-        let mut guard = unsafe { APP_STATE.borrow_mut() };
-        if guard.is_none() {
-            #[inline(never)]
-            #[cold]
-            fn init_guard(guard: &mut RefMut<'static, Option<AppState>>, mtm: MainThreadMarker) {
-                let waker = EventLoopWaker::new(CFRunLoop::main().unwrap());
-                let event_loop_proxy = Arc::new(EventLoopProxy::new(mtm, move || {
-                    get_handler(mtm).handle(|app| app.proxy_wake_up(&ActiveEventLoop { mtm }));
-                }));
-
-                **guard = Some(AppState {
-                    app_state: Some(AppStateImpl::Initial { queued_gpu_redraws: HashSet::new() }),
-                    control_flow: ControlFlow::default(),
-                    waker,
-                    event_loop_proxy,
-                    queued_events: Vec::new(),
-                });
-            }
-            init_guard(&mut guard, mtm);
-        }
-        RefMut::map(guard, |state| state.as_mut().unwrap())
+    pub(crate) fn setup_global(mtm: MainThreadMarker) -> bool {
+        let event_loop_proxy = Arc::new(EventLoopProxy::new(mtm, move || {
+            get_handler(mtm).handle(|app| app.proxy_wake_up(&ActiveEventLoop { mtm }));
+        }));
+        GLOBAL
+            .get(mtm)
+            .set(Self {
+                state: Cell::new(AppStateImpl::Initial),
+                control_flow: Cell::new(ControlFlow::default()),
+                waker: EventLoopWaker::new(CFRunLoop::main().unwrap()),
+                event_loop_proxy,
+                queued_events: Cell::new(Vec::new()),
+                queued_gpu_redraws: Cell::new(HashSet::new()),
+            })
+            .is_ok()
    }

-    fn state(&self) -> &AppStateImpl {
-        match &self.app_state {
-            Some(ref state) => state,
-            None => bug!("`AppState` previously failed a state transition"),
-        }
-    }
-
-    fn state_mut(&mut self) -> &mut AppStateImpl {
-        match &mut self.app_state {
-            Some(ref mut state) => state,
-            None => bug!("`AppState` previously failed a state transition"),
-        }
-    }
-
-    fn take_state(&mut self) -> AppStateImpl {
-        match self.app_state.take() {
-            Some(state) => state,
-            None => bug!("`AppState` previously failed a state transition"),
-        }
-    }
-
-    fn set_state(&mut self, new_state: AppStateImpl) {
-        bug_assert!(
-            self.app_state.is_none(),
-            "attempted to set an `AppState` without calling `take_state` first {:?}",
-            self.app_state
-        );
-        self.app_state = Some(new_state)
-    }
-
-    fn replace_state(&mut self, new_state: AppStateImpl) -> AppStateImpl {
-        match &mut self.app_state {
-            Some(ref mut state) => mem::replace(state, new_state),
-            None => bug!("`AppState` previously failed a state transition"),
-        }
+    pub(crate) fn get(mtm: MainThreadMarker) -> &'static Self {
+        GLOBAL.get(mtm).get().expect("tried to get application state before it was registered")
    }

    fn has_launched(&self) -> bool {
-        !matches!(self.state(), AppStateImpl::Initial { .. })
+        !matches!(self.state.get(), AppStateImpl::Initial)
    }

    fn has_terminated(&self) -> bool {
-        matches!(self.state(), AppStateImpl::Terminated)
+        matches!(self.state.get(), AppStateImpl::Terminated)
    }

-    fn did_finish_launching_transition(&mut self) {
-        let queued_gpu_redraws = match self.take_state() {
-            AppStateImpl::Initial { queued_gpu_redraws } => queued_gpu_redraws,
+    fn did_finish_launching_transition(&self) {
+        match self.state.get() {
+            AppStateImpl::Initial => {},
            s => bug!("unexpected state {:?}", s),
-        };
-        self.set_state(AppStateImpl::ProcessingEvents {
-            active_control_flow: self.control_flow,
-            queued_gpu_redraws,
-        });
+        }
+        self.state
+            .set(AppStateImpl::ProcessingEvents { active_control_flow: self.control_flow.get() });
    }

-    fn wakeup_transition(&mut self) -> Option<StartCause> {
+    fn wakeup_transition(&self) -> Option<StartCause> {
        // before `AppState::did_finish_launching` is called, pretend there is no running
        // event loop.
        if !self.has_launched() || self.has_terminated() {
            return None;
        }

-        let start_cause = match (self.control_flow, self.take_state()) {
+        let start_cause = match (self.control_flow.get(), self.state.get()) {
            (ControlFlow::Poll, AppStateImpl::PollFinished) => StartCause::Poll,
            (ControlFlow::Wait, AppStateImpl::Waiting { start }) => {
                StartCause::WaitCancelled { start, requested_resume: None }
@@ -210,66 +163,61 @@ impl AppState {
            s => bug!("`EventHandler` unexpectedly woke up {:?}", s),
        };

-        self.set_state(AppStateImpl::ProcessingEvents {
-            queued_gpu_redraws: Default::default(),
-            active_control_flow: self.control_flow,
-        });
+        self.state
+            .set(AppStateImpl::ProcessingEvents { active_control_flow: self.control_flow.get() });
        Some(start_cause)
    }

-    fn main_events_cleared_transition(&mut self) -> HashSet<Retained<WinitUIWindow>> {
-        let (queued_gpu_redraws, active_control_flow) = match self.take_state() {
-            AppStateImpl::ProcessingEvents { queued_gpu_redraws, active_control_flow } => {
-                (queued_gpu_redraws, active_control_flow)
-            },
+    fn main_events_cleared_transition(&self) {
+        let active_control_flow = match self.state.get() {
+            AppStateImpl::ProcessingEvents { active_control_flow } => active_control_flow,
            s => bug!("unexpected state {:?}", s),
        };
-        self.set_state(AppStateImpl::ProcessingRedraws { active_control_flow });
-        queued_gpu_redraws
+        self.state.set(AppStateImpl::ProcessingRedraws { active_control_flow });
    }

-    fn events_cleared_transition(&mut self) {
+    fn events_cleared_transition(&self) {
        if !self.has_launched() || self.has_terminated() {
            return;
        }
-        let old = match self.take_state() {
+        let old = match self.state.get() {
            AppStateImpl::ProcessingRedraws { active_control_flow } => active_control_flow,
            s => bug!("unexpected state {:?}", s),
        };

-        let new = self.control_flow;
+        let new = self.control_flow.get();
        match (old, new) {
            (ControlFlow::Wait, ControlFlow::Wait) => {
                let start = Instant::now();
-                self.set_state(AppStateImpl::Waiting { start });
+                self.state.set(AppStateImpl::Waiting { start });
                self.waker.stop()
            },
            (ControlFlow::WaitUntil(old_instant), ControlFlow::WaitUntil(new_instant))
                if old_instant == new_instant =>
            {
                let start = Instant::now();
-                self.set_state(AppStateImpl::Waiting { start });
+                self.state.set(AppStateImpl::Waiting { start });
            },
            (_, ControlFlow::Wait) => {
                let start = Instant::now();
-                self.set_state(AppStateImpl::Waiting { start });
+                self.state.set(AppStateImpl::Waiting { start });
                self.waker.stop()
            },
            (_, ControlFlow::WaitUntil(new_instant)) => {
                let start = Instant::now();
-                self.set_state(AppStateImpl::Waiting { start });
+                self.state.set(AppStateImpl::Waiting { start });
                self.waker.start_at(new_instant)
            },
            // Unlike on macOS, handle Poll to Poll transition here to call the waker
            (_, ControlFlow::Poll) => {
-                self.set_state(AppStateImpl::PollFinished);
+                self.state.set(AppStateImpl::PollFinished);
                self.waker.start()
            },
        }
    }

-    fn terminated_transition(&mut self) {
-        match self.replace_state(AppStateImpl::Terminated) {
+    fn terminated_transition(&self) {
+        match self.state.replace(AppStateImpl::Terminated) {
            AppStateImpl::ProcessingEvents { .. } => {},
            s => bug!("terminated while not processing events {:?}", s),
        }
@@ -279,26 +227,27 @@ impl AppState {
        &self.event_loop_proxy
    }

-    pub(crate) fn set_control_flow(&mut self, control_flow: ControlFlow) {
-        self.control_flow = control_flow;
+    pub(crate) fn set_control_flow(&self, control_flow: ControlFlow) {
+        self.control_flow.set(control_flow);
    }

    pub(crate) fn control_flow(&self) -> ControlFlow {
-        self.control_flow
+        self.control_flow.get()
    }
 }

 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::Initial { ref mut queued_gpu_redraws, .. }
-        | &mut AppStateImpl::ProcessingEvents { ref mut queued_gpu_redraws, .. } => {
+    let this = AppState::get(mtm);
+    match this.state.get() {
+        AppStateImpl::Initial | AppStateImpl::ProcessingEvents { .. } => {
+            let mut queued_gpu_redraws = this.queued_gpu_redraws.take();
            let _ = queued_gpu_redraws.insert(window);
+            this.queued_gpu_redraws.set(queued_gpu_redraws);
        },
-        s @ &mut AppStateImpl::ProcessingRedraws { .. }
-        | s @ &mut AppStateImpl::Waiting { .. }
-        | s @ &mut AppStateImpl::PollFinished => bug!("unexpected state {:?}", s),
-        &mut AppStateImpl::Terminated => {
+        s @ AppStateImpl::ProcessingRedraws { .. }
+        | s @ AppStateImpl::Waiting { .. }
+        | s @ AppStateImpl::PollFinished => bug!("unexpected state {:?}", s),
+        AppStateImpl::Terminated => {
            panic!("Attempt to create a `Window` after the app has terminated")
        },
    }
@@ -313,14 +262,10 @@ pub(crate) fn launch<R>(
 }

 pub fn did_finish_launching(mtm: MainThreadMarker) {
-    let mut this = AppState::get_mut(mtm);
+    let this = AppState::get(mtm);

    this.waker.start();
-
-    // have to drop RefMut because the window setup code below can trigger new events
-    drop(this);
-
-    AppState::get_mut(mtm).did_finish_launching_transition();
+    this.did_finish_launching_transition();

    get_handler(mtm).handle(|app| app.new_events(&ActiveEventLoop { mtm }, StartCause::Init));
    get_handler(mtm).handle(|app| app.can_create_surfaces(&ActiveEventLoop { mtm }));
@@ -329,12 +274,11 @@ pub fn did_finish_launching(mtm: MainThreadMarker) {

 // AppState::did_finish_launching handles the special transition `Init`
 pub fn handle_wakeup_transition(mtm: MainThreadMarker) {
-    let mut this = AppState::get_mut(mtm);
+    let this = AppState::get(mtm);
    let cause = match this.wakeup_transition() {
        None => return,
        Some(cause) => cause,
    };
-    drop(this);

    get_handler(mtm).handle(|app| app.new_events(&ActiveEventLoop { mtm }, cause));
    handle_nonuser_events(mtm, []);
@@ -348,19 +292,20 @@ pub(crate) fn handle_nonuser_events<I: IntoIterator<Item = EventWrapper>>(
    mtm: MainThreadMarker,
    events: I,
 ) {
-    let mut this = AppState::get_mut(mtm);
+    let this = AppState::get(mtm);
    if this.has_terminated() {
        return;
    }

    if !get_handler(mtm).ready() {
        // Prevent re-entrancy; queue the events up for once we're done handling the event instead.
-        this.queued_events.extend(events);
+        let mut queued_events = this.queued_events.take();
+        queued_events.extend(events);
+        this.queued_events.set(queued_events);
        return;
    }

-    let processing_redraws = matches!(this.state(), AppStateImpl::ProcessingRedraws { .. });
-    drop(this);
+    let processing_redraws = matches!(this.state.get(), AppStateImpl::ProcessingRedraws { .. });

    for event in events {
        if !processing_redraws && event.is_redraw() {
@@ -375,12 +320,10 @@ pub(crate) fn handle_nonuser_events<I: IntoIterator<Item = EventWrapper>>(
    }

    loop {
-        let mut this = AppState::get_mut(mtm);
-        let queued_events = mem::take(&mut this.queued_events);
+        let queued_events = this.queued_events.take();
        if queued_events.is_empty() {
            break;
        }
-        drop(this);

        for event in queued_events {
            if !processing_redraws && event.is_redraw() {
@@ -397,19 +340,16 @@ pub(crate) fn handle_nonuser_events<I: IntoIterator<Item = EventWrapper>>(
 }

 fn handle_user_events(mtm: MainThreadMarker) {
-    let this = AppState::get_mut(mtm);
-    if matches!(this.state(), AppStateImpl::ProcessingRedraws { .. }) {
+    let this = AppState::get(mtm);
+    if matches!(this.state.get(), AppStateImpl::ProcessingRedraws { .. }) {
        bug!("user events attempted to be sent out while `ProcessingRedraws`");
    }
-    drop(this);

    loop {
-        let mut this = AppState::get_mut(mtm);
-        let queued_events = mem::take(&mut this.queued_events);
+        let queued_events = this.queued_events.take();
        if queued_events.is_empty() {
            break;
        }
-        drop(this);

        for event in queued_events {
            handle_wrapped_event(mtm, event);
@@ -434,28 +374,23 @@ pub(crate) fn send_occluded_event_for_all_windows(application: &UIApplication, o
 }

 pub fn handle_main_events_cleared(mtm: MainThreadMarker) {
-    let mut this = AppState::get_mut(mtm);
+    let this = AppState::get(mtm);
    if !this.has_launched() || this.has_terminated() {
        return;
    }
-    match this.state_mut() {
+    match this.state.get() {
        AppStateImpl::ProcessingEvents { .. } => {},
        _ => bug!("`ProcessingRedraws` happened unexpectedly"),
    };
-    drop(this);

    handle_user_events(mtm);

-    let mut this = AppState::get_mut(mtm);
-    let redraw_events: Vec<EventWrapper> = this
-        .main_events_cleared_transition()
-        .into_iter()
-        .map(|window| EventWrapper::Window {
-            window_id: window.id(),
-            event: WindowEvent::RedrawRequested,
-        })
-        .collect();
-    drop(this);
+    this.main_events_cleared_transition();
+    let queued_gpu_redraws = this.queued_gpu_redraws.take();
+    let redraw_events = queued_gpu_redraws.into_iter().map(|window| EventWrapper::Window {
+        window_id: window.id(),
+        event: WindowEvent::RedrawRequested,
+    });

    handle_nonuser_events(mtm, redraw_events);
    get_handler(mtm).handle(|app| app.about_to_wait(&ActiveEventLoop { mtm }));
@@ -463,7 +398,7 @@ pub fn handle_main_events_cleared(mtm: MainThreadMarker) {
 }

 pub fn handle_events_cleared(mtm: MainThreadMarker) {
-    AppState::get_mut(mtm).events_cleared_transition();
+    AppState::get(mtm).events_cleared_transition();
 }

 pub(crate) fn handle_resumed(mtm: MainThreadMarker) {
@@ -496,11 +431,10 @@ pub(crate) fn terminated(application: &UIApplication) {
    }
    handle_nonuser_events(mtm, events);

-    let mut this = AppState::get_mut(mtm);
+    let this = AppState::get(mtm);
    this.terminated_transition();
    // Prevent EventLoopProxy from firing again.
    this.event_loop_proxy.invalidate();
-    drop(this);

    get_handler(mtm).terminate();
 }
@@ -541,6 +475,7 @@ fn get_view_and_screen_frame(window: &WinitUIWindow) -> (Retained<UIView>, CGRec
    (view, screen_frame)
 }

+#[derive(Debug)]
 struct EventLoopWaker {
    timer: CFRetained<CFRunLoopTimer>,
 }
@@ -574,15 +509,15 @@ impl EventLoopWaker {
        }
    }

-    fn stop(&mut self) {
+    fn stop(&self) {
        self.timer.set_next_fire_date(f64::MAX);
    }

-    fn start(&mut self) {
+    fn start(&self) {
        self.timer.set_next_fire_date(f64::MIN);
    }

-    fn start_at(&mut self, instant: Instant) {
+    fn start_at(&self, instant: Instant) {
        let now = Instant::now();
        if now >= instant {
            self.start();
--- a/src/platform_impl/apple/uikit/event_loop.rs
+++ b/src/platform_impl/apple/uikit/event_loop.rs
@@ -4,9 +4,9 @@ use std::sync::Arc;

 use objc2::rc::Retained;
 use objc2::runtime::ProtocolObject;
-use objc2::{msg_send, ClassType, MainThreadMarker};
+use objc2::{ClassType, MainThreadMarker, msg_send};
 use objc2_core_foundation::{
-    kCFRunLoopDefaultMode, CFIndex, CFRunLoop, CFRunLoopActivity, CFRunLoopObserver,
+    CFIndex, CFRunLoop, CFRunLoopActivity, CFRunLoopObserver, kCFRunLoopDefaultMode,
 };
 use objc2_foundation::{NSNotificationCenter, NSObjectProtocol};
 use objc2_ui_kit::{
@@ -16,33 +16,35 @@ use objc2_ui_kit::{
    UIApplicationWillResignActiveNotification, UIApplicationWillTerminateNotification, UIScreen,
 };
 use rwh_06::HasDisplayHandle;
-
-use super::super::notification_center::create_observer;
-use super::app_state::{send_occluded_event_for_all_windows, AppState};
-use super::{app_state, monitor, MonitorHandle};
-use crate::application::ApplicationHandler;
-use crate::error::{EventLoopError, NotSupportedError, RequestError};
-use crate::event_loop::{
+use winit_core::application::ApplicationHandler;
+use winit_core::cursor::{CustomCursor, CustomCursorSource};
+use winit_core::error::{EventLoopError, NotSupportedError, RequestError};
+use winit_core::event_loop::{
    ActiveEventLoop as RootActiveEventLoop, ControlFlow, DeviceEvents,
    EventLoopProxy as CoreEventLoopProxy, OwnedDisplayHandle as CoreOwnedDisplayHandle,
 };
-use crate::monitor::MonitorHandle as CoreMonitorHandle;
-use crate::platform_impl::Window;
-use crate::window::{CustomCursor, CustomCursorSource, Theme, Window as CoreWindow};
+use winit_core::monitor::MonitorHandle as CoreMonitorHandle;
+use winit_core::window::{Theme, Window as CoreWindow};
+
+use super::app_state::{AppState, send_occluded_event_for_all_windows};
+use super::notification_center::create_observer;
+use crate::monitor::MonitorHandle;
+use crate::window::Window;
+use crate::{app_state, monitor};

 #[derive(Debug)]
-pub(crate) struct ActiveEventLoop {
+pub struct ActiveEventLoop {
    pub(super) mtm: MainThreadMarker,
 }

 impl RootActiveEventLoop for ActiveEventLoop {
    fn create_proxy(&self) -> CoreEventLoopProxy {
-        CoreEventLoopProxy::new(AppState::get_mut(self.mtm).event_loop_proxy().clone())
+        CoreEventLoopProxy::new(AppState::get(self.mtm).event_loop_proxy().clone())
    }

    fn create_window(
        &self,
-        window_attributes: crate::window::WindowAttributes,
+        window_attributes: winit_core::window::WindowAttributes,
    ) -> Result<Box<dyn CoreWindow>, RequestError> {
        Ok(Box::new(Window::new(self, window_attributes)?))
    }
@@ -62,7 +64,7 @@ impl RootActiveEventLoop for ActiveEventLoop {
        )
    }

-    fn primary_monitor(&self) -> Option<crate::monitor::MonitorHandle> {
+    fn primary_monitor(&self) -> Option<winit_core::monitor::MonitorHandle> {
        #[allow(deprecated)]
        let monitor = MonitorHandle::new(UIScreen::mainScreen(self.mtm));
        Some(CoreMonitorHandle(Arc::new(monitor)))
@@ -71,7 +73,7 @@ impl RootActiveEventLoop for ActiveEventLoop {
    fn listen_device_events(&self, _allowed: DeviceEvents) {}

    fn set_control_flow(&self, control_flow: ControlFlow) {
-        AppState::get_mut(self.mtm).set_control_flow(control_flow)
+        AppState::get(self.mtm).set_control_flow(control_flow)
    }

    fn system_theme(&self) -> Option<Theme> {
@@ -79,7 +81,7 @@ impl RootActiveEventLoop for ActiveEventLoop {
    }

    fn control_flow(&self) -> ControlFlow {
-        AppState::get_mut(self.mtm).control_flow()
+        AppState::get(self.mtm).control_flow()
    }

    fn exit(&self) {
@@ -137,28 +139,22 @@ pub struct EventLoop {
 }

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

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

-        static mut SINGLETON_INIT: bool = false;
-        unsafe {
-            assert!(
-                !SINGLETON_INIT,
-                "Only one `EventLoop` is supported on iOS. `EventLoopProxy` might be helpful"
-            );
-            SINGLETON_INIT = true;
+        if !AppState::setup_global(mtm) {
+            // Required, AppState is global state, and event loop can only be run once.
+            return Err(EventLoopError::RecreationAttempt);
        }

        // this line sets up the main run loop before `UIApplicationMain`
        setup_control_flow_observers();

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

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

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

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

--- a/winit-uikit/src/lib.rs
+++ b/winit-uikit/src/lib.rs
@@ -1,4 +1,4 @@
-//! # iOS / UIKit
+//! # Winit's UIKit (iOS/tvOS/visionOS) backend
 //!
 //! Winit has [the same iOS version requirements as `rustc`][rustc-ios-version], although it's
 //! frequently only tested on newer iOS versions.
@@ -98,15 +98,26 @@
 //! register an application delegate, so you can set up a custom one in a nib file instead.
 //!
 //! [app-delegate]: https://developer.apple.com/documentation/uikit/uiapplicationdelegate?language=objc
+#![cfg(target_vendor = "apple")] // TODO: Remove once `objc2` allows compiling on all platforms
+
+mod app_state;
+mod event_loop;
+mod monitor;
+mod notification_center;
+mod view;
+mod view_controller;
+mod window;

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

 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
+use winit_core::monitor::{MonitorHandle, VideoMode};
+use winit_core::window::{PlatformWindowAttributes, Window};

-use crate::monitor::{MonitorHandle, VideoMode};
-use crate::platform_impl::MonitorHandle as IosMonitorHandle;
-use crate::window::{Window, WindowAttributes};
+pub use self::event_loop::{EventLoop, PlatformSpecificEventLoopAttributes};
+use self::monitor::MonitorHandle as UIKitMonitorHandle;
+use self::window::Window as UIKitWindow;

 /// Additional methods on [`Window`] that are specific to iOS.
 pub trait WindowExtIOS {
@@ -211,25 +222,25 @@ pub trait WindowExtIOS {
 impl WindowExtIOS for dyn Window + '_ {
    #[inline]
    fn set_scale_factor(&self, scale_factor: f64) {
-        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<UIKitWindow>().unwrap();
        window.maybe_wait_on_main(move |w| w.set_scale_factor(scale_factor));
    }

    #[inline]
    fn set_valid_orientations(&self, valid_orientations: ValidOrientations) {
-        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<UIKitWindow>().unwrap();
        window.maybe_wait_on_main(move |w| w.set_valid_orientations(valid_orientations));
    }

    #[inline]
    fn set_prefers_home_indicator_hidden(&self, hidden: bool) {
-        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<UIKitWindow>().unwrap();
        window.maybe_wait_on_main(move |w| w.set_prefers_home_indicator_hidden(hidden));
    }

    #[inline]
    fn set_preferred_screen_edges_deferring_system_gestures(&self, edges: ScreenEdge) {
-        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<UIKitWindow>().unwrap();
        window.maybe_wait_on_main(move |w| {
            w.set_preferred_screen_edges_deferring_system_gestures(edges)
        });
@@ -237,19 +248,19 @@ impl WindowExtIOS for dyn Window + '_ {

    #[inline]
    fn set_prefers_status_bar_hidden(&self, hidden: bool) {
-        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<UIKitWindow>().unwrap();
        window.maybe_wait_on_main(move |w| w.set_prefers_status_bar_hidden(hidden));
    }

    #[inline]
    fn set_preferred_status_bar_style(&self, status_bar_style: StatusBarStyle) {
-        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<UIKitWindow>().unwrap();
        window.maybe_wait_on_main(move |w| w.set_preferred_status_bar_style(status_bar_style))
    }

    #[inline]
    fn recognize_pinch_gesture(&self, should_recognize: bool) {
-        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<UIKitWindow>().unwrap();
        window.maybe_wait_on_main(move |w| w.recognize_pinch_gesture(should_recognize));
    }

@@ -260,7 +271,7 @@ impl WindowExtIOS for dyn Window + '_ {
        minimum_number_of_touches: u8,
        maximum_number_of_touches: u8,
    ) {
-        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<UIKitWindow>().unwrap();
        window.maybe_wait_on_main(move |w| {
            w.recognize_pan_gesture(
                should_recognize,
@@ -272,19 +283,29 @@ impl WindowExtIOS for dyn Window + '_ {

    #[inline]
    fn recognize_doubletap_gesture(&self, should_recognize: bool) {
-        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<UIKitWindow>().unwrap();
        window.maybe_wait_on_main(move |w| w.recognize_doubletap_gesture(should_recognize));
    }

    #[inline]
    fn recognize_rotation_gesture(&self, should_recognize: bool) {
-        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<UIKitWindow>().unwrap();
        window.maybe_wait_on_main(move |w| w.recognize_rotation_gesture(should_recognize));
    }
 }

-/// Additional methods on [`WindowAttributes`] that are specific to iOS.
-pub trait WindowAttributesExtIOS {
+/// Ios specific window attributes.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct WindowAttributesIos {
+    pub(crate) scale_factor: Option<f64>,
+    pub(crate) valid_orientations: ValidOrientations,
+    pub(crate) prefers_home_indicator_hidden: bool,
+    pub(crate) prefers_status_bar_hidden: bool,
+    pub(crate) preferred_status_bar_style: StatusBarStyle,
+    pub(crate) preferred_screen_edges_deferring_system_gestures: ScreenEdge,
+}
+
+impl WindowAttributesIos {
    /// Sets the [`contentScaleFactor`] of the underlying [`UIWindow`] to `scale_factor`.
    ///
    /// The default value is device dependent, and it's recommended GLES or Metal applications set
@@ -293,7 +314,10 @@ pub trait WindowAttributesExtIOS {
    /// [`UIWindow`]: https://developer.apple.com/documentation/uikit/uiwindow?language=objc
    /// [`contentScaleFactor`]: https://developer.apple.com/documentation/uikit/uiview/1622657-contentscalefactor?language=objc
    /// [`MonitorHandleProvider::scale_factor()`]: crate::monitor::MonitorHandleProvider::scale_factor()
-    fn with_scale_factor(self, scale_factor: f64) -> Self;
+    pub fn with_scale_factor(mut self, scale_factor: f64) -> Self {
+        self.scale_factor = Some(scale_factor);
+        self
+    }

    /// Sets the valid orientations for the [`Window`].
    ///
@@ -301,7 +325,10 @@ pub trait WindowAttributesExtIOS {
    ///
    /// This sets the initial value returned by
    /// [`-[UIViewController supportedInterfaceOrientations]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/1621435-supportedinterfaceorientations?language=objc).
-    fn with_valid_orientations(self, valid_orientations: ValidOrientations) -> Self;
+    pub fn with_valid_orientations(mut self, valid_orientations: ValidOrientations) -> Self {
+        self.valid_orientations = valid_orientations;
+        self
+    }

    /// Sets whether the [`Window`] prefers the home indicator hidden.
    ///
@@ -311,7 +338,10 @@ pub trait WindowAttributesExtIOS {
    /// [`-[UIViewController prefersHomeIndicatorAutoHidden]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/2887510-prefershomeindicatorautohidden?language=objc).
    ///
    /// This only has an effect on iOS 11.0+.
-    fn with_prefers_home_indicator_hidden(self, hidden: bool) -> Self;
+    pub fn with_prefers_home_indicator_hidden(mut self, hidden: bool) -> Self {
+        self.prefers_home_indicator_hidden = hidden;
+        self
+    }

    /// Sets the screen edges for which the system gestures will take a lower priority than the
    /// application's touch handling.
@@ -320,7 +350,13 @@ pub trait WindowAttributesExtIOS {
    /// [`-[UIViewController preferredScreenEdgesDeferringSystemGestures]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/2887512-preferredscreenedgesdeferringsys?language=objc).
    ///
    /// This only has an effect on iOS 11.0+.
-    fn with_preferred_screen_edges_deferring_system_gestures(self, edges: ScreenEdge) -> Self;
+    pub fn with_preferred_screen_edges_deferring_system_gestures(
+        mut self,
+        edges: ScreenEdge,
+    ) -> Self {
+        self.preferred_screen_edges_deferring_system_gestures = edges;
+        self
+    }

    /// Sets whether the [`Window`] prefers the status bar hidden.
    ///
@@ -328,7 +364,10 @@ pub trait WindowAttributesExtIOS {
    ///
    /// This sets the initial value returned by
    /// [`-[UIViewController prefersStatusBarHidden]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/1621440-prefersstatusbarhidden?language=objc).
-    fn with_prefers_status_bar_hidden(self, hidden: bool) -> Self;
+    pub fn with_prefers_status_bar_hidden(mut self, hidden: bool) -> Self {
+        self.prefers_status_bar_hidden = hidden;
+        self
+    }

    /// Sets the style of the [`Window`]'s status bar.
    ///
@@ -336,44 +375,15 @@ pub trait WindowAttributesExtIOS {
    ///
    /// This sets the initial value returned by
    /// [`-[UIViewController preferredStatusBarStyle]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/1621416-preferredstatusbarstyle?language=objc),
-    fn with_preferred_status_bar_style(self, status_bar_style: StatusBarStyle) -> Self;
+    pub fn with_preferred_status_bar_style(mut self, status_bar_style: StatusBarStyle) -> Self {
+        self.preferred_status_bar_style = status_bar_style;
+        self
+    }
 }

-impl WindowAttributesExtIOS for WindowAttributes {
-    #[inline]
-    fn with_scale_factor(mut self, scale_factor: f64) -> Self {
-        self.platform_specific.scale_factor = Some(scale_factor);
-        self
-    }
-
-    #[inline]
-    fn with_valid_orientations(mut self, valid_orientations: ValidOrientations) -> Self {
-        self.platform_specific.valid_orientations = valid_orientations;
-        self
-    }
-
-    #[inline]
-    fn with_prefers_home_indicator_hidden(mut self, hidden: bool) -> Self {
-        self.platform_specific.prefers_home_indicator_hidden = hidden;
-        self
-    }
-
-    #[inline]
-    fn with_preferred_screen_edges_deferring_system_gestures(mut self, edges: ScreenEdge) -> Self {
-        self.platform_specific.preferred_screen_edges_deferring_system_gestures = edges;
-        self
-    }
-
-    #[inline]
-    fn with_prefers_status_bar_hidden(mut self, hidden: bool) -> Self {
-        self.platform_specific.prefers_status_bar_hidden = hidden;
-        self
-    }
-
-    #[inline]
-    fn with_preferred_status_bar_style(mut self, status_bar_style: StatusBarStyle) -> Self {
-        self.platform_specific.preferred_status_bar_style = status_bar_style;
-        self
+impl PlatformWindowAttributes for WindowAttributesIos {
+    fn box_clone(&self) -> Box<dyn PlatformWindowAttributes> {
+        Box::from(self.clone())
    }
 }

@@ -395,13 +405,13 @@ 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::MainThreadMarker::new_unchecked() };
-        let monitor = self.cast_ref::<IosMonitorHandle>().unwrap();
+        let monitor = self.cast_ref::<UIKitMonitorHandle>().unwrap();
        objc2::rc::Retained::as_ptr(monitor.ui_screen(mtm)) as *mut c_void
    }

    #[inline]
    fn preferred_video_mode(&self) -> VideoMode {
-        let monitor = self.cast_ref::<IosMonitorHandle>().unwrap();
+        let monitor = self.cast_ref::<UIKitMonitorHandle>().unwrap();
        monitor.preferred_video_mode()
    }
 }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Kirill Chibisov	f98ccf8efc	Winit version 0.31.0-beta.2	2025-11-16 17:23:28 +09:00
Kirill Chibisov	b961e8e941	winit-core: fix set_ime_allowed always panicing	2025-11-16 17:23:28 +09:00
Mads Marquart	4c5bf0ee08	winit/event_loop: Add register_app and run_app_never_return To allow users to explicitly choose the run semantics that they want.	2025-11-16 17:23:28 +09:00
Mads Marquart	f69b601abb	winit-web: return immediately from run_app on web This avoids using JavaScript exceptions to support `EventLoop::run_app` on the web, which is a huge hack, and doesn't work with the Exception Handling Proposal for WebAssembly: https://github.com/WebAssembly/exception-handling This needs the application handler passed to `run_app` to be `'static`, but that works better on iOS too anyhow (since you can't accidentally forget to pass in state that then wouldn't be dropped when terminating).	2025-11-16 17:23:28 +09:00
Kirill Chibisov	e8bccfff4f	Winit version 0.31.0-beta.1	2025-11-16 13:32:44 +09:00
Kirill Chibisov	0a59e4b905	chore: fix clippy on X11	2025-11-16 13:07:23 +09:00
ShikiSuen	d837c88855	winit-appkit: fix tests on systems without MonitorId(1) Use `CGMainDisplayID` instead of `1` to make tests pass on systems without `MonitorId(1)`.	2025-11-06 14:46:28 +09:00
Dan Harris	82eab465e0	macOS: fix a crash when dragging non-file content onto window Winit only supports text, thus we should ignore the rest instead of crashing.	2025-11-05 13:20:01 +09:00
Diggory Hardy	a9c189a423	winit-win32: prevent inner size reported as (0,0) when minimized	2025-11-01 23:39:57 +09:00
Diggory Hardy	9d9d21cfdb	winit-core: revise MouseButton type Unify the values of `MouseButton` and thus remove `Other` variant in limit possible buttons to 32, which was picked based on platform capabilities, where 32 is the highest. For the reference, SDL has identical limit.	2025-11-01 21:00:39 +09:00
Kirill Chibisov	779f52a21f	chore: latest typos	2025-11-01 21:00:39 +09:00
mfluehr	7a21858d29	windows: don't confine hidden cursor	2025-11-01 13:03:11 +09:00
Kirill Chibisov	a3f7e6566a	ci: fix eslint version to 9.38.0 9.39.0 has an issue with unified-signatures. Links: https://github.com/eslint/eslint/issues/20272	2025-11-01 12:52:30 +09:00
DorotaC	f41897cfa4	examples/ime: fix crash on wayland When pressing Ctrl+Space, KeyEvent::text_with_all_modifiers would return \0. That would get included in the text-input text. When an input method gets activated, the invalid string returning \0 would get sent as surrounding text, resulting in a Wayland protocol error and crashing the application.	2025-10-29 13:40:30 +09:00
Timon	bd6fef1d80	wayland: add prefer_csd attribute	2025-10-24 21:35:51 +09:00
Kirill Chibisov	42d256e926	ci: fix version of smol_str	2025-10-24 21:01:20 +09:00
Pavel Strakhov	03dad26c43	x11: ignore mouse scroll button release events	2025-10-24 20:07:10 +09:00
Kirill Chibisov	1e7ab0cd25	wayland: handle wl_seat v10 repeated state Fixes #4382.	2025-10-20 00:01:36 +09:00
Kirill Chibisov	c333003514	Bump MSRV to 1.85 and edition to 2024	2025-10-20 00:01:36 +09:00
Arthur Cosentino	10f21090ce	x11: fix deadlock in request_ime_update	2025-10-09 16:57:20 +09:00
Timon	5575f51483	wayland: add wayland-csd-adwaita-notitlebar feature Addition to already present `notitle` feature.	2025-10-08 12:11:55 +09:00
Ian Douglas Scott	2ede84ab2f	wayland: handle `axis_value120` scroll events This can be tested with the `application` example, looking at the events shown for mouse wheel movement. `wl_pointer::axis_discrete` isn't sent in version 8 or higher of `wl_pointer`. And `sctk` doesn't convert the `value120` events, so on compositors advertising version 8, only pixel scroll events were being sent. This sends `MouseScrollDelta::LineDelta` with a fractional value, without doing any accumulation. Given `LineDelta` contains `f32` values, this presumably is expected? Though it might be good to change the definition of `MouseScrollDelta` to include both discrete and pixel values, when the compositor sends both. I'm not familiar with how this works on non-Wayland backends though.	2025-10-08 11:53:57 +09:00
Kirill Chibisov	f046e778aa	winit-core:winit: add tablet input support The API is integrated into the `WindowEvent::Pointer*` API and is present in form of `TabletTool` variant on corresponding data entries. For now implemented for Web, Windows, and with limitations for Wayland. Fixes #99. Co-authored-by: daxpedda <daxpedda@gmail.com>	2025-10-07 21:42:36 +09:00
sachharine	ffcdf80192	chore: fix typos causing dead links	2025-10-07 19:25:41 +09:00
Mads Marquart	b811e9d878	chore: update to objc2 frameworks v0.3.2	2025-10-07 17:56:05 +09:00
Kirill Chibisov	d815bc089c	chore: fix nightly clippy	2025-10-07 17:56:05 +09:00
Kirill Chibisov	66283a79bd	wayland: reduce amount of empty preedits If we send empty preedit before, don't send it again.	2025-09-13 06:53:29 +09:00
Alan Everett	3be30affe4	wayland: support for pinch, rotation, and pan gestures Co-Authored-By: linkmauve <linkmauve@linkmauve.fr> Co-authored-by: Kirill Chibisov <contact@kchibisov.com>	2025-09-07 11:45:35 +09:00
Kirill Chibisov	a68f1a664b	winit-wayland: bump sctk and sctk-adwaita	2025-09-06 22:25:24 +09:00
DorotaC	6de5041a94	winit-core/ime: add more purposes and content hints Also move IME example into `ime.rs` thus making IME integrations more easily comprehendible. Co-authored-by: Kirill Chibisov <contact@kchibisov.com>	2025-09-06 13:27:55 +09:00
Mads Marquart	014fb68a26	Fix using Rust-Analyzer on non-macOS platforms (#4347 )	2025-09-05 22:32:20 +02:00
Mads Marquart	9a03dacbde	linux: align scancode conversions with Chromium	2025-09-05 10:17:34 +09:00
Jeremy Soller	4d9302b33c	Add borderless fullscreen mode for orbital (#4343 )	2025-09-04 22:14:41 +02:00
moooozi	488c036a05	win32: disable DPI re-adjustments on Windows 11 For earlier Windows 10 builds (pre-22000), a workaround was necessary to fix dragging window onto a monitor with different DPI. This commit makes the old DPI workaround to only apply conditionally on affected Windows versions. Fixes #4041.	2025-08-24 12:57:31 +09:00
Tony	a4af50ec13	win32: refresh title bar on `Window::set_theme`	2025-08-23 21:55:54 +09:00
Tony	317d62fb93	win32: account for mouse wheel speed setting Also adds a method to toggle this behavior during runtime.	2025-08-23 21:38:56 +09:00
dependabot[bot]	b13b39aa0b	chore: bump ci deps versions	2025-08-23 21:19:46 +09:00
Sanjay	abea6e64e4	macOS: default menu uses bundle name Use the bundle name in the default menu or fall back to using the process name as before.	2025-08-23 20:35:45 +09:00
Jeremiah S	d6f7a28499	macOS: fix crash due during window drop On macOS 26+ the window drop was leading to unwrap, since events were coming after the window was already destroyed, while it sounds rather strange, guard against such things just in case. Fixes #4333.	2025-08-15 09:52:23 +09:00
Kirill Chibisov	bd98561b38	chore: fix typos from recent typos-cli (#4329 )	2025-08-12 16:30:34 +09:00
John Nunley	ca6f523924	m: remove self from CODEOWNERS This is making official what's basically been the case for the past few months at this point. I no longer have the capacity to effectively review and merge PRs for the Windows and X11 backends. Thanks again for having me. Signed-off-by: John Nunley <dev@notgull.net>	2025-08-04 02:50:06 +09:00
DorotaC	d7fdfb1bca	winit-core: add Ime::DeleteSurroundingText API This completes the basic API required for e.g. Wayland.	2025-08-02 19:17:27 +09:00
Kirill Chibisov	120f21a010	Bump version on master This commit does not represent a release and only synchronizes CHANGELOG from the latest release.	2025-07-27 22:13:06 +09:00
Robert Wallis	5904529ba1	macOS: fix runtime crash on macos26 "type code 'q', but found 'Q'" Fixes #4299.	2025-07-20 17:04:04 +09:00
DorotaC	e7a6034b55	winit-core: add surrounding_text for IME Allow communicating surrounding text to IME to better handle user input and account for content around for preedit.	2025-07-13 14:57:10 +09:00
DorotaC	eb66c25980	chore: fix typos Latest typos found more issues.	2025-07-03 08:30:22 +09:00
DorotaC	0ccb8a9f87	example: fix toggling IME	2025-06-30 11:51:46 +09:00
DorotaC	abed32eb80	winit-core/window: wrap ImeCapabilities in struct To prevent user from using `::all()` and thus writing not forward compatible code wrap the bitflags struct and provide simpler interface to it.	2025-06-29 13:53:47 +09:00
DorotaC	08907148ec	winit-core/window: add Window::request_ime_update Allow updating IME state atomically to make it easier for platforms where it's atomic by its nature, like Wayland. The old API is marked as deprecated and is routed to the new atomic API. Co-authored-by: dcz <gilapfco.dcz@porcupinefactory.org>	2025-06-28 13:14:20 +09:00
Kirill Chibisov	fa0795a50c	examples/application: fix running on wasm Was using `time` unconditionally.	2025-06-24 19:15:46 +09:00
Enn3Developer	fe1eab07ae	wayland: add xdg_toplevel_icon_v1 support Closes: #3859.	2025-06-22 19:40:05 +09:00
Kirill Chibisov	552c7a6252	winit: silence wasm on nightly The lint is needed for stable, but is no longer present on nightly, so silence it for the time being.	2025-06-22 19:29:27 +09:00
Jeremy Soller	50c0180af3	winit-orbital: update to new path format	2025-06-17 14:46:09 +09:00
Mads Marquart	4f33643509	chore: make git checkout build on Windows with symlinks disabled	2025-06-10 07:37:36 +09:00
Kirill Chibisov	0b21c55b72	winit-core/as_any: fix `Box<AsAny>` casting The casting was doing an incorrect check on the `ref` instead of actually trying to downcast a ref as `cast_ref` does. So use `cast_ref` to check whether we can safely `cast` to owned type.	2025-06-08 22:11:02 +09:00
Mads Marquart	e1bccb68d8	chore: use a shared version number for all winit-* crates	2025-06-08 09:22:58 +09:00
Mads Marquart	e540062ac0	iOS: Avoid `RefCell` and `static mut` (#4255 ) * iOS: Refactor queued_gpu_redraws out from AppStateImpl To allow AppStateImpl to be Copy, and to move redraws into the window in the future. * iOS AppState: Avoid RefCell and static mut Instead, prefer Cell and Copy types, as those will never have crashes on re-entrancy / if forgetting to make a state transition.	2025-06-07 23:16:41 +02:00
Martin Fischer	f1e0f6c646	icon: add PartialEq and Hash for RgbaIcon	2025-06-08 01:18:55 +09:00
Mads Marquart	3218316420	Document platform-specific modules	2025-06-07 22:43:38 +09:00
Mads Marquart	2900ecab93	winit-core/keyboard: use keyboard_types Closes #2394.	2025-06-07 16:47:47 +09:00
Kirill Chibisov	3a84da6951	Move winit itself to crate That way we use top-level Cargo.toml only for the workspace management purposes.	2025-06-07 13:07:12 +09:00
Mads Marquart	478427b0bd	Remove the need for `cfg_aliases` in `winit-core` (#4271 )	2025-06-06 13:24:01 +02:00
Mads Marquart	b0f26c79ff	Fix CI (#4270 ) * Fix typos * Remove OsError in winit-web	2025-06-05 13:10:30 +02:00
Kirill Chibisov	969237f422	Bump rustix to 1.0.0	2025-05-27 16:31:11 +09:00
Mads Marquart	e542a78deb	Move Web backend to winit-web	2025-05-26 14:56:00 +09:00
Kirill Chibisov	2d4b9938f0	ci/deny: add rustix Will take a while to move to 1.0 for everyone.	2025-05-26 14:56:00 +09:00
Mads Marquart	8ad016362a	chore: move event loop recreation check into backends themselves	2025-05-26 13:48:52 +09:00
Mads Marquart	5f2c7350e9	Move AppKit (macOS) backend to `winit-appkit` (#4248 )	2025-05-25 17:37:40 +02:00
Mads Marquart	256bbe949e	Move X11 backend to `winit-x11` (#4253 )	2025-05-25 17:24:00 +02:00
Mads Marquart	1126e9ea2f	Move Wayland backend to `winit-wayland` (#4252 )	2025-05-25 16:48:07 +02:00
Mads Marquart	927af44aa4	Move UIKit backend to `winit-uikit`	2025-05-25 23:19:30 +09:00
Mads Marquart	0adc0898f0	Move shared code to a new crate `winit-common`	2025-05-25 20:41:28 +09:00
Mads Marquart	3b986f5583	Move Windows backend to `winit-win32`	2025-05-25 12:13:25 +09:00
Mads Marquart	b1f8d778a1	Move Android backend to `winit-android` (#4250 )	2025-05-24 13:29:53 +02:00
Mads Marquart	04482d5a2e	fix: Allow unknown bit-depth on macOS (#4190 ) It is unclear what values CGDisplayModeCopyPixelEncoding is allowed to return, so let's make sure to handle unknown cases.	2025-05-23 16:07:09 +02:00
Mads Marquart	3e50911adb	macOS: Remove panic wrapper (#4147 ) This is unnecessary nowadays, unwinding in CF observer callbacks is safe (and is safe in Rust after the introduction of `extern "C-unwind"`). Panicking elsewhere (such as in NSNotificationCenter callbacks or delegate methods) _may_ still lead to an abort, if AppKit tries to catch it with libc++, since Rust panics are not compatible with those. That's "just" a quality-of-implementation detail of current Rust though, not an inherent limitation, and should really be solved in rustc.	2025-05-23 15:53:12 +02:00
Evgeny	f51a470872	doc: add info on sticky vs toggle modifier behavior (#4251 )	2025-05-22 21:57:10 +02:00
Mads Marquart	47b938dbe7	Split Orbital backend out into `winit-orbital` (#4243 )	2025-05-21 13:12:55 +02:00
Kirill Chibisov	e2b883d215	Bump version on master This commit does not represent a release and only synchronizes CHANGELOG from the latest release.	2025-05-21 18:04:10 +09:00
Evgeny	38fd3c6a99	winit-core/keyboard: clarify modifier docs Emphasize the difference between logical and physical state, reference sticky mods.	2025-05-21 17:40:28 +09:00
Mads Marquart	5190472bee	chore: use workspace dependencies everywhere To reduce the amount of duplication in 'Cargo.toml's when we split into different crates.	2025-05-21 15:45:12 +09:00
Mads Marquart	eab03dca80	Move `EventLoopExt` to `winit-core` (#4228 ) Move EventLoopExtPumpEvents and PumpStatus to winit-core * Move EventLoopExtRunOnDemand to winit-core	2025-05-20 16:56:53 +02:00
Kirill Chibisov	59e3dda89f	wayland: fix pump events's loop drop deadlock	2025-05-17 13:23:01 +09:00
Mads Marquart	c846f67bcb	chore: import from winit-core instead of the top-level crate Reproduce with: find ./src/platform_impl -type f -exec sed -i '' 's/crate::/winit_core::/g' {} \; find ./src/platform_impl -type f -exec sed -i '' 's/winit_core::platform/crate::platform/g' {} \; find ./src/platform_impl -type f -exec sed -i '' 's/winit_core::dpi::/dpi::/g' {} \; cargo +nightly fmt	2025-05-17 11:26:09 +09:00
Mads Marquart	03c01e038b	chose: appease clippy	2025-05-17 10:56:51 +09:00
Varphone Wong	ed4ebd4242	windows: Fix crash in for Windows versions < 17763 In Windows versions < 17763, `GetProcAddress("#132")` from `uxtheme.dll` also returns a non-null pointer. However, the function does not match the expected `extern "system" fn() -> bool` prototype, which causes a crash when it is called. This fix ensures compatibility by adding proper checks to prevent such crashes on older Windows versions.	2025-05-14 21:31:48 +09:00
Kirill Chibisov	b5921d89f2	winit-core: add top-level doc	2025-05-14 21:18:44 +09:00
Kirill Chibisov	b5a6a4e616	ci: test winit-core	2025-05-14 21:18:44 +09:00
Kirill Chibisov	9598eb371c	winit-core: fix tests	2025-05-14 21:18:44 +09:00
Kirill Chibisov	634b9baea2	winit-core: drop all cfg except web	2025-05-14 21:18:44 +09:00
Kirill Chibisov	cf5e422dc8	winit-core: drop broken docs Generally, winit-core doesn't know about underlying platforms, though, some general information which will true for any implementation was left in place.	2025-05-14 21:18:44 +09:00
Kirill Chibisov	276597e009	winit-core: cleanup event loop docs	2025-05-14 21:18:44 +09:00
Kirill Chibisov	c0b737de4a	winit-core: move application	2025-05-14 21:18:44 +09:00
Kirill Chibisov	79fa4061cb	winit-core: move event	2025-05-14 21:18:44 +09:00
Kirill Chibisov	056421546a	winit-core: move `ActiveEventLoop`	2025-05-14 21:18:44 +09:00
Kirill Chibisov	b4c5b76155	winit-core: move window Create `WindowAttributes` for respective platform specific window attributes in `winit` due to move of `WindowAttributes`.	2025-05-14 21:18:44 +09:00
Kirill Chibisov	c8b9a86885	winit-core: partially split event_loop	2025-05-14 21:18:44 +09:00
Kirill Chibisov	fe2df61884	winit-core: move error	2025-05-14 21:18:44 +09:00
Kirill Chibisov	446482367b	winit-core: move cursor	2025-05-14 21:18:44 +09:00
Kirill Chibisov	cbb29ab526	winit-core: move icon	2025-05-14 21:18:44 +09:00
Kirill Chibisov	a491c2abed	winit-core: move keyboard	2025-05-14 21:18:44 +09:00
Kirill Chibisov	3142355417	winit-core: move monitor handle	2025-05-14 21:18:44 +09:00
Kirill Chibisov	3493a20173	winit-core: new crate + split out as_any	2025-05-14 21:18:44 +09:00
Kirill Chibisov	bf0bde8067	ci/deny: allow scripts in zerocopy	2025-05-14 21:18:44 +09:00