macOS: Fix pump_app_events

Use the system's mechanisms for pumping events, namely `nextEventMatchingMask:untilDate:inMode:dequeue:`. This still has a few problems as detailed in the documentation for `pump_app_events` (which is why we switched away from it all the way back in Winit v0.20), but it doesn't have nearly as many problems as the current implementation does.
macOS: Remove panic wrapper
2026-06-26 22:53:15 -04:00 · 2025-03-03 08:46:54 +01:00 · 2025-03-01 22:13:39 +01:00
318 changed files with 12055 additions and 15038 deletions
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -1,26 +1,31 @@
 # Android
-/winit-android                      @MarijnS95
+/src/platform/android.rs            @MarijnS95
+/src/platform_impl/android          @MarijnS95

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

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

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

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

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

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

 # Orbital (Redox OS)
-/winit-orbital                      @jackpot51
+/src/platform/orbital.rs            @jackpot51
+/src/platform_impl/orbital          @jackpot51
--- a/.github/ISSUE_TEMPLATE/bug_uikit.yml
+++ b/.github/ISSUE_TEMPLATE/bug_uikit.yml
@@ -1,8 +1,8 @@
 name: iOS bug
-description: Create an iOS/UIKit-specific bug report
+description: Create an iOS-specific bug report
 labels:
  - B - bug
-  - DS - uikit
+  - DS - ios
 body:
  - type: markdown
    attributes:
--- a/.github/ISSUE_TEMPLATE/bug_appkit.yml
+++ b/.github/ISSUE_TEMPLATE/bug_appkit.yml
@@ -1,8 +1,8 @@
-name: macOS bug
+name: MacOS bug
 description: Create a macOS-specific bug report
 labels:
  - B - bug
-  - DS - appkit
+  - DS - macos
 body:
  - type: markdown
    attributes:
--- a/.github/ISSUE_TEMPLATE/bug_windows.yml
+++ b/.github/ISSUE_TEMPLATE/bug_windows.yml
@@ -2,7 +2,7 @@ name: Windows bug
 description: Create a Windows-specific bug report
 labels:
  - B - bug
-  - DS - win32
+  - DS - windows
 body:
  - type: markdown
    attributes:
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -55,7 +55,7 @@ jobs:
    strategy:
      fail-fast: false
      matrix:
-        toolchain: [stable, nightly, '1.85']
+        toolchain: [stable, nightly, '1.73']
        platform:
          # Note: Make sure that we test all the `docs.rs` targets defined in Cargo.toml!
          - { name: 'Windows 64bit MSVC', target: x86_64-pc-windows-msvc,   os: windows-latest,  }
@@ -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.85'
+          - toolchain: '1.73'
            platform: { name: 'Android' }
          # Redox OS doesn't follow MSRV
-          - toolchain: '1.85'
+          - toolchain: '1.73'
            platform: { name: 'Redox OS' }
        include:
-          - toolchain: '1.85'
-            platform: { name: 'Android', target: aarch64-linux-android, os: ubuntu-latest, options: '--package winit --features=android-native-activity', cmd: 'apk -- ' }
+          - toolchain: '1.73'
+            platform: { name: 'Android', target: aarch64-linux-android, os: ubuntu-latest, options: '--package=winit --features=android-native-activity', cmd: 'apk --' }
          - toolchain: 'nightly'
            platform: { name: 'Web', target: wasm32-unknown-unknown, os: ubuntu-latest, test-options: -Zdoctest-xcompile }
          - toolchain: 'nightly'
@@ -124,7 +124,7 @@ jobs:
      # the cache has been downloaded.
      #
      # This could be avoided if we added Cargo.lock to the repository.
-      uses: actions/cache/restore@v6
+      uses: actions/cache/restore@v4
      with:
        # https://doc.rust-lang.org/cargo/guide/cargo-home.html#caching-the-cargo-home-in-ci
        path: |
@@ -136,7 +136,7 @@ jobs:

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

    - name: Install GCC Multilib
      if: (matrix.platform.os == 'ubuntu-latest') && contains(matrix.platform.target, 'i686')
@@ -145,7 +145,7 @@ jobs:
    - name: Cache cargo-apk
      if: contains(matrix.platform.target, 'android')
      id: cargo-apk-cache
-      uses: actions/cache@v6
+      uses: actions/cache@v4
      with:
        path: ~/.cargo/bin/cargo-apk
        # Change this key if we update the required cargo-apk version
@@ -160,7 +160,7 @@ jobs:
      if: contains(matrix.platform.target, 'android') && (steps.cargo-apk-cache.outputs.cache-hit != 'true')
      run: cargo install cargo-apk --version=^0.9.7 --locked

-    - uses: taiki-e/cache-cargo-install-action@v3
+    - uses: taiki-e/cache-cargo-install-action@v2
      if: contains(matrix.platform.target, 'wasm32') && matrix.toolchain == 'nightly'
      with:
        tool: wasm-bindgen-cli
@@ -179,70 +179,17 @@ 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.85'
+        matrix.toolchain != '1.73'
      run: cargo test -p dpi

-    - name: Check dpi crate (no_std)
-      if: >
-        contains(matrix.platform.name, 'Linux 64bit') &&
-        matrix.toolchain != '1.85'
-      run: cargo check -p dpi --no-default-features
-
    - name: Build tests
      if: >
        !contains(matrix.platform.target, 'redox') &&
-        matrix.toolchain != '1.85'
+        matrix.toolchain != '1.73'
      run: cargo $CMD test --no-run $OPTIONS

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

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

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

    - name: Check docs.rs documentation
@@ -281,7 +228,7 @@ jobs:

    # See restore step above
    - name: Save cache of cargo folder
-      uses: actions/cache/save@v6
+      uses: actions/cache/save@v4
      with:
        path: |
          ~/.cargo/registry/index/
@@ -290,14 +237,30 @@ jobs:
        key: cargo-${{ matrix.toolchain }}-${{ matrix.platform.name }}-${{ hashFiles('Cargo.lock') }}

  cargo-deny:
-    name: Run cargo-deny
+    name: Run cargo-deny on ${{ matrix.platform.name }}
    runs-on: ubuntu-latest

+    # TODO: remove this matrix when https://github.com/EmbarkStudios/cargo-deny/issues/324 is resolved
+    strategy:
+      fail-fast: false
+      matrix:
+        platform:
+          - { name: 'Android', target: aarch64-linux-android }
+          - { name: 'iOS', target: aarch64-apple-ios }
+          - { name: 'Linux', target: x86_64-unknown-linux-gnu }
+          - { name: 'macOS', target: aarch64-apple-darwin }
+          - { name: 'Redox OS', target: x86_64-unknown-redox }
+          - { name: 'Web', target: wasm32-unknown-unknown }
+          - { name: 'Windows GNU', target: x86_64-pc-windows-gnu }
+          - { name: 'Windows MSVC', target: x86_64-pc-windows-msvc }
+
    steps:
    - uses: taiki-e/checkout-action@v1
    - uses: EmbarkStudios/cargo-deny-action@v2
      with:
+        command: check
        log-level: error
+        arguments: --all-features --target ${{ matrix.platform.target }}

  eslint:
    name: ESLint
@@ -305,14 +268,14 @@ jobs:
    runs-on: ubuntu-latest
    defaults:
      run:
-        working-directory: ./winit-web/src/script
+        working-directory: ./src/platform_impl/web/script

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

  swc:
    name: Minimize JavaScript
@@ -320,7 +283,7 @@ jobs:
    runs-on: ubuntu-latest
    defaults:
      run:
-        working-directory: ./winit-web/src/script
+        working-directory: ./src/platform_impl/web/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@v7
+      - uses: actions/checkout@v4

      - uses: dtolnay/rust-toolchain@master
        with:
@@ -32,7 +32,7 @@ jobs:
          cargo doc --no-deps -Z rustdoc-map -Z rustdoc-scrape-examples --features=serde,mint,android-native-activity

      - name: Setup Pages
-        uses: actions/configure-pages@v6
+        uses: actions/configure-pages@v5

      - name: Fix permissions
        run: |
@@ -41,10 +41,10 @@ jobs:
          done

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

      - name: Deploy to GitHub Pages
        id: deployment
-        uses: actions/deploy-pages@v5
+        uses: actions/deploy-pages@v4
--- 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`]: winit/src/changelog/unreleased.md
+[`changelog::unreleased`]: 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,13 +13,6 @@ 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
@@ -29,12 +22,7 @@ to the branch" checkbox.
 We use unstable Rustfmt options across the project, so please run
 `cargo +nightly fmt` before submitting your work. If you are unable to do so,
 the maintainers can do it for you before merging, just state so in your pull
-request description. For details on how to use nightly, consult [the
-documentation][toolchains].
-
-When editing markdown files (`.md`) they must be wrapped at 80 characters.
-
-[toolchains]: https://rust-lang.github.io/rustup/concepts/toolchains.html
+request description.

 #### Handling review

--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,97 +1,403 @@
-[workspace]
-default-members = ["winit"]
-members = ["dpi", "winit*"]
-resolver = "2"
+[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.9"

-[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"
+[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.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" }
+# 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"]

-# Core dependencies.
-bitflags = "2"
+[build-dependencies]
 cfg_aliases = "0.2.1"
+
+[dependencies]
+bitflags = "2"
 cursor-icon = "1.1.0"
-dpi = { version = "0.1.2", path = "dpi" }
-keyboard-types = "0.8.0"
-mint = "0.5.6"
+dpi = { version = "0.1.1", path = "dpi" }
 rwh_06 = { package = "raw-window-handle", version = "0.6", features = ["std"] }
-serde = { version = "1", features = ["serde_derive"] }
+serde = { workspace = true, optional = true }
 smol_str = "0.3"
 tracing = { version = "0.1.40", default-features = false }

-# Dev dependencies.
-image = { version = "0.25.0", default-features = false }
-softbuffer = { version = "0.4.8", default-features = false, features = [
+[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]
+softbuffer = { version = "0.4.6", default-features = false, features = [
    "x11",
    "x11-dlopen",
    "wayland",
    "wayland-dlopen",
 ] }
-tracing-subscriber = "0.3.18"

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

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

-# Windows dependencies.
+# AppKit
+[target.'cfg(target_os = "macos")'.dependencies]
+objc2-app-kit = { version = "0.3.0", 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.0", default-features = false, features = [
+    "std",
+    "block2",
+    "CFBase",
+    "CFCGTypes",
+    "CFData",
+    "CFRunLoop",
+    "CFString",
+    "CFUUID",
+] }
+objc2-core-graphics = { version = "0.3.0", default-features = false, features = [
+    "std",
+    "libc",
+    "CGDirectDisplay",
+    "CGDisplayConfiguration",
+    "CGDisplayFade",
+    "CGError",
+    "CGRemoteOperation",
+    "CGWindowLevel",
+] }
+objc2-core-video = { version = "0.3.0", default-features = false, features = [
+    "std",
+    "objc2-core-graphics",
+    "CVBase",
+    "CVReturn",
+    "CVDisplayLink",
+] }
+objc2-foundation = { version = "0.3.0", 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.0", default-features = false, features = [
+    "std",
+    "CFCGTypes",
+    "CFBase",
+    "CFRunLoop",
+    "CFString",
+] }
+objc2-foundation = { version = "0.3.0", default-features = false, features = [
+    "std",
+    "block2",
+    "objc2-core-foundation",
+    "NSArray",
+    "NSEnumerator",
+    "NSGeometry",
+    "NSObjCRuntime",
+    "NSOperation",
+    "NSString",
+    "NSThread",
+    "NSSet",
+] }
+objc2-ui-kit = { version = "0.3.0", 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]
 unicode-segmentation = "1.7.1"
-windows-sys = "0.61"
+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",
+] }

-# Linux dependencies.
-bytemuck = { version = "1.13.1", default-features = false }
-calloop = "0.14.3"
-foldhash = { version = "0.2.0", default-features = false, features = ["std"] }
+# 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"
 libc = "0.2.64"
-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 }
+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.5", default-features = false, features = [
+    "client_system",
+], optional = true }
+wayland-client = { version = "0.31.4", optional = true }
+wayland-protocols = { version = "0.32.2", features = ["staging"], optional = true }
+wayland-protocols-plasma = { version = "0.3.2", 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 }
 xkbcommon-dl = "0.4.2"

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

-# Web dependencies.
-atomic-waker = "1"
-concurrent-queue = { version = "2", default-features = false }
-console_error_panic_hook = "0.1"
+# Web
+[target.'cfg(target_family = "wasm")'.dependencies]
 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"
 web-time = "1"
-web_sys = { package = "web-sys", version = "0.3.70" }
+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]
+atomic-waker = "1"
+concurrent-queue = { version = "2", default-features = false }
+
+[target.'cfg(target_family = "wasm")'.dev-dependencies]
+console_error_panic_hook = "0.1"
+tracing-web = "0.1"
+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.73"
+
+[workspace.dependencies]
+mint = "0.5.6"
+serde = { version = "1", features = ["serde_derive"] }
--- a/README.md
+++ b/README.md
@@ -8,7 +8,7 @@

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

 ## [Documentation](https://docs.rs/winit)
@@ -33,13 +33,9 @@ Winit is designed to be a low-level brick in a hierarchy of libraries. Consequen
 show something on the window you need to use the platform-specific getters provided by winit, or
 another library.

-## CONTRIBUTING
-
-For contributing guidelines see [CONTRIBUTING.md](./CONTRIBUTING.md).
-
 ## MSRV Policy

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

 As a **tentative** policy, the upper bound of the MSRV is given by the following
@@ -71,9 +67,3 @@ same MSRV policy.
 ### Platform-specific usage

 Check out the [`winit::platform`](https://docs.rs/winit/latest/winit/platform/index.html) module for platform-specific usage.
-
-### Repository License
-
-Note that the license in `LICENSE` doesn't apply in full to the DPI package [./dpi](./dpi).
-Full details can be found in that folder's README.
-<!-- This doesn't apply to users of the Winit crate, but this is also the repository level README -->
--- a/winit/build.rs
+++ b/winit/build.rs
@@ -1,9 +1,7 @@
 use cfg_aliases::cfg_aliases;

-// Only relevant for examples and Winit, our usage of println! is fine here.
-#[allow(clippy::disallowed_macros)]
 fn main() {
-    // Dummy invocation to enable change-tracking in build scripts.
+    // The script doesn't depend on our code.
    println!("cargo:rerun-if-changed=build.rs");

    // Setup cfg aliases.
--- a/clippy.toml
+++ b/clippy.toml
@@ -1,27 +1,16 @@
-# Using allow-invalid because this is platform-specific code
-disallowed-macros = [
-    { path = "std::print", reason = "works badly on web", replacement = "tracing::info" },
-    { path = "std::println", reason = "works badly on web", replacement = "tracing::info" },
-    { path = "std::eprint", reason = "works badly on web", replacement = "tracing::error" },
-    { path = "std::eprintln", reason = "works badly on web", replacement = "tracing::error" },
-    { path = "std::dbg", reason = "leftover debugging aid, remove it or use tracing" },
-]
 disallowed-methods = [
-    { 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" },
+    { 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" },
 ]
--- a/deny.toml
+++ b/deny.toml
@@ -1,25 +1,27 @@
 # https://embarkstudios.github.io/cargo-deny
 # cargo install cargo-deny
-# cargo update && cargo deny check
+# cargo update && cargo deny --target aarch64-apple-ios check
+# Note: running just `cargo deny check` without a `--target` will result in
+# false positives due to https://github.com/EmbarkStudios/cargo-deny/issues/324
 [graph]
 all-features = true
 exclude-dev = true
 targets = [
-    "aarch64-apple-darwin",
-    "aarch64-apple-ios",
-    "aarch64-linux-android",
-    "i686-pc-windows-gnu",
-    "i686-pc-windows-msvc",
-    "i686-unknown-linux-gnu",
+    { triple = "aarch64-apple-darwin" },
+    { triple = "aarch64-apple-ios" },
+    { triple = "aarch64-linux-android" },
+    { triple = "i686-pc-windows-gnu" },
+    { triple = "i686-pc-windows-msvc" },
+    { triple = "i686-unknown-linux-gnu" },
    { triple = "wasm32-unknown-unknown", features = [
        "atomics",
    ] },
-    "x86_64-apple-darwin",
-    "x86_64-apple-ios",
-    "x86_64-pc-windows-gnu",
-    "x86_64-pc-windows-msvc",
-    "x86_64-unknown-linux-gnu",
-    "x86_64-unknown-redox",
+    { triple = "x86_64-apple-darwin" },
+    { triple = "x86_64-apple-ios" },
+    { triple = "x86_64-pc-windows-gnu" },
+    { triple = "x86_64-pc-windows-msvc" },
+    { triple = "x86_64-unknown-linux-gnu" },
+    { triple = "x86_64-unknown-redox" },
 ]

 [licenses]
@@ -30,32 +32,41 @@ allow = [
    "ISC",          # https://tldrlegal.com/license/isc-license
    "MIT",          # https://tldrlegal.com/license/mit-license
    "Unicode-3.0",  # https://spdx.org/licenses/Unicode-3.0.html
-    "Zlib",         # https://spdx.org/licenses/Zlib.html
-    "MPL-2.0",      # https://www.mozilla.org/en-US/MPL/2.0/
 ]
 confidence-threshold = 1.0
 private = { ignore = true }

 [bans]
 multiple-versions = "deny"
-skip = [
-    { crate = "jni-sys@0.3", reason = "uses the semver trick to depend on v0.4, but `ndk` hasn't been updated to v0.4 yet" },
-    { crate = "thiserror@1.0", reason = "dep of `ndk` crate, yet to be updated" },
-    { crate = "thiserror-impl@1.0", reason = "dep of `thiserror`" },
-    { crate = "objc2@0.5", reason = "used by crossfont" },
-    { crate = "objc2-foundation@0.2", reason = "used by crossfont" },
-]
-skip-tree = [
-    { crate = "windows-sys", reason = "foundational but bumps fairly often, nothing we can do about it not having a shared version" },
-]
+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

 [bans.build]
-bypass = [
-    { crate = "android-activity", allow-globs = ["android-games-sdk/import-games-sdk.sh"] },
-    { crate = "freetype-sys", allow-globs = ["freetype2/*"] },
-    # `crossfont` still depends (partially transitively) on `winapi`.
-    { crate = "winapi-i686-pc-windows-gnu", allow-globs = ["lib/lib*.a"] },
-    { crate = "winapi-x86_64-pc-windows-gnu", allow-globs = ["lib/lib*.a"] },
-]
 include-archives = true
 interpreted = "deny"
+
+[[bans.build.bypass]]
+allow = [
+    { path = "generate-bindings.sh", checksum = "268ec23248218d779e33853cdc60e2985e70214ff004716cd734270de1f6b561" },
+]
+crate = "android-activity"
+
+[[bans.build.bypass]]
+allow-globs = ["freetype2/*"]
+crate = "freetype-sys"
+
+[[bans.build.bypass]]
+allow-globs = ["lib/*.a"]
+crate = "windows_i686_gnu"
+
+[[bans.build.bypass]]
+allow-globs = ["lib/*.lib"]
+crate = "windows_i686_msvc"
+
+[[bans.build.bypass]]
+allow-globs = ["lib/*.a"]
+crate = "windows_x86_64_gnu"
+
+[[bans.build.bypass]]
+allow-globs = ["lib/*.lib"]
+crate = "windows_x86_64_msvc"
--- a/docs/ATTRIBUTION.md
+++ b/docs/ATTRIBUTION.md
@@ -0,0 +1,18 @@
+# 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/winit/docs/coordinate-systems.drawio
+++ b/winit/docs/coordinate-systems.drawio
--- a/winit/docs/res/coordinate-systems-desktop.svg
+++ b/winit/docs/res/coordinate-systems-desktop.svg
--- a/winit/docs/res/coordinate-systems-mobile.svg
+++ b/winit/docs/res/coordinate-systems-mobile.svg
--- 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/CHANGELOG.md
+++ b/dpi/CHANGELOG.md
@@ -11,10 +11,7 @@ Unreleased` header.

 ## Unreleased

-## 0.1.2
-
 - Added `Insets`, `LogicalInsets` and `PhysicalInsets` types.
- Make `no_std` compatible. If you use this functionality, DPI's license has changed.

 ## 0.1.1

--- a/dpi/Cargo.toml
+++ b/dpi/Cargo.toml
@@ -3,22 +3,16 @@ categories = ["gui"]
 description = "Types for handling UI scaling"
 edition.workspace = true
 keywords = ["DPI", "HiDPI", "scale-factor"]
-# N.B. This is "AND", because of the imported libm code.
-license = "Apache-2.0 AND MIT"
+license.workspace = true
 name = "dpi"
 repository.workspace = true
 rust-version.workspace = true
-version = "0.1.2"
+version = "0.1.1"

 [features]
-default = ["std"]
-
 mint = ["dep:mint"]
 serde = ["dep:serde"]

-# Access mathematical functions using the standard library implementations
-std = []
-
 [dependencies]
 mint = { workspace = true, optional = true }
 serde = { workspace = true, optional = true }
--- a/dpi/LICENSE-LIBM-MIT
+++ b/dpi/LICENSE-LIBM-MIT
@@ -1,51 +0,0 @@
-rust-lang/libm as a whole is available for use under the MIT license:
-
------------------------------------------------------------------------------
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
------------------------------------------------------------------------------
-
-This Rust library contains the following copyrights:
-
-    Copyright (c) 2018 Jorge Aparicio
-
-Portions of this software are derived from third-party works licensed under
-terms compatible with the above MIT license:
-
-* musl libc https://www.musl-libc.org/. This library contains the following
-  copyright:
-
-      Copyright © 2005-2020 Rich Felker, et al.
-
-* The CORE-MATH project https://core-math.gitlabpages.inria.fr/. CORE-MATH
-  routines are available under the MIT license on a per-file basis.
-
-The musl libc COPYRIGHT file also includes the following notice relevant to
-math portions of the library:
-
------------------------------------------------------------------------------
-Much of the math library code (src/math/* and src/complex/*) is
-Copyright © 1993,2004 Sun Microsystems or
-Copyright © 2003-2011 David Schultz or
-Copyright © 2003-2009 Steven G. Kargl or
-Copyright © 2003-2009 Bruce D. Evans or
-Copyright © 2008 Stephen L. Moshier or
-Copyright © 2017-2018 Arm Limited
-and labelled as such in comments in the individual source files. All
-have been licensed under extremely permissive terms.
------------------------------------------------------------------------------
--- a/dpi/README.md
+++ b/dpi/README.md
@@ -1,18 +0,0 @@
-# DPI
-
-Full docs can be found on docs.rs.
-
-## License
-
-Most of DPI is licensed under the Apache License, Version 2.0 ([LICENSE](LICENSE)).
-All files except for `src/libm.rs` (and `LICENSE-LIBM-MIT`) are available solely under that license.
-
-For its `no_std` support, DPI uses code from the [libm](https://crates.io/crates/libm) crate.
-This is in the `libm.rs` file, and is licensed solely under the MIT Licence ([LICENSE-LIBM-MIT](LICENSE-LIBM-MIT)).
-That file contains details of all potentially applicable copyright notices.
-This is feature gated to only be included if you disable the `std` feature, otherwise it will not be compiled into your final binary
-(and so these license terms will not apply).
-
-Overall, this means that the license for this crate depends on what features you have enabled.
-If you enable the `std` feature, then DPI uses only code available under the Apache-2.0 license, and so can be used under the terms of that license.
-However, if you disable the `std` feature, then both these licenses must be followed to use the crate as a whole.
--- a/dpi/src/lib.rs
+++ b/dpi/src/lib.rs
@@ -54,25 +54,13 @@
 //!
 //! * `serde`: Enables serialization/deserialization of certain types with [Serde](https://crates.io/crates/serde).
 //! * `mint`: Enables mint (math interoperability standard types) conversions.
-//! * `std` (enabled by default): Uses the standard library mathematical functions (normally through
-//!   your target platform's libm). This feature also changes the library's license from `Apache-2.0
-//!   AND MIT` to `APACHE-2.0` (only). For full details, see the package README.
 //!
-//! To use this library on a target without the standard library available, you should disable
-//! default features (thus disabling the `std` feature, with the license consequences thereof).
 //!
 //! [points]: https://en.wikipedia.org/wiki/Point_(typography)
 //! [picas]: https://en.wikipedia.org/wiki/Pica_(typography)

-#![cfg_attr(docsrs, feature(doc_cfg), doc(auto_cfg(hide(doc, docsrs))))]
-#![cfg_attr(feature = "std", forbid(unsafe_code))]
-#![no_std]
-
-#[cfg(not(feature = "std"))]
-mod libm;
-
-#[cfg(any(feature = "std", test))]
-extern crate std;
+#![cfg_attr(docsrs, feature(doc_auto_cfg, doc_cfg_hide), doc(cfg_hide(doc, docsrs)))]
+#![forbid(unsafe_code)]

 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
@@ -84,18 +72,36 @@ pub trait Pixel: Copy + Into<f64> {
    }
 }

-macro_rules! pixel_int_impl {
-    ($($t:ty),*) => {$(
-        impl Pixel for $t {
-            fn from_f64(f: f64) -> Self {
-                round(f) as $t
-            }
-        }
-    )*}
+impl Pixel for u8 {
+    fn from_f64(f: f64) -> Self {
+        f.round() as u8
+    }
+}
+impl Pixel for u16 {
+    fn from_f64(f: f64) -> Self {
+        f.round() as u16
+    }
+}
+impl Pixel for u32 {
+    fn from_f64(f: f64) -> Self {
+        f.round() as u32
+    }
+}
+impl Pixel for i8 {
+    fn from_f64(f: f64) -> Self {
+        f.round() as i8
+    }
+}
+impl Pixel for i16 {
+    fn from_f64(f: f64) -> Self {
+        f.round() as i16
+    }
+}
+impl Pixel for i32 {
+    fn from_f64(f: f64) -> Self {
+        f.round() as i32
+    }
 }
-
-pixel_int_impl!(u8, u16, u32, i8, i16, i32);
-
 impl Pixel for f32 {
    fn from_f64(f: f64) -> Self {
        f as f32
@@ -107,15 +113,6 @@ impl Pixel for f64 {
    }
 }

-/// Round f to the closest integer, rounding away from `0.0`
-#[inline]
-fn round(f: f64) -> f64 {
-    #[cfg(feature = "std")]
-    return f.round();
-    #[cfg(not(feature = "std"))]
-    return libm::round(f);
-}
-
 /// Checks that the scale factor is a normal positive `f64`.
 ///
 /// All functions that take a scale factor assert that this will return `true`. If you're sourcing
@@ -360,48 +357,6 @@ impl<P: Pixel> From<LogicalUnit<P>> for PixelUnit {
    }
 }

-macro_rules! vec2_from_impls {
-    ($t:ident, $a:ident, $b:ident, $mint_ty:ident) => {
-        impl<P: Pixel, X: Pixel> From<(X, X)> for $t<P> {
-            fn from(($a, $b): (X, X)) -> Self {
-                Self::new($a.cast(), $b.cast())
-            }
-        }
-
-        impl<P: Pixel, X: Pixel> From<$t<P>> for (X, X) {
-            fn from(p: $t<P>) -> Self {
-                (p.$a.cast(), p.$b.cast())
-            }
-        }
-
-        impl<P: Pixel, X: Pixel> From<[X; 2]> for $t<P> {
-            fn from([$a, $b]: [X; 2]) -> Self {
-                Self::new($a.cast(), $b.cast())
-            }
-        }
-
-        impl<P: Pixel, X: Pixel> From<$t<P>> for [X; 2] {
-            fn from(p: $t<P>) -> Self {
-                [p.$a.cast(), p.$b.cast()]
-            }
-        }
-
-        #[cfg(feature = "mint")]
-        impl<P: Pixel> From<mint::$mint_ty<P>> for $t<P> {
-            fn from(p: mint::$mint_ty<P>) -> Self {
-                Self::new(p.x, p.y)
-            }
-        }
-
-        #[cfg(feature = "mint")]
-        impl<P: Pixel> From<$t<P>> for mint::$mint_ty<P> {
-            fn from(p: $t<P>) -> Self {
-                Self { x: p.$a, y: p.$b }
-            }
-        }
-    };
-}
-
 /// A position represented in logical pixels.
 ///
 /// The position is stored as floats, so please be careful. Casting floats to integers truncates the
@@ -444,7 +399,43 @@ impl<P: Pixel> LogicalPosition<P> {
    }
 }

-vec2_from_impls!(LogicalPosition, x, y, Point2);
+impl<P: Pixel, X: Pixel> From<(X, X)> for LogicalPosition<P> {
+    fn from((x, y): (X, X)) -> LogicalPosition<P> {
+        LogicalPosition::new(x.cast(), y.cast())
+    }
+}
+
+impl<P: Pixel, X: Pixel> From<LogicalPosition<P>> for (X, X) {
+    fn from(p: LogicalPosition<P>) -> (X, X) {
+        (p.x.cast(), p.y.cast())
+    }
+}
+
+impl<P: Pixel, X: Pixel> From<[X; 2]> for LogicalPosition<P> {
+    fn from([x, y]: [X; 2]) -> LogicalPosition<P> {
+        LogicalPosition::new(x.cast(), y.cast())
+    }
+}
+
+impl<P: Pixel, X: Pixel> From<LogicalPosition<P>> for [X; 2] {
+    fn from(p: LogicalPosition<P>) -> [X; 2] {
+        [p.x.cast(), p.y.cast()]
+    }
+}
+
+#[cfg(feature = "mint")]
+impl<P: Pixel> From<mint::Point2<P>> for LogicalPosition<P> {
+    fn from(p: mint::Point2<P>) -> Self {
+        Self::new(p.x, p.y)
+    }
+}
+
+#[cfg(feature = "mint")]
+impl<P: Pixel> From<LogicalPosition<P>> for mint::Point2<P> {
+    fn from(p: LogicalPosition<P>) -> Self {
+        mint::Point2 { x: p.x, y: p.y }
+    }
+}

 /// A position represented in physical pixels.
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Default, Hash)]
@@ -484,7 +475,43 @@ impl<P: Pixel> PhysicalPosition<P> {
    }
 }

-vec2_from_impls!(PhysicalPosition, x, y, Point2);
+impl<P: Pixel, X: Pixel> From<(X, X)> for PhysicalPosition<P> {
+    fn from((x, y): (X, X)) -> PhysicalPosition<P> {
+        PhysicalPosition::new(x.cast(), y.cast())
+    }
+}
+
+impl<P: Pixel, X: Pixel> From<PhysicalPosition<P>> for (X, X) {
+    fn from(p: PhysicalPosition<P>) -> (X, X) {
+        (p.x.cast(), p.y.cast())
+    }
+}
+
+impl<P: Pixel, X: Pixel> From<[X; 2]> for PhysicalPosition<P> {
+    fn from([x, y]: [X; 2]) -> PhysicalPosition<P> {
+        PhysicalPosition::new(x.cast(), y.cast())
+    }
+}
+
+impl<P: Pixel, X: Pixel> From<PhysicalPosition<P>> for [X; 2] {
+    fn from(p: PhysicalPosition<P>) -> [X; 2] {
+        [p.x.cast(), p.y.cast()]
+    }
+}
+
+#[cfg(feature = "mint")]
+impl<P: Pixel> From<mint::Point2<P>> for PhysicalPosition<P> {
+    fn from(p: mint::Point2<P>) -> Self {
+        Self::new(p.x, p.y)
+    }
+}
+
+#[cfg(feature = "mint")]
+impl<P: Pixel> From<PhysicalPosition<P>> for mint::Point2<P> {
+    fn from(p: PhysicalPosition<P>) -> Self {
+        mint::Point2 { x: p.x, y: p.y }
+    }
+}

 /// A size represented in logical pixels.
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Default, Hash)]
@@ -524,7 +551,43 @@ impl<P: Pixel> LogicalSize<P> {
    }
 }

-vec2_from_impls!(LogicalSize, width, height, Vector2);
+impl<P: Pixel, X: Pixel> From<(X, X)> for LogicalSize<P> {
+    fn from((x, y): (X, X)) -> LogicalSize<P> {
+        LogicalSize::new(x.cast(), y.cast())
+    }
+}
+
+impl<P: Pixel, X: Pixel> From<LogicalSize<P>> for (X, X) {
+    fn from(s: LogicalSize<P>) -> (X, X) {
+        (s.width.cast(), s.height.cast())
+    }
+}
+
+impl<P: Pixel, X: Pixel> From<[X; 2]> for LogicalSize<P> {
+    fn from([x, y]: [X; 2]) -> LogicalSize<P> {
+        LogicalSize::new(x.cast(), y.cast())
+    }
+}
+
+impl<P: Pixel, X: Pixel> From<LogicalSize<P>> for [X; 2] {
+    fn from(s: LogicalSize<P>) -> [X; 2] {
+        [s.width.cast(), s.height.cast()]
+    }
+}
+
+#[cfg(feature = "mint")]
+impl<P: Pixel> From<mint::Vector2<P>> for LogicalSize<P> {
+    fn from(v: mint::Vector2<P>) -> Self {
+        Self::new(v.x, v.y)
+    }
+}
+
+#[cfg(feature = "mint")]
+impl<P: Pixel> From<LogicalSize<P>> for mint::Vector2<P> {
+    fn from(s: LogicalSize<P>) -> Self {
+        mint::Vector2 { x: s.width, y: s.height }
+    }
+}

 /// A size represented in physical pixels.
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Default, Hash)]
@@ -561,7 +624,43 @@ impl<P: Pixel> PhysicalSize<P> {
    }
 }

-vec2_from_impls!(PhysicalSize, width, height, Vector2);
+impl<P: Pixel, X: Pixel> From<(X, X)> for PhysicalSize<P> {
+    fn from((x, y): (X, X)) -> PhysicalSize<P> {
+        PhysicalSize::new(x.cast(), y.cast())
+    }
+}
+
+impl<P: Pixel, X: Pixel> From<PhysicalSize<P>> for (X, X) {
+    fn from(s: PhysicalSize<P>) -> (X, X) {
+        (s.width.cast(), s.height.cast())
+    }
+}
+
+impl<P: Pixel, X: Pixel> From<[X; 2]> for PhysicalSize<P> {
+    fn from([x, y]: [X; 2]) -> PhysicalSize<P> {
+        PhysicalSize::new(x.cast(), y.cast())
+    }
+}
+
+impl<P: Pixel, X: Pixel> From<PhysicalSize<P>> for [X; 2] {
+    fn from(s: PhysicalSize<P>) -> [X; 2] {
+        [s.width.cast(), s.height.cast()]
+    }
+}
+
+#[cfg(feature = "mint")]
+impl<P: Pixel> From<mint::Vector2<P>> for PhysicalSize<P> {
+    fn from(v: mint::Vector2<P>) -> Self {
+        Self::new(v.x, v.y)
+    }
+}
+
+#[cfg(feature = "mint")]
+impl<P: Pixel> From<PhysicalSize<P>> for mint::Vector2<P> {
+    fn from(s: PhysicalSize<P>) -> Self {
+        mint::Vector2 { x: s.width, y: s.height }
+    }
+}

 /// A size that's either physical or logical.
 #[derive(Debug, Copy, Clone, PartialEq)]
@@ -1171,20 +1270,20 @@ mod tests {
    // Eat coverage for the Debug impls et al
    #[test]
    fn ensure_attrs_do_not_panic() {
-        let _ = std::format!("{:?}", LogicalPosition::<u32>::default().clone());
+        let _ = format!("{:?}", LogicalPosition::<u32>::default().clone());
        HashSet::new().insert(LogicalPosition::<u32>::default());

-        let _ = std::format!("{:?}", PhysicalPosition::<u32>::default().clone());
+        let _ = format!("{:?}", PhysicalPosition::<u32>::default().clone());
        HashSet::new().insert(PhysicalPosition::<u32>::default());

-        let _ = std::format!("{:?}", LogicalSize::<u32>::default().clone());
+        let _ = format!("{:?}", LogicalSize::<u32>::default().clone());
        HashSet::new().insert(LogicalSize::<u32>::default());

-        let _ = std::format!("{:?}", PhysicalSize::<u32>::default().clone());
+        let _ = format!("{:?}", PhysicalSize::<u32>::default().clone());
        HashSet::new().insert(PhysicalSize::<u32>::default());

-        let _ = std::format!("{:?}", Size::Physical((1, 2).into()).clone());
-        let _ = std::format!("{:?}", Position::Physical((1, 2).into()).clone());
+        let _ = format!("{:?}", Size::Physical((1, 2).into()).clone());
+        let _ = format!("{:?}", Position::Physical((1, 2).into()).clone());
    }

    #[test]
--- a/dpi/src/libm.rs
+++ b/dpi/src/libm.rs
@@ -1,56 +0,0 @@
-// Copyright (c) 2018 Jorge Aparicio
-// Copyright © 2005-2020 Rich Felker, et al.
-// Copyright © 1993,2004 Sun Microsystems or
-// Copyright © 2003-2011 David Schultz or
-// Copyright © 2003-2009 Steven G. Kargl or
-// Copyright © 2003-2009 Bruce D. Evans or
-// Copyright © 2008 Stephen L. Moshier or
-// Copyright © 2017-2018 Arm Limited
-// SPDX-License-Identifier: MIT
-// This file is licensed solely under the terms discussed in LICENSE-LIBM-MIT at the crate root.
-// See the package-level README for full details.
-
-// Taken from https://github.com/rust-lang/libm/blob/master/src/math/mod.rs#L1
-macro_rules! force_eval {
-    ($e:expr) => {
-        unsafe { ::core::ptr::read_volatile(&$e) }
-    };
-}
-
-// Taken from https://github.com/rust-lang/libm/blob/libm-v0.2.11/src/math/round.rs
-pub(crate) fn round(x: f64) -> f64 {
-    trunc(x + copysign(0.5 - 0.25 * f64::EPSILON, x))
-}
-
-// Adapted from: https://github.com/rust-lang/libm/blob/libm-v0.2.11/src/math/trunc.rs#L8-L12
-#[allow(clippy::needless_late_init /*, reason = "The original libm code uses this style" */)]
-fn trunc(x: f64) -> f64 {
-    let x1p120 = f64::from_bits(0x4770000000000000); // 0x1p120f === 2 ^ 120
-
-    let mut i: u64 = x.to_bits();
-    let mut e: i64 = ((i >> 52) & 0x7ff) as i64 - 0x3ff + 12;
-    let m: u64;
-
-    if e >= 52 + 12 {
-        return x;
-    }
-    if e < 12 {
-        e = 1;
-    }
-    m = -1i64 as u64 >> e;
-    if (i & m) == 0 {
-        return x;
-    }
-    force_eval!(x + x1p120);
-    i &= !m;
-    f64::from_bits(i)
-}
-
-// Taken from https://github.com/rust-lang/libm/blob/libm-v0.2.11/src/math/copysign.rs
-fn copysign(x: f64, y: f64) -> f64 {
-    let mut ux = x.to_bits();
-    let uy = y.to_bits();
-    ux &= (!0) >> 1;
-    ux |= uy & (1 << 63);
-    f64::from_bits(ux)
-}
--- a/1
+++ b/1
@@ -1 +0,0 @@
-winit/examples
--- a/winit/examples/application.rs
+++ b/winit/examples/application.rs
@@ -1,48 +1,45 @@
 //! Simple winit application.
-//!
-//! Note that a real application accepting text input **should** support
-//! the IME interface. See the `ime` example.

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

+use ::tracing::{error, info};
 use cursor_icon::CursorIcon;
+#[cfg(not(android_platform))]
+use rwh_06::{DisplayHandle, HasDisplayHandle};
+#[cfg(not(android_platform))]
 use softbuffer::{Context, Surface};
-use tracing::{error, info};
-#[cfg(web_platform)]
-use web_time::Instant;
 use winit::application::ApplicationHandler;
-use winit::cursor::{Cursor, CustomCursor, CustomCursorSource};
 use winit::dpi::{LogicalSize, PhysicalPosition, PhysicalSize};
 use winit::error::RequestError;
-use winit::event::{DeviceEvent, DeviceId, MouseButton, MouseScrollDelta, WindowEvent};
-use winit::event_loop::{ActiveEventLoop, EventLoop, OwnedDisplayHandle};
-use winit::icon::{Icon, RgbaIcon};
+use winit::event::{DeviceEvent, DeviceId, Ime, MouseButton, MouseScrollDelta, WindowEvent};
+use winit::event_loop::{ActiveEventLoop, EventLoop};
 use winit::keyboard::{Key, ModifiersState};
-use winit::monitor::Fullscreen;
 #[cfg(macos_platform)]
-use winit::platform::macos::{OptionAsAlt, WindowAttributesMacOS, WindowExtMacOS};
+use winit::platform::macos::{
+    ApplicationHandlerExtMacOS, OptionAsAlt, WindowAttributesExtMacOS, WindowExtMacOS,
+};
 #[cfg(any(x11_platform, wayland_platform))]
-use winit::platform::startup_notify::{self, EventLoopExtStartupNotify, WindowExtStartupNotify};
-#[cfg(wayland_platform)]
-use winit::platform::wayland::{ActiveEventLoopExtWayland, WindowAttributesWayland};
+use winit::platform::startup_notify::{
+    self, EventLoopExtStartupNotify, WindowAttributesExtStartupNotify, WindowExtStartupNotify,
+};
 #[cfg(web_platform)]
-use winit::platform::web::{ActiveEventLoopExtWeb, WindowAttributesWeb};
+use winit::platform::web::{ActiveEventLoopExtWeb, CustomCursorExtWeb, WindowAttributesExtWeb};
 #[cfg(x11_platform)]
-use winit::platform::x11::{ActiveEventLoopExtX11, WindowAttributesX11};
-use winit::window::{CursorGrabMode, ResizeDirection, Theme, Window, WindowAttributes, WindowId};
-use winit_core::application::macos::ApplicationHandlerExtMacOS;
+use winit::platform::x11::WindowAttributesExtX11;
+use winit::window::{
+    Cursor, CursorGrabMode, CustomCursor, CustomCursorSource, Fullscreen, Icon, ResizeDirection,
+    Theme, Window, WindowAttributes, WindowId,
+};

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

 /// The amount of points to around the window for drag resize direction calculations.
 const BORDER_SIZE: f64 = 20.;
@@ -51,7 +48,7 @@ fn main() -> Result<(), Box<dyn Error>> {
    #[cfg(web_platform)]
    console_error_panic_hook::set_once();

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

    let event_loop = EventLoop::new()?;
    let (sender, receiver) = mpsc::channel();
@@ -90,12 +87,22 @@ struct Application {
    /// Drawing context.
    ///
    /// With OpenGL it could be EGLDisplay.
-    context: Context<OwnedDisplayHandle>,
+    #[cfg(not(android_platform))]
+    context: Option<Context<DisplayHandle<'static>>>,
 }

 impl Application {
    fn new(event_loop: &EventLoop, receiver: Receiver<Action>, sender: Sender<Action>) -> Self {
-        let context = Context::new(event_loop.owned_display_handle()).unwrap();
+        // SAFETY: we drop the context right before the event loop is stopped, thus making it safe.
+        #[cfg(not(android_platform))]
+        let context = Some(
+            Context::new(unsafe {
+                std::mem::transmute::<DisplayHandle<'_>, DisplayHandle<'static>>(
+                    event_loop.display_handle().unwrap(),
+                )
+            })
+            .unwrap(),
+        );

        // You'll have to choose an icon size at your own discretion. On X11, the desired size
        // varies by WM, and on Windows, you still have to account for screen scaling. Here
@@ -113,7 +120,15 @@ impl Application {
        .into_iter()
        .collect();

-        Self { receiver, sender, context, custom_cursors, icon, windows: Default::default() }
+        Self {
+            receiver,
+            sender,
+            #[cfg(not(android_platform))]
+            context,
+            custom_cursors,
+            icon,
+            windows: Default::default(),
+        }
    }

    fn create_window(
@@ -129,29 +144,43 @@ impl Application {
            .with_transparent(true)
            .with_window_icon(Some(self.icon.clone()));

-        #[cfg(x11_platform)]
-        if event_loop.is_x11() {
-            window_attributes = window_attributes
-                .with_platform_attributes(Box::new(window_attributes_x11(event_loop)?));
+        #[cfg(any(x11_platform, wayland_platform))]
+        if let Some(token) = event_loop.read_token_from_env() {
+            startup_notify::reset_activation_token_env();
+            info!("Using token {:?} to activate a window", token);
+            window_attributes = window_attributes.with_activation_token(token);
        }

-        #[cfg(wayland_platform)]
-        if event_loop.is_wayland() {
-            window_attributes = window_attributes
-                .with_platform_attributes(Box::new(window_attributes_wayland(event_loop)));
+        #[cfg(x11_platform)]
+        match std::env::var("X11_VISUAL_ID") {
+            Ok(visual_id_str) => {
+                info!("Using X11 visual id {visual_id_str}");
+                let visual_id = visual_id_str.parse()?;
+                window_attributes = window_attributes.with_x11_visual(visual_id);
+            },
+            Err(_) => info!("Set the X11_VISUAL_ID env variable to request specific X11 visual"),
+        }
+
+        #[cfg(x11_platform)]
+        match std::env::var("X11_SCREEN_ID") {
+            Ok(screen_id_str) => {
+                info!("Placing the window on X11 screen {screen_id_str}");
+                let screen_id = screen_id_str.parse()?;
+                window_attributes = window_attributes.with_x11_screen(screen_id);
+            },
+            Err(_) => info!(
+                "Set the X11_SCREEN_ID env variable to place the window on non-default screen"
+            ),
        }

        #[cfg(macos_platform)]
        if let Some(tab_id) = _tab_id {
-            let window_attributes_macos =
-                Box::new(WindowAttributesMacOS::default().with_tabbing_identifier(&tab_id));
-            window_attributes = window_attributes.with_platform_attributes(window_attributes_macos);
+            window_attributes = window_attributes.with_tabbing_identifier(&tab_id);
        }

        #[cfg(web_platform)]
        {
-            window_attributes =
-                window_attributes.with_platform_attributes(Box::new(window_attributes_web()));
+            window_attributes = window_attributes.with_append(true);
        }

        let window = event_loop.create_window(window_attributes)?;
@@ -178,15 +207,6 @@ impl Application {
            Action::DumpMonitors => self.dump_monitors(_event_loop),
            Action::Message => {
                info!("User wake up");
-                for (id, window) in self.windows.iter() {
-                    if window.emit_surface_size {
-                        let size = window.window.surface_size();
-                        info!(
-                            "Window {id:?} has physical surface size {}x{}",
-                            size.width, size.height
-                        );
-                    }
-                }
            },
            _ => unreachable!("Tried to execute invalid action without `WindowId`"),
        }
@@ -226,13 +246,8 @@ impl Application {
            Action::ToggleSimpleFullscreen => {
                window.window.set_simple_fullscreen(!window.window.simple_fullscreen());
            },
-            #[cfg(macos_platform)]
-            Action::ToggleBorderlessGame => {
-                let current = window.window.is_borderless_game();
-                window.window.set_borderless_game(!current);
-                info!("Borderless game: {}", !current);
-            },
            Action::ToggleMaximize => window.toggle_maximize(),
+            Action::ToggleImeInput => window.toggle_ime(),
            Action::Minimize => window.minimize(),
            Action::NextCursor => window.next_cursor(),
            Action::NextCustomCursor => {
@@ -298,16 +313,6 @@ impl Application {
                self.sender.send(Action::Message).unwrap();
                event_loop.create_proxy().wake_up();
            },
-            Action::ToggleAnimatedFillColor => {
-                window.animated_fill_color = !window.animated_fill_color;
-            },
-            Action::ToggleContinuousRedraw => {
-                window.continuous_redraw = !window.continuous_redraw;
-                window.window.request_redraw();
-            },
-            Action::EmitSurfaceSize => {
-                window.toggle_emit_surface_size();
-            },
        }
    }

@@ -435,9 +440,6 @@ impl ApplicationHandler for Application {
                if let Err(err) = window.draw() {
                    error!("Error drawing window: {err}");
                }
-                if window.continuous_redraw {
-                    window.window.request_redraw();
-                }
            },
            WindowEvent::Occluded(occluded) => {
                window.set_occluded(occluded);
@@ -463,7 +465,7 @@ impl ApplicationHandler for Application {

                // Dispatch actions only on press.
                if event.state.is_pressed() {
-                    let action = if let Key::Character(ch) = event.key_without_modifiers.as_ref() {
+                    let action = if let Key::Character(ch) = event.logical_key.as_ref() {
                        Self::process_key_binding(&ch.to_uppercase(), &mods)
                    } else {
                        None
@@ -479,9 +481,8 @@ impl ApplicationHandler for Application {
                let mods = window.modifiers;
                if let Some(action) = state
                    .is_pressed()
-                    .then(|| button.mouse_button())
+                    .then(|| Self::process_mouse_binding(button.mouse_button(), &mods))
                    .flatten()
-                    .and_then(|button| Self::process_mouse_binding(button, &mods))
                {
                    self.handle_action_with_window(event_loop, window_id, action);
                }
@@ -503,6 +504,16 @@ impl ApplicationHandler for Application {
                    }
                }
            },
+            WindowEvent::Ime(event) => match event {
+                Ime::Enabled => info!("IME enabled for Window={window_id:?}"),
+                Ime::Preedit(text, caret_pos) => {
+                    info!("Preedit: {}, with caret at {:?}", text, caret_pos);
+                },
+                Ime::Commit(text) => {
+                    info!("Committed: {}", text);
+                },
+                Ime::Disabled => info!("IME disabled for Window={window_id:?}"),
+            },
            WindowEvent::PinchGesture { delta, .. } => {
                window.zoom += delta;
                let zoom = window.zoom;
@@ -529,7 +540,15 @@ impl ApplicationHandler for Application {
            WindowEvent::DoubleTapGesture { .. } => {
                info!("Smart zoom");
            },
-            _ => (),
+            WindowEvent::TouchpadPressure { .. }
+            | WindowEvent::DragLeft { .. }
+            | WindowEvent::KeyboardInput { .. }
+            | WindowEvent::PointerEntered { .. }
+            | WindowEvent::DragEntered { .. }
+            | WindowEvent::DragMoved { .. }
+            | WindowEvent::DragDropped { .. }
+            | WindowEvent::Destroyed
+            | WindowEvent::Moved(_) => (),
        }
    }

@@ -559,17 +578,19 @@ impl ApplicationHandler for Application {
        }
    }

+    #[cfg(not(android_platform))]
+    fn exiting(&mut self, _event_loop: &dyn ActiveEventLoop) {
+        // We must drop the context here.
+        self.context = None;
+    }
+
+    #[cfg(target_os = "macos")]
    fn macos_handler(&mut self) -> Option<&mut dyn ApplicationHandlerExtMacOS> {
        Some(self)
    }
 }

-impl Drop for Application {
-    fn drop(&mut self) {
-        info!("Application exited");
-    }
-}
-
+#[cfg(target_os = "macos")]
 impl ApplicationHandlerExtMacOS for Application {
    fn standard_key_binding(
        &mut self,
@@ -583,20 +604,17 @@ impl ApplicationHandlerExtMacOS for Application {

 /// State of the window.
 struct WindowState {
+    /// IME input.
+    ime: bool,
    /// Render surface.
-    surface: Surface<OwnedDisplayHandle, Arc<dyn Window>>,
+    ///
+    /// NOTE: This surface must be dropped before the `Window`.
+    #[cfg(not(android_platform))]
+    surface: Surface<DisplayHandle<'static>, Arc<dyn Window>>,
    /// The actual winit Window.
    window: Arc<dyn Window>,
    /// The window theme we're drawing with.
    theme: Theme,
-    /// Fill the window with animated color
-    animated_fill_color: bool,
-    /// The application start time. Used for color fill animation
-    start_time: Instant,
-    /// Redraw continuously
-    continuous_redraw: bool,
-    /// Periodically emit the surface size
-    emit_surface_size: bool,
    /// Cursor position over the window.
    cursor_position: Option<PhysicalPosition<f64>>,
    /// Window modifiers state.
@@ -625,13 +643,20 @@ impl WindowState {
    fn new(app: &Application, window: Box<dyn Window>) -> Result<Self, Box<dyn Error>> {
        let window: Arc<dyn Window> = Arc::from(window);

-        let surface = Surface::new(&app.context, Arc::clone(&window))?;
+        // SAFETY: the surface is dropped before the `window` which provided it with handle, thus
+        // it doesn't outlive it.
+        #[cfg(not(android_platform))]
+        let surface = Surface::new(app.context.as_ref().unwrap(), Arc::clone(&window))?;

        let theme = window.theme().unwrap_or(Theme::Dark);
        info!("Theme: {theme:?}");
        let named_idx = 0;
        window.set_cursor(CURSORS[named_idx].into());

+        // Allow IME out of the box.
+        let ime = true;
+        window.set_ime_allowed(ime);
+
        let size = window.surface_size();
        let mut state = Self {
            #[cfg(macos_platform)]
@@ -639,13 +664,11 @@ impl WindowState {
            custom_idx: app.custom_cursors.as_ref().map(Vec::len).unwrap_or(1) - 1,
            cursor_grab: CursorGrabMode::None,
            named_idx,
+            #[cfg(not(android_platform))]
            surface,
            window,
            theme,
-            animated_fill_color: false,
-            continuous_redraw: false,
-            emit_surface_size: false,
-            start_time: Instant::now(),
+            ime,
            cursor_position: Default::default(),
            cursor_hidden: Default::default(),
            modifiers: Default::default(),
@@ -659,12 +682,23 @@ impl WindowState {
        Ok(state)
    }

+    pub fn toggle_ime(&mut self) {
+        self.ime = !self.ime;
+        self.window.set_ime_allowed(self.ime);
+        if let Some(position) = self.ime.then_some(self.cursor_position).flatten() {
+            self.window.set_ime_cursor_area(position.into(), PhysicalSize::new(20, 20).into());
+        }
+    }
+
    pub fn minimize(&mut self) {
        self.window.set_minimized(true);
    }

    pub fn cursor_moved(&mut self, position: PhysicalPosition<f64>) {
        self.cursor_position = Some(position);
+        if self.ime {
+            self.window.set_ime_cursor_area(position.into(), PhysicalSize::new(20, 20).into());
+        }
    }

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

-    fn toggle_emit_surface_size(&mut self) {
-        self.emit_surface_size = !self.emit_surface_size;
-    }
-
    /// Cycle through the grab modes ignoring errors.
    fn cycle_cursor_grab(&mut self) {
        self.cursor_grab = match self.cursor_grab {
@@ -805,7 +835,7 @@ impl WindowState {
            custom_cursors[1].clone(),
            event_loop.create_custom_cursor(url_custom_cursor())?,
        ];
-        let cursor = CustomCursorSource::from_animation(Duration::from_secs(3), cursors).unwrap();
+        let cursor = CustomCursor::from_animation(Duration::from_secs(3), cursors).unwrap();
        let cursor = event_loop.create_custom_cursor(cursor)?;

        self.window.set_cursor(cursor.into());
@@ -816,12 +846,15 @@ impl WindowState {
    /// Resize the surface to the new size.
    fn resize(&mut self, size: PhysicalSize<u32>) {
        info!("Surface resized to {size:?}");
-        let (width, height) = match (NonZeroU32::new(size.width), NonZeroU32::new(size.height)) {
-            (Some(width), Some(height)) => (width, height),
-            _ => return,
-        };
-        self.surface.resize(width, height).expect("failed to resize inner buffer");
-
+        #[cfg(not(android_platform))]
+        {
+            let (width, height) = match (NonZeroU32::new(size.width), NonZeroU32::new(size.height))
+            {
+                (Some(width), Some(height)) => (width, height),
+                _ => return,
+            };
+            self.surface.resize(width, height).expect("failed to resize inner buffer");
+        }
        self.window.request_redraw();
    }

@@ -906,6 +939,7 @@ impl WindowState {
    }

    /// Draw the window contents.
+    #[cfg(not(android_platform))]
    fn draw(&mut self) -> Result<(), Box<dyn Error>> {
        if self.occluded {
            info!("Skipping drawing occluded window={:?}", self.window.id());
@@ -914,38 +948,28 @@ impl WindowState {

        let mut buffer = self.surface.buffer_mut()?;

-        if self.animated_fill_color {
-            // Fill the entire buffer with a single color.
-            let time = self.start_time.elapsed().as_secs_f32() * 1.5;
-            let blue = (time.sin() * 255.0) as u32;
-            let green = ((time.cos() * 255.0) as u32) << 8;
-            let red = ((1.0 - time.sin() * 255.0) as u32) << 16;
-            let color = red | green | blue;
-            buffer.fill(color);
-        } else {
-            // Draw a different color inside the safe area
-            let surface_size = self.window.surface_size();
-            let insets = self.window.safe_area();
-            for y in 0..surface_size.height {
-                for x in 0..surface_size.width {
-                    let index = y as usize * surface_size.width as usize + x as usize;
-                    if insets.left <= x
-                        && x <= (surface_size.width - insets.right)
-                        && insets.top <= y
-                        && y <= (surface_size.height - insets.bottom)
-                    {
-                        // In safe area
-                        buffer[index] = match self.theme {
-                            Theme::Light => 0xffe8e8e8, // Light gray
-                            Theme::Dark => 0xff525252,  // Medium gray
-                        };
-                    } else {
-                        // Outside safe area
-                        buffer[index] = match self.theme {
-                            Theme::Light => 0xffffffff, // White
-                            Theme::Dark => 0xff181818,  // Dark gray
-                        };
-                    }
+        // Draw a different color inside the safe area
+        let surface_size = self.window.surface_size();
+        let insets = self.window.safe_area();
+        for y in 0..surface_size.height {
+            for x in 0..surface_size.width {
+                let index = y as usize * surface_size.width as usize + x as usize;
+                if insets.left <= x
+                    && x <= (surface_size.width - insets.right)
+                    && insets.top <= y
+                    && y <= (surface_size.height - insets.bottom)
+                {
+                    // In safe area
+                    buffer[index] = match self.theme {
+                        Theme::Light => 0xffe8e8e8, // Light gray
+                        Theme::Dark => 0xff525252,  // Medium gray
+                    };
+                } else {
+                    // Outside safe area
+                    buffer[index] = match self.theme {
+                        Theme::Light => 0xffffffff, // White
+                        Theme::Dark => 0xff181818,  // Dark gray
+                    };
                }
            }
        }
@@ -956,6 +980,12 @@ impl WindowState {

        Ok(())
    }
+
+    #[cfg(android_platform)]
+    fn draw(&mut self) -> Result<(), Box<dyn Error>> {
+        info!("Drawing but without rendering...");
+        Ok(())
+    }
 }

 struct Binding<T: Eq> {
@@ -980,13 +1010,12 @@ enum Action {
    ToggleCursorVisibility,
    CreateNewWindow,
    ToggleResizeIncrements,
+    ToggleImeInput,
    ToggleDecorations,
    ToggleResizable,
    ToggleFullscreen,
    #[cfg(macos_platform)]
    ToggleSimpleFullscreen,
-    #[cfg(macos_platform)]
-    ToggleBorderlessGame,
    ToggleMaximize,
    Minimize,
    NextCursor,
@@ -1008,9 +1037,6 @@ enum Action {
    RequestResize,
    DumpMonitors,
    Message,
-    ToggleAnimatedFillColor,
-    ToggleContinuousRedraw,
-    EmitSurfaceSize,
 }

 impl Action {
@@ -1019,13 +1045,12 @@ impl Action {
            Action::CloseWindow => "Close window",
            Action::ToggleCursorVisibility => "Hide cursor",
            Action::CreateNewWindow => "Create new window",
+            Action::ToggleImeInput => "Toggle IME input",
            Action::ToggleDecorations => "Toggle decorations",
            Action::ToggleResizable => "Toggle window resizable state",
            Action::ToggleFullscreen => "Toggle fullscreen",
            #[cfg(macos_platform)]
            Action::ToggleSimpleFullscreen => "Toggle simple fullscreen",
-            #[cfg(macos_platform)]
-            Action::ToggleBorderlessGame => "Toggle borderless game mode",
            Action::ToggleMaximize => "Maximize",
            Action::Minimize => "Minimize",
            Action::ToggleResizeIncrements => "Use resize increments when resizing window",
@@ -1056,9 +1081,6 @@ impl Action {
                 information"
            },
            Action::Message => "Prints a message through a user wake up",
-            Action::ToggleAnimatedFillColor => "Toggle animated fill color",
-            Action::ToggleContinuousRedraw => "Toggle continuous redraw",
-            Action::EmitSurfaceSize => "Periodically print the surface size",
        }
    }
 }
@@ -1074,7 +1096,7 @@ fn decode_cursor(bytes: &[u8]) -> CustomCursorSource {
    let samples = img.into_flat_samples();
    let (_, w, h) = samples.extents();
    let (w, h) = (w as u16, h as u16);
-    CustomCursorSource::from_rgba(samples.samples, w, h, w / 2, h / 2).unwrap()
+    CustomCursor::from_rgba(samples.samples, w, h, w / 2, h / 2).unwrap()
 }

 #[cfg(web_platform)]
@@ -1083,14 +1105,11 @@ fn url_custom_cursor() -> CustomCursorSource {

    static URL_COUNTER: AtomicU64 = AtomicU64::new(0);

-    CustomCursorSource::Url {
-        hotspot_x: 64,
-        hotspot_y: 64,
-        url: format!(
-            "https://picsum.photos/128?random={}",
-            URL_COUNTER.fetch_add(1, Ordering::Relaxed)
-        ),
-    }
+    CustomCursor::from_url(
+        format!("https://picsum.photos/128?random={}", URL_COUNTER.fetch_add(1, Ordering::Relaxed)),
+        64,
+        64,
+    )
 }

 fn load_icon(bytes: &[u8]) -> Icon {
@@ -1100,23 +1119,14 @@ fn load_icon(bytes: &[u8]) -> Icon {
        let rgba = image.into_raw();
        (rgba, width, height)
    };
-    RgbaIcon::new(icon_rgba, icon_width, icon_height).expect("Failed to open icon").into()
+    Icon::from_rgba(icon_rgba, icon_width, icon_height).expect("Failed to open icon")
 }

 fn modifiers_to_string(mods: ModifiersState) -> String {
    let mut mods_line = String::new();
    // Always add + since it's printed as a part of the bindings.
    for (modifier, desc) in [
-        (
-            ModifiersState::META,
-            if cfg!(target_os = "windows") {
-                "Win+"
-            } else if cfg!(target_vendor = "apple") {
-                "Cmd+"
-            } else {
-                "Super+"
-            },
-        ),
+        (ModifiersState::SUPER, "Super+"),
        (ModifiersState::ALT, "Alt+"),
        (ModifiersState::CONTROL, "Ctrl+"),
        (ModifiersState::SHIFT, "Shift+"),
@@ -1130,70 +1140,15 @@ fn modifiers_to_string(mods: ModifiersState) -> String {
    mods_line
 }

-fn mouse_button_to_string(button: MouseButton) -> Cow<'static, str> {
+fn mouse_button_to_string(button: MouseButton) -> &'static str {
    match button {
        MouseButton::Left => "LMB",
        MouseButton::Right => "RMB",
        MouseButton::Middle => "MMB",
        MouseButton::Back => "Back",
        MouseButton::Forward => "Forward",
-        other => return format!("button {}", other as u8 + 1).into(),
+        MouseButton::Other(_) => "",
    }
-    .into()
-}
-
-#[cfg(web_platform)]
-fn window_attributes_web() -> WindowAttributesWeb {
-    WindowAttributesWeb::default().with_append(true)
-}
-
-#[cfg(wayland_platform)]
-fn window_attributes_wayland(event_loop: &dyn ActiveEventLoop) -> WindowAttributesWayland {
-    let mut window_attributes = WindowAttributesWayland::default();
-
-    if let Some(token) = event_loop.read_token_from_env() {
-        startup_notify::reset_activation_token_env();
-        info!("Using token {:?} to activate a window", token);
-        window_attributes = window_attributes.with_activation_token(token);
-    }
-
-    window_attributes
-}
-
-#[cfg(x11_platform)]
-fn window_attributes_x11(
-    event_loop: &dyn ActiveEventLoop,
-) -> Result<WindowAttributesX11, Box<dyn Error>> {
-    let mut window_attributes = WindowAttributesX11::default();
-
-    #[cfg(any(x11_platform, wayland_platform))]
-    if let Some(token) = event_loop.read_token_from_env() {
-        startup_notify::reset_activation_token_env();
-        info!("Using token {:?} to activate a window", token);
-        window_attributes = window_attributes.with_activation_token(token);
-    }
-
-    match std::env::var("X11_VISUAL_ID") {
-        Ok(visual_id_str) => {
-            info!("Using X11 visual id {visual_id_str}");
-            let visual_id = visual_id_str.parse()?;
-            window_attributes = window_attributes.with_x11_visual(visual_id);
-        },
-        Err(_) => info!("Set the X11_VISUAL_ID env variable to request specific X11 visual"),
-    }
-
-    match std::env::var("X11_SCREEN_ID") {
-        Ok(screen_id_str) => {
-            info!("Placing the window on X11 screen {screen_id_str}");
-            let screen_id = screen_id_str.parse()?;
-            window_attributes = window_attributes.with_x11_screen(screen_id);
-        },
-        Err(_) => {
-            info!("Set the X11_SCREEN_ID env variable to place the window on non-default screen")
-        },
-    }
-
-    Ok(window_attributes)
 }

 /// Cursor list to cycle through.
@@ -1237,16 +1192,15 @@ const CURSORS: &[CursorIcon] = &[
 const KEY_BINDINGS: &[Binding<&'static str>] = &[
    Binding::new("Q", ModifiersState::CONTROL, Action::CloseWindow),
    Binding::new("H", ModifiersState::CONTROL, Action::PrintHelp),
-    Binding::new("F", ModifiersState::SHIFT, Action::ToggleAnimatedFillColor),
    Binding::new("F", ModifiersState::CONTROL, Action::ToggleFullscreen),
    #[cfg(macos_platform)]
    Binding::new("F", ModifiersState::ALT, Action::ToggleSimpleFullscreen),
    Binding::new("D", ModifiersState::CONTROL, Action::ToggleDecorations),
+    Binding::new("I", ModifiersState::CONTROL, Action::ToggleImeInput),
    Binding::new("L", ModifiersState::CONTROL, Action::CycleCursorGrab),
    Binding::new("P", ModifiersState::CONTROL, Action::ToggleResizeIncrements),
    Binding::new("R", ModifiersState::CONTROL, Action::ToggleResizable),
    Binding::new("R", ModifiersState::ALT, Action::RequestResize),
-    Binding::new("R", ModifiersState::SHIFT, Action::ToggleContinuousRedraw),
    // M.
    Binding::new("M", ModifiersState::CONTROL.union(ModifiersState::ALT), Action::DumpMonitors),
    Binding::new("M", ModifiersState::CONTROL, Action::ToggleMaximize),
@@ -1271,15 +1225,12 @@ const KEY_BINDINGS: &[Binding<&'static str>] = &[
    Binding::new("Z", ModifiersState::CONTROL, Action::ToggleCursorVisibility),
    // K.
    Binding::new("K", ModifiersState::empty(), Action::SetTheme(None)),
-    Binding::new("K", ModifiersState::META, Action::SetTheme(Some(Theme::Light))),
+    Binding::new("K", ModifiersState::SUPER, Action::SetTheme(Some(Theme::Light))),
    Binding::new("K", ModifiersState::CONTROL, Action::SetTheme(Some(Theme::Dark))),
    #[cfg(macos_platform)]
-    Binding::new("T", ModifiersState::META, Action::CreateNewTab),
+    Binding::new("T", ModifiersState::SUPER, Action::CreateNewTab),
    #[cfg(macos_platform)]
    Binding::new("O", ModifiersState::CONTROL, Action::CycleOptionAsAlt),
-    #[cfg(macos_platform)]
-    Binding::new("B", ModifiersState::CONTROL, Action::ToggleBorderlessGame),
-    Binding::new("S", ModifiersState::ALT, Action::EmitSurfaceSize),
    Binding::new("S", ModifiersState::CONTROL, Action::Message),
 ];

--- a/winit/examples/child_window.rs
+++ b/winit/examples/child_window.rs
@@ -3,34 +3,29 @@
 fn main() -> Result<(), impl std::error::Error> {
    use std::collections::HashMap;

-    use softbuffer::{Context, Surface};
-    use tracing::info;
    use winit::application::ApplicationHandler;
    use winit::dpi::{LogicalPosition, LogicalSize, Position};
    use winit::event::{ElementState, KeyEvent, WindowEvent};
-    use winit::event_loop::{ActiveEventLoop, EventLoop, OwnedDisplayHandle};
+    use winit::event_loop::{ActiveEventLoop, EventLoop};
    use winit::raw_window_handle::HasRawWindowHandle;
    use winit::window::{Window, WindowAttributes, WindowId};

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

-    #[derive(Debug)]
    struct WindowData {
-        surface: Surface<OwnedDisplayHandle, Box<dyn Window>>,
+        window: Box<dyn Window>,
        color: u32,
    }

    impl WindowData {
-        fn new(context: &Context<OwnedDisplayHandle>, window: Box<dyn Window>, color: u32) -> Self {
-            let surface = Surface::new(context, window).unwrap();
-            Self { surface, color }
+        fn new(window: Box<dyn Window>, color: u32) -> Self {
+            Self { window, color }
        }
    }

-    #[derive(Debug)]
+    #[derive(Default)]
    struct Application {
-        context: Context<OwnedDisplayHandle>,
        parent_window_id: Option<WindowId>,
        windows: HashMap<WindowId, WindowData>,
    }
@@ -42,10 +37,10 @@ fn main() -> Result<(), impl std::error::Error> {
                .with_position(Position::Logical(LogicalPosition::new(0.0, 0.0)))
                .with_surface_size(LogicalSize::new(640.0f32, 480.0f32));
            let window = event_loop.create_window(attributes).unwrap();
-            info!("Parent window id: {:?})", window.id());
+            println!("Parent window id: {:?})", window.id());
            self.parent_window_id = Some(window.id());

-            self.windows.insert(window.id(), WindowData::new(&self.context, window, 0xffbbbbbb));
+            self.windows.insert(window.id(), WindowData::new(window, 0xffbbbbbb));
        }

        fn window_event(
@@ -60,12 +55,12 @@ fn main() -> Result<(), impl std::error::Error> {
                    event_loop.exit();
                },
                WindowEvent::PointerEntered { device_id: _, .. } => {
-                    // On x11, log when the cursor entered in a window even if the child window
+                    // On x11, println when the cursor entered in a window even if the child window
                    // is created by some key inputs.
                    // the child windows are always placed at (0, 0) with size (200, 200) in the
                    // parent window, so we also can see this log when we move
                    // the cursor around (200, 200) in parent window.
-                    info!("cursor entered in the window {window_id:?}");
+                    println!("cursor entered in the window {window_id:?}");
                },
                WindowEvent::KeyboardInput {
                    event: KeyEvent { state: ElementState::Pressed, .. },
@@ -76,24 +71,18 @@ fn main() -> Result<(), impl std::error::Error> {
                        0xff000000 + 3_u32.pow((child_index + 2).rem_euclid(16) as u32);

                    let parent_window = self.windows.get(&self.parent_window_id.unwrap()).unwrap();
-                    let child_window = spawn_child_window(
-                        parent_window.surface.window().as_ref(),
-                        event_loop,
-                        child_index,
-                    );
+                    let child_window =
+                        spawn_child_window(parent_window.window.as_ref(), event_loop, child_index);
                    let child_id = child_window.id();
-                    info!("Child window created with id: {child_id:?}");
-                    self.windows.insert(
-                        child_id,
-                        WindowData::new(&self.context, child_window, child_color),
-                    );
+                    println!("Child window created with id: {child_id:?}");
+                    self.windows.insert(child_id, WindowData::new(child_window, child_color));
                },
                WindowEvent::RedrawRequested => {
-                    if let Some(window) = self.windows.get_mut(&window_id) {
+                    if let Some(window) = self.windows.get(&window_id) {
                        if window_id == self.parent_window_id.unwrap() {
-                            fill::fill(&mut window.surface);
+                            fill::fill_window(window.window.as_ref());
                        } else {
-                            fill::fill_with_color(&mut window.surface, window.color);
+                            fill::fill_window_with_color(window.window.as_ref(), window.color);
                        }
                    }
                },
@@ -127,8 +116,7 @@ fn main() -> Result<(), impl std::error::Error> {
    }

    let event_loop = EventLoop::new().unwrap();
-    let context = Context::new(event_loop.owned_display_handle()).unwrap();
-    event_loop.run_app(Application { context, parent_window_id: None, windows: HashMap::new() })
+    event_loop.run_app(Application::default())
 }

 #[cfg(not(any(x11_platform, macos_platform, windows_platform)))]
--- a/winit/examples/control_flow.rs
+++ b/winit/examples/control_flow.rs
@@ -4,13 +4,12 @@ use std::thread;
 #[cfg(not(web_platform))]
 use std::time;

-use softbuffer::{Context, Surface};
-use tracing::{info, warn};
+use ::tracing::{info, warn};
 #[cfg(web_platform)]
 use web_time as time;
 use winit::application::ApplicationHandler;
 use winit::event::{ElementState, KeyEvent, StartCause, WindowEvent};
-use winit::event_loop::{ActiveEventLoop, ControlFlow, EventLoop, OwnedDisplayHandle};
+use winit::event_loop::{ActiveEventLoop, ControlFlow, EventLoop};
 use winit::keyboard::{Key, NamedKey};
 use winit::window::{Window, WindowAttributes, WindowId};

@@ -47,13 +46,13 @@ fn main() -> Result<(), impl std::error::Error> {
    event_loop.run_app(ControlFlowDemo::default())
 }

-#[derive(Default, Debug)]
+#[derive(Default)]
 struct ControlFlowDemo {
    mode: Mode,
    request_redraw: bool,
    wait_cancelled: bool,
    close_requested: bool,
-    surface: Option<Surface<OwnedDisplayHandle, Box<dyn Window>>>,
+    window: Option<Box<dyn Window>>,
 }

 impl ApplicationHandler for ControlFlowDemo {
@@ -70,10 +69,7 @@ impl ApplicationHandler for ControlFlowDemo {
        let window_attributes = WindowAttributes::default().with_title(
            "Press 1, 2, 3 to change control flow mode. Press R to toggle redraw requests.",
        );
-        let window = event_loop.create_window(window_attributes).unwrap();
-        let context = Context::new(event_loop.owned_display_handle()).unwrap();
-        let surface = Surface::new(&context, window).unwrap();
-        self.surface = Some(surface);
+        self.window = Some(event_loop.create_window(window_attributes).unwrap());
    }

    fn window_event(
@@ -116,9 +112,9 @@ impl ApplicationHandler for ControlFlowDemo {
                _ => (),
            },
            WindowEvent::RedrawRequested => {
-                let surface = self.surface.as_mut().unwrap();
-                surface.window().pre_present_notify();
-                fill::fill(surface);
+                let window = self.window.as_ref().unwrap();
+                window.pre_present_notify();
+                fill::fill_window(window.as_ref());
            },
            _ => (),
        }
@@ -126,7 +122,7 @@ impl ApplicationHandler for ControlFlowDemo {

    fn about_to_wait(&mut self, event_loop: &dyn ActiveEventLoop) {
        if self.request_redraw && !self.wait_cancelled && !self.close_requested {
-            self.surface.as_ref().unwrap().window().request_redraw();
+            self.window.as_ref().unwrap().request_redraw();
        }

        match self.mode {
--- a/winit/examples/data/cross.png
+++ b/winit/examples/data/cross.png
--- a/winit/examples/data/cross2.png
+++ b/winit/examples/data/cross2.png
--- a/winit/examples/data/gradient.png
+++ b/winit/examples/data/gradient.png
--- a/winit/examples/data/icon.png
+++ b/winit/examples/data/icon.png
--- a/winit/examples/dnd.rs
+++ b/winit/examples/dnd.rs
@@ -1,10 +1,8 @@
 use std::error::Error;

-use softbuffer::{Context, Surface};
-use tracing::info;
 use winit::application::ApplicationHandler;
 use winit::event::WindowEvent;
-use winit::event_loop::{ActiveEventLoop, EventLoop, OwnedDisplayHandle};
+use winit::event_loop::{ActiveEventLoop, EventLoop};
 use winit::window::{Window, WindowAttributes, WindowId};

 #[path = "util/fill.rs"]
@@ -17,24 +15,26 @@ fn main() -> Result<(), Box<dyn Error>> {

    let event_loop = EventLoop::new()?;

-    let app = Application::default();
+    let app = Application::new();
    Ok(event_loop.run_app(app)?)
 }

 /// Application state and event handling.
-#[derive(Default, Debug)]
 struct Application {
-    surface: Option<Surface<OwnedDisplayHandle, Box<dyn Window>>>,
+    window: Option<Box<dyn Window>>,
+}
+
+impl Application {
+    fn new() -> Self {
+        Self { window: None }
+    }
 }

 impl ApplicationHandler for Application {
    fn can_create_surfaces(&mut self, event_loop: &dyn ActiveEventLoop) {
        let window_attributes =
            WindowAttributes::default().with_title("Drag and drop files on me!");
-        let window = event_loop.create_window(window_attributes).unwrap();
-        let context = Context::new(event_loop.owned_display_handle()).unwrap();
-        let surface = Surface::new(&context, window).unwrap();
-        self.surface = Some(surface);
+        self.window = Some(event_loop.create_window(window_attributes).unwrap());
    }

    fn window_event(
@@ -48,12 +48,12 @@ impl ApplicationHandler for Application {
            | WindowEvent::DragEntered { .. }
            | WindowEvent::DragMoved { .. }
            | WindowEvent::DragDropped { .. } => {
-                info!("{event:?}");
+                println!("{:?}", event);
            },
            WindowEvent::RedrawRequested => {
-                let surface = self.surface.as_mut().unwrap();
-                surface.window().pre_present_notify();
-                fill::fill(surface);
+                let window = self.window.as_ref().unwrap();
+                window.pre_present_notify();
+                fill::fill_window(window.as_ref());
            },
            WindowEvent::CloseRequested => {
                event_loop.exit();
--- a/winit/examples/pump_events.rs
+++ b/winit/examples/pump_events.rs
@@ -7,31 +7,24 @@ fn main() -> std::process::ExitCode {
    use std::thread::sleep;
    use std::time::Duration;

-    use softbuffer::{Context, Surface};
-    use tracing::info;
    use winit::application::ApplicationHandler;
    use winit::event::WindowEvent;
-    use winit::event_loop::pump_events::{EventLoopExtPumpEvents, PumpStatus};
-    use winit::event_loop::{ActiveEventLoop, EventLoop, OwnedDisplayHandle};
+    use winit::event_loop::{ActiveEventLoop, EventLoop};
+    use winit::platform::pump_events::{EventLoopExtPumpEvents, PumpStatus};
    use winit::window::{Window, WindowAttributes, WindowId};

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

-    #[derive(Default, Debug)]
+    #[derive(Default)]
    struct PumpDemo {
-        surface: Option<Surface<OwnedDisplayHandle, Box<dyn Window>>>,
+        window: Option<Box<dyn Window>>,
    }

    impl ApplicationHandler for PumpDemo {
        fn can_create_surfaces(&mut self, event_loop: &dyn ActiveEventLoop) {
            let window_attributes = WindowAttributes::default().with_title("A fantastic window!");
-            let window = event_loop.create_window(window_attributes).unwrap();
-
-            let context = Context::new(event_loop.owned_display_handle()).unwrap();
-            self.surface = Some(Surface::new(&context, window).unwrap());
+            self.window = Some(event_loop.create_window(window_attributes).unwrap());
        }

        fn window_event(
@@ -40,28 +33,28 @@ fn main() -> std::process::ExitCode {
            _window_id: WindowId,
            event: WindowEvent,
        ) {
-            info!("{event:?}");
+            println!("{event:?}");

-            let surface = match self.surface.as_mut() {
-                Some(surface) => surface,
+            let window = match self.window.as_ref() {
+                Some(window) => window,
                None => return,
            };

            match event {
                WindowEvent::CloseRequested => event_loop.exit(),
                WindowEvent::RedrawRequested => {
-                    fill::fill(surface);
-                    surface.window().request_redraw();
+                    fill::fill_window(window.as_ref());
+                    window.request_redraw();
                },
                _ => (),
            }
        }
    }

-    tracing::init();
-
    let mut event_loop = EventLoop::new().unwrap();

+    tracing_subscriber::fmt::init();
+
    let mut app = PumpDemo::default();

    loop {
@@ -76,12 +69,12 @@ fn main() -> std::process::ExitCode {
        //
        // Since `pump_events` doesn't block it will be important to
        // throttle the loop in the app somehow.
-        info!("Update()");
+        println!("Update()");
        sleep(Duration::from_millis(16));
    }
 }

 #[cfg(any(ios_platform, web_platform, orbital_platform))]
 fn main() {
-    panic!("This platform doesn't support pump_events.")
+    println!("This platform doesn't support pump_events.");
 }
--- a/winit/examples/run_on_demand.rs
+++ b/winit/examples/run_on_demand.rs
@@ -1,47 +1,40 @@
 #![allow(clippy::single_match)]

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

-    use softbuffer::{Context, Surface};
-    use tracing::info;
    use winit::application::ApplicationHandler;
    use winit::event::WindowEvent;
-    use winit::event_loop::run_on_demand::EventLoopExtRunOnDemand;
-    use winit::event_loop::{ActiveEventLoop, EventLoop, OwnedDisplayHandle};
+    use winit::event_loop::{ActiveEventLoop, EventLoop};
+    use winit::platform::run_on_demand::EventLoopExtRunOnDemand;
    use winit::window::{Window, WindowAttributes, WindowId};

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

-    #[derive(Debug)]
+    #[derive(Default)]
    struct App {
-        context: Context<OwnedDisplayHandle>,
        idx: usize,
-        surface: Option<Surface<OwnedDisplayHandle, Box<dyn Window>>>,
        window_id: Option<WindowId>,
+        window: Option<Box<dyn Window>>,
    }

    impl ApplicationHandler for App {
        fn about_to_wait(&mut self, _event_loop: &dyn ActiveEventLoop) {
-            if let Some(surface) = self.surface.as_ref() {
-                surface.window().request_redraw();
+            if let Some(window) = self.window.as_ref() {
+                window.request_redraw();
            }
        }

        fn can_create_surfaces(&mut self, event_loop: &dyn ActiveEventLoop) {
            let window_attributes = WindowAttributes::default()
-                .with_title(format!("Fantastic window number {}!", self.idx))
+                .with_title("Fantastic window number one!")
                .with_surface_size(winit::dpi::LogicalSize::new(128.0, 128.0));
            let window = event_loop.create_window(window_attributes).unwrap();
            self.window_id = Some(window.id());
-
-            let surface = Surface::new(&self.context, window).unwrap();
-            self.surface = Some(surface);
+            self.window = Some(window);
        }

        fn window_event(
@@ -51,54 +44,56 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
            event: WindowEvent,
        ) {
            if event == WindowEvent::Destroyed && self.window_id == Some(window_id) {
-                info!("Window {} Destroyed", self.idx);
+                println!(
+                    "--------------------------------------------------------- Window {} Destroyed",
+                    self.idx
+                );
                self.window_id = None;
                event_loop.exit();
                return;
            }

-            let Some(surface) = self.surface.as_mut() else {
-                return;
+            let window = match self.window.as_mut() {
+                Some(window) => window,
+                None => return,
            };

            match event {
                WindowEvent::CloseRequested => {
-                    info!("Window {} CloseRequested", self.idx);
-                    self.surface = None;
+                    println!(
+                        "--------------------------------------------------------- Window {} \
+                         CloseRequested",
+                        self.idx
+                    );
+                    fill::cleanup_window(window.as_ref());
+                    self.window = None;
                },
                WindowEvent::RedrawRequested => {
-                    fill::fill(surface);
+                    fill::fill_window(window.as_ref());
                },
                _ => (),
            }
        }
    }

-    tracing::init();
+    tracing_subscriber::fmt::init();

    let mut event_loop = EventLoop::new().unwrap();

-    let context = Context::new(event_loop.owned_display_handle()).unwrap();
-    let mut app = App { context, idx: 1, surface: None, window_id: None };
+    let mut app = App { idx: 1, ..Default::default() };
    event_loop.run_app_on_demand(&mut app)?;

-    info!("Finished first loop");
-    info!("Waiting 5 seconds");
+    println!("--------------------------------------------------------- Finished first loop");
+    println!("--------------------------------------------------------- Waiting 5 seconds");
    std::thread::sleep(Duration::from_secs(5));

    app.idx += 1;
    event_loop.run_app_on_demand(&mut app)?;
-    info!("Finished second loop");
+    println!("--------------------------------------------------------- Finished second loop");
    Ok(())
 }

-#[cfg(not(any(
-    windows_platform,
-    macos_platform,
-    x11_platform,
-    wayland_platform,
-    orbital_platform
-)))]
+#[cfg(not(any(windows_platform, macos_platform, x11_platform, wayland_platform,)))]
 fn main() {
-    panic!("This example is not supported on this platform")
+    println!("This example is not supported on this platform");
 }
--- a/examples/util/fill.rs
+++ b/examples/util/fill.rs
@@ -0,0 +1,131 @@
+//! Fill the window buffer with a solid color.
+//!
+//! Launching a window without drawing to it has unpredictable results varying from platform to
+//! platform. In order to have well-defined examples, this module provides an easy way to
+//! fill the window buffer with a solid color.
+//!
+//! The `softbuffer` crate is used, largely because of its ease of use. `glutin` or `wgpu` could
+//! also be used to fill the window buffer, but they are more complicated to use.
+
+#[allow(unused_imports)]
+pub use platform::cleanup_window;
+#[allow(unused_imports)]
+pub use platform::fill_window;
+#[allow(unused_imports)]
+pub use platform::fill_window_with_color;
+
+#[cfg(not(any(target_os = "android", target_os = "ios")))]
+mod platform {
+    use std::cell::RefCell;
+    use std::collections::HashMap;
+    use std::mem;
+    use std::mem::ManuallyDrop;
+    use std::num::NonZeroU32;
+
+    use softbuffer::{Context, Surface};
+    use winit::window::{Window, WindowId};
+
+    thread_local! {
+        // NOTE: You should never do things like that, create context and drop it before
+        // you drop the event loop. We do this for brevity to not blow up examples. We use
+        // ManuallyDrop to prevent destructors from running.
+        //
+        // A static, thread-local map of graphics contexts to open windows.
+        static GC: ManuallyDrop<RefCell<Option<GraphicsContext>>> = const { ManuallyDrop::new(RefCell::new(None)) };
+    }
+
+    /// The graphics context used to draw to a window.
+    struct GraphicsContext {
+        /// The global softbuffer context.
+        context: RefCell<Context<&'static dyn Window>>,
+
+        /// The hash map of window IDs to surfaces.
+        surfaces: HashMap<WindowId, Surface<&'static dyn Window, &'static dyn Window>>,
+    }
+
+    impl GraphicsContext {
+        fn new(w: &dyn Window) -> Self {
+            Self {
+                context: RefCell::new(
+                    Context::new(unsafe {
+                        mem::transmute::<&'_ dyn Window, &'static dyn Window>(w)
+                    })
+                    .expect("Failed to create a softbuffer context"),
+                ),
+                surfaces: HashMap::new(),
+            }
+        }
+
+        fn create_surface(
+            &mut self,
+            window: &dyn Window,
+        ) -> &mut Surface<&'static dyn Window, &'static dyn Window> {
+            self.surfaces.entry(window.id()).or_insert_with(|| {
+                Surface::new(&self.context.borrow(), unsafe {
+                    mem::transmute::<&'_ dyn Window, &'static dyn Window>(window)
+                })
+                .expect("Failed to create a softbuffer surface")
+            })
+        }
+
+        fn destroy_surface(&mut self, window: &dyn Window) {
+            self.surfaces.remove(&window.id());
+        }
+    }
+
+    pub fn fill_window_with_color(window: &dyn Window, color: u32) {
+        GC.with(|gc| {
+            let size = window.surface_size();
+            let (Some(width), Some(height)) =
+                (NonZeroU32::new(size.width), NonZeroU32::new(size.height))
+            else {
+                return;
+            };
+
+            // Either get the last context used or create a new one.
+            let mut gc = gc.borrow_mut();
+            let surface =
+                gc.get_or_insert_with(|| GraphicsContext::new(window)).create_surface(window);
+
+            // Fill a buffer with a solid color
+
+            surface.resize(width, height).expect("Failed to resize the softbuffer surface");
+
+            let mut buffer = surface.buffer_mut().expect("Failed to get the softbuffer buffer");
+            buffer.fill(color);
+            buffer.present().expect("Failed to present the softbuffer buffer");
+        })
+    }
+
+    #[allow(dead_code)]
+    pub fn fill_window(window: &dyn Window) {
+        fill_window_with_color(window, 0xff181818);
+    }
+
+    #[allow(dead_code)]
+    pub fn cleanup_window(window: &dyn Window) {
+        GC.with(|gc| {
+            let mut gc = gc.borrow_mut();
+            if let Some(context) = gc.as_mut() {
+                context.destroy_surface(window);
+            }
+        });
+    }
+}
+
+#[cfg(any(target_os = "android", target_os = "ios"))]
+mod platform {
+    pub fn fill_window(_window: &dyn winit::window::Window) {
+        // No-op on mobile platforms.
+    }
+
+    #[allow(dead_code)]
+    pub fn fill_window_with_color(_window: &dyn winit::window::Window, _color: u32) {
+        // No-op on mobile platforms.
+    }
+
+    #[allow(dead_code)]
+    pub fn cleanup_window(_window: &dyn winit::window::Window) {
+        // No-op on mobile platforms.
+    }
+}
--- a/winit/examples/util/tracing.rs
+++ b/winit/examples/util/tracing.rs
@@ -23,6 +23,3 @@ pub fn init() {
        )
        .init();
 }
-
-#[allow(unused_imports)]
-pub use ::tracing::*;
--- a/winit/examples/window.rs
+++ b/winit/examples/window.rs
@@ -2,23 +2,19 @@

 use std::error::Error;

-use softbuffer::{Context, Surface};
-use tracing::info;
 use winit::application::ApplicationHandler;
 use winit::event::WindowEvent;
-use winit::event_loop::{ActiveEventLoop, EventLoop, OwnedDisplayHandle};
+use winit::event_loop::{ActiveEventLoop, EventLoop};
 #[cfg(web_platform)]
-use winit::platform::web::WindowAttributesWeb;
+use winit::platform::web::WindowAttributesExtWeb;
 use winit::window::{Window, WindowAttributes, WindowId};

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

-#[derive(Default, Debug)]
+#[derive(Default)]
 struct App {
-    surface: Option<Surface<OwnedDisplayHandle, Box<dyn Window>>>,
+    window: Option<Box<dyn Window>>,
 }

 impl ApplicationHandler for App {
@@ -26,27 +22,26 @@ impl ApplicationHandler for App {
        #[cfg(not(web_platform))]
        let window_attributes = WindowAttributes::default();
        #[cfg(web_platform)]
-        let window_attributes = WindowAttributes::default()
-            .with_platform_attributes(Box::new(WindowAttributesWeb::default().with_append(true)));
-        let window = event_loop.create_window(window_attributes).expect("failed creating window");
-
-        let context =
-            Context::new(event_loop.owned_display_handle()).expect("failed creating context");
-        let surface = Surface::new(&context, window).expect("failed creating surface");
-        self.surface = Some(surface);
+        let window_attributes = WindowAttributes::default().with_append(true);
+        self.window = match event_loop.create_window(window_attributes) {
+            Ok(window) => Some(window),
+            Err(err) => {
+                eprintln!("error creating window: {err}");
+                event_loop.exit();
+                return;
+            },
+        }
    }

    fn window_event(&mut self, event_loop: &dyn ActiveEventLoop, _: WindowId, event: WindowEvent) {
-        info!("{event:?}");
+        println!("{event:?}");
        match event {
            WindowEvent::CloseRequested => {
-                info!("Close was requested; stopping");
+                println!("Close was requested; stopping");
                event_loop.exit();
            },
-            WindowEvent::SurfaceResized(surface_size) => {
-                let surface = self.surface.as_mut().expect("resize event without a surface");
-                fill::resize(surface, surface_size);
-                surface.window().request_redraw();
+            WindowEvent::SurfaceResized(_) => {
+                self.window.as_ref().expect("resize event without a window").request_redraw();
            },
            WindowEvent::RedrawRequested => {
                // Redraw the application.
@@ -55,15 +50,13 @@ impl ApplicationHandler for App {
                // this event rather than in AboutToWait, since rendering in here allows
                // the program to gracefully handle redraws requested by the OS.

-                let surface = self.surface.as_mut().expect("redraw event without a surface");
+                let window = self.window.as_ref().expect("redraw request without a window");

                // Notify that you're about to draw.
-                surface.window().pre_present_notify();
+                window.pre_present_notify();

                // Draw.
-                let mut buffer = surface.buffer_mut().expect("Failed to get the softbuffer buffer");
-                buffer.fill(0xff181818);
-                buffer.present().expect("Failed to present the softbuffer buffer");
+                fill::fill_window(window.as_ref());

                // For contiguous redraw loop you can request a redraw from here.
                // window.request_redraw();
@@ -77,12 +70,9 @@ fn main() -> Result<(), Box<dyn Error>> {
    #[cfg(web_platform)]
    console_error_panic_hook::set_once();

-    tracing::init();
-
    let event_loop = EventLoop::new()?;
+    let mut app = App::default();

    // For alternative loop run options see `pump_events` and `run_on_demand` examples.
-    event_loop.run_app(App::default())?;
-
-    Ok(())
+    event_loop.run_app(&mut app).map_err(Into::into)
 }
--- a/winit/examples/x11_embed.rs
+++ b/winit/examples/x11_embed.rs
@@ -3,37 +3,28 @@ use std::error::Error;

 #[cfg(x11_platform)]
 fn main() -> Result<(), Box<dyn Error>> {
-    use softbuffer::{Context, Surface};
    use winit::application::ApplicationHandler;
    use winit::event::WindowEvent;
-    use winit::event_loop::{ActiveEventLoop, EventLoop, OwnedDisplayHandle};
-    use winit::platform::x11::WindowAttributesX11;
+    use winit::event_loop::{ActiveEventLoop, EventLoop};
+    use winit::platform::x11::WindowAttributesExtX11;
    use winit::window::{Window, WindowAttributes, WindowId};

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

-    #[derive(Debug)]
    pub struct XEmbedDemo {
        parent_window_id: u32,
-        surface: Option<Surface<OwnedDisplayHandle, Box<dyn Window>>>,
+        window: Option<Box<dyn Window>>,
    }

    impl ApplicationHandler for XEmbedDemo {
        fn can_create_surfaces(&mut self, event_loop: &dyn ActiveEventLoop) {
-            let mut window_attributes = WindowAttributes::default()
+            let window_attributes = WindowAttributes::default()
                .with_title("An embedded window!")
-                .with_surface_size(winit::dpi::LogicalSize::new(128.0, 128.0));
-            let x11_attrs =
-                WindowAttributesX11::default().with_embed_parent_window(self.parent_window_id);
-            window_attributes = window_attributes.with_platform_attributes(Box::new(x11_attrs));
+                .with_surface_size(winit::dpi::LogicalSize::new(128.0, 128.0))
+                .with_embed_parent_window(self.parent_window_id);

-            let window = event_loop.create_window(window_attributes).unwrap();
-            let context = Context::new(event_loop.owned_display_handle()).unwrap();
-            let surface = Surface::new(&context, window).unwrap();
-            self.surface = Some(surface);
+            self.window = Some(event_loop.create_window(window_attributes).unwrap());
        }

        fn window_event(
@@ -42,19 +33,19 @@ fn main() -> Result<(), Box<dyn Error>> {
            _window_id: WindowId,
            event: WindowEvent,
        ) {
+            let window = self.window.as_ref().unwrap();
            match event {
                WindowEvent::CloseRequested => event_loop.exit(),
                WindowEvent::RedrawRequested => {
-                    let surface = self.surface.as_mut().unwrap();
-                    surface.window().pre_present_notify();
-                    fill::fill(surface);
+                    window.pre_present_notify();
+                    fill::fill_window(window.as_ref());
                },
                _ => (),
            }
        }

        fn about_to_wait(&mut self, _event_loop: &dyn ActiveEventLoop) {
-            self.surface.as_ref().unwrap().window().request_redraw();
+            self.window.as_ref().unwrap().request_redraw();
        }
    }

@@ -64,13 +55,14 @@ fn main() -> Result<(), Box<dyn Error>> {
        .ok_or("Expected a 32-bit X11 window ID as the first argument.")?
        .parse::<u32>()?;

-    tracing::init();
+    tracing_subscriber::fmt::init();
    let event_loop = EventLoop::new()?;

-    Ok(event_loop.run_app(XEmbedDemo { parent_window_id, surface: None })?)
+    Ok(event_loop.run_app(XEmbedDemo { parent_window_id, window: None })?)
 }

 #[cfg(not(x11_platform))]
 fn main() -> Result<(), Box<dyn Error>> {
-    panic!("This example is only supported on X11 platforms.")
+    println!("This example is only supported on X11 platforms.");
+    Ok(())
 }
--- a/winit-core/src/application/mod.rs
+++ b/winit-core/src/application/mod.rs
@@ -2,11 +2,11 @@

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

-pub mod macos;
-
-/// The handler of application-level events.
+/// The handler of the application events.
 pub trait ApplicationHandler {
    /// Emitted when new events arrive from the OS to be processed.
    ///
@@ -57,6 +57,7 @@ pub trait ApplicationHandler {
    ///
    /// [`resumed()`]: Self::resumed()
    /// [`suspended()`]: Self::suspended()
+    /// [`exiting()`]: Self::exiting()
    fn resumed(&mut self, event_loop: &dyn ActiveEventLoop) {
        let _ = event_loop;
    }
@@ -125,9 +126,8 @@ pub trait ApplicationHandler {
    /// use std::thread;
    /// use std::time::Duration;
    ///
-    /// use winit::event_loop::EventLoop;
-    /// use winit_core::application::ApplicationHandler;
-    /// use winit_core::event_loop::ActiveEventLoop;
+    /// use winit::application::ApplicationHandler;
+    /// use winit::event_loop::{ActiveEventLoop, EventLoop};
    ///
    /// struct MyApp {
    ///     receiver: mpsc::Receiver<u64>,
@@ -162,6 +162,8 @@ pub trait ApplicationHandler {
    ///
    ///     let (sender, receiver) = mpsc::channel();
    ///
+    ///     let mut app = MyApp { receiver };
+    ///
    ///     // Send an event in a loop
    ///     let proxy = event_loop.create_proxy();
    ///     let background_thread = thread::spawn(move || {
@@ -169,7 +171,7 @@ pub trait ApplicationHandler {
    ///         loop {
    ///             println!("sending: {i}");
    ///             if sender.send(i).is_err() {
-    ///                 // Stop sending once the receiver is dropped
+    ///                 // Stop sending once `MyApp` is dropped
    ///                 break;
    ///             }
    ///             // Trigger the wake-up _after_ we placed the event in the channel.
@@ -180,8 +182,9 @@ pub trait ApplicationHandler {
    ///         }
    ///     });
    ///
-    ///     event_loop.run_app(MyApp { receiver })?;
+    ///     event_loop.run_app(&mut app)?;
    ///
+    ///     drop(app);
    ///     background_thread.join().unwrap();
    ///
    ///     Ok(())
@@ -200,8 +203,6 @@ pub trait ApplicationHandler {
    );

    /// Emitted when the OS sends an event to a device.
-    ///
-    /// Whether device events are delivered depends on the backend in use.
    fn device_event(
        &mut self,
        event_loop: &dyn ActiveEventLoop,
@@ -257,7 +258,7 @@ pub trait ApplicationHandler {
    /// to the user. This is a good place to stop refreshing UI, running animations and other visual
    /// things. It is driven by Android's [`onStop()`] method.
    ///
-    /// After this event the application either receives [`resumed()`] again, or will exit.
+    /// After this event the application either receives [`resumed()`] again, or [`exiting()`].
    ///
    /// [`onStop()`]: https://developer.android.com/reference/android/app/Activity#onStop()
    ///
@@ -267,6 +268,7 @@ pub trait ApplicationHandler {
    ///
    /// [`resumed()`]: Self::resumed()
    /// [`suspended()`]: Self::suspended()
+    /// [`exiting()`]: Self::exiting()
    fn suspended(&mut self, event_loop: &dyn ActiveEventLoop) {
        let _ = event_loop;
    }
@@ -308,6 +310,14 @@ pub trait ApplicationHandler {
        let _ = event_loop;
    }

+    /// Emitted when the event loop is being shut down.
+    ///
+    /// This is irreversible - if this method is called, it is guaranteed that the event loop
+    /// will exit right after.
+    fn exiting(&mut self, event_loop: &dyn ActiveEventLoop) {
+        let _ = event_loop;
+    }
+
    /// Emitted when the application has received a memory warning.
    ///
    /// ## Platform-specific
@@ -339,8 +349,9 @@ pub trait ApplicationHandler {
    /// The macOS-specific handler.
    ///
    /// The return value from this should not change at runtime.
+    #[cfg(any(docsrs, macos_platform))]
    #[inline(always)]
-    fn macos_handler(&mut self) -> Option<&mut dyn macos::ApplicationHandlerExtMacOS> {
+    fn macos_handler(&mut self) -> Option<&mut dyn ApplicationHandlerExtMacOS> {
        None
    }
 }
@@ -402,13 +413,19 @@ impl<A: ?Sized + ApplicationHandler> ApplicationHandler for &mut A {
        (**self).destroy_surfaces(event_loop);
    }

+    #[inline]
+    fn exiting(&mut self, event_loop: &dyn ActiveEventLoop) {
+        (**self).exiting(event_loop);
+    }
+
    #[inline]
    fn memory_warning(&mut self, event_loop: &dyn ActiveEventLoop) {
        (**self).memory_warning(event_loop);
    }

+    #[cfg(any(docsrs, macos_platform))]
    #[inline]
-    fn macos_handler(&mut self) -> Option<&mut dyn macos::ApplicationHandlerExtMacOS> {
+    fn macos_handler(&mut self) -> Option<&mut dyn ApplicationHandlerExtMacOS> {
        (**self).macos_handler()
    }
 }
@@ -470,13 +487,19 @@ impl<A: ?Sized + ApplicationHandler> ApplicationHandler for Box<A> {
        (**self).destroy_surfaces(event_loop);
    }

+    #[inline]
+    fn exiting(&mut self, event_loop: &dyn ActiveEventLoop) {
+        (**self).exiting(event_loop);
+    }
+
    #[inline]
    fn memory_warning(&mut self, event_loop: &dyn ActiveEventLoop) {
        (**self).memory_warning(event_loop);
    }

+    #[cfg(any(docsrs, macos_platform))]
    #[inline]
-    fn macos_handler(&mut self) -> Option<&mut dyn macos::ApplicationHandlerExtMacOS> {
+    fn macos_handler(&mut self) -> Option<&mut dyn ApplicationHandlerExtMacOS> {
        (**self).macos_handler()
    }
 }
--- a/winit/src/changelog/mod.rs
+++ b/winit/src/changelog/mod.rs
--- a/winit/src/changelog/v0.31.md
+++ b/winit/src/changelog/v0.31.md
@@ -1,21 +1,44 @@
-## 0.31.0-beta.2
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).

+The sections should follow the order `Added`, `Changed`, `Deprecated`,
+`Removed`, and `Fixed`.
+
+Platform specific changed should be added to the end of the section and grouped
+by platform name. Common API additions should have `, implemented` at the end
+for platforms where the API was initially implemented. See the following example
+on how to add them:
+
+```md
 ### Added

- Add `EventLoopExtRegister::register_app` for being explicit about how the event loop runs on Web.
- Add `EventLoopExtNeverReturn::run_app_never_return` for being explicit about how the event loop runs on iOS.
+- Add `Window::turbo()`, implemented on X11, Wayland, and Web.
+- On X11, add `Window::some_rare_api`.
+- On X11, add `Window::even_more_rare_api`.
+- On Wayland, add `Window::common_api`.
+- On Windows, add `Window::some_rare_api`.
+```

-### Changed
+When the change requires non-trivial amount of work for users to comply
+with it, the migration guide should be added below the entry, like:

- On Web, avoid throwing an exception in `EventLoop::run_app`, instead preferring to return to the caller.
-  This requires passing a `'static` application to ensure that the application state will live as long as necessary.
- On Web, the event loop can now always be re-created once it has finished running.
+```md
+- Deprecate `Window` creation outside of `EventLoop::run`

-### Fixed
+  This was done to simply migration in the future. Consider the
+  following code:

- Fixed panic when calling `Window::set_ime_allowed`.
+  // Code snippet.

-## 0.31.0-beta.1
+  To migrate it we should do X, Y, and then Z, for example:
+
+  // Code snippet.
+
+```
+
+The migration guide could reference other migration examples in the current
+changelog entry.
+
+## Unreleased

 ### Added

@@ -38,7 +61,7 @@
 - Add `MonitorHandle::current_video_mode()`.
 - Add `ApplicationHandlerExtMacOS` trait, and a `macos_handler` method to `ApplicationHandler` which returns a `dyn ApplicationHandlerExtMacOS` which allows for macOS specific extensions to winit.
 - Add a `standard_key_binding` method to the `ApplicationHandlerExtMacOS` trait. This allows handling of standard keybindings such as "go to end of line" on macOS.
- On macOS, add `WindowExtMacOS::set_unified_titlebar` and `WindowAttributesMacOS::with_unified_titlebar`
+- On macOS, add `WindowExtMacOS::set_unified_titlebar` and `WindowAttributesExtMacOS::with_unified_titlebar`
  to use a larger style of titlebar.
 - Add `WindowId::into_raw()` and `from_raw()`.
 - Add `PointerKind`, `PointerSource`, `ButtonSource`, `FingerId`, `primary` and `position` to all
@@ -48,32 +71,16 @@
 - Added `Window::safe_area`, which describes the area of the surface that is unobstructed.
 - On X11, Wayland, Windows and macOS, improved scancode conversions for more obscure key codes.
 - Add ability to make non-activating window on macOS using `NSPanel` with `NSWindowStyleMask::NonactivatingPanel`.
- Implement `MonitorHandleProvider` for `MonitorHandle` to access common monitor API.
- On X11, set an "area" attribute on XIM input connection to convey the cursor area.
- Implement `CustomCursorProvider` for `CustomCursor` to access cursor API.
- Add `CustomCursorSource::Url`, `CustomCursorSource::from_animation`.
- Implement `CustomIconProvider` for `RgbaIcon`.
- Add `icon` module that exposes winit's icon API.
- `VideoMode::new` to create a `VideoMode`.
- `keyboard::ModifiersKey` to track which modifier is exactly pressed.
- `ActivationToken::as_raw` to get a ref to raw token.
- Each platform now has corresponding `WindowAttributes` struct instead of trait extension.
- On Wayland, added implementation for `Window::set_window_icon`
- On Wayland, added `PanGesture`, `PinchGesture`, and `RotationGesture`
- Add `Window::request_ime_update` to atomically apply set of IME changes.
- Add `Ime::DeleteSurrounding` to let the input method delete text.
- Add more `ImePurpose` values.
- Add `ImeHints` to request particular IME behaviour.
- Add Pen input support on Wayland, Windows, and Web via new Pointer event.
+- On Windows, add `IconExtWindows::from_resource_name`.

 ### Changed

- Change `ActiveEventLoop` and `Window` to be traits, and added `cast_ref`/`cast_mut`/`cast`
-  methods to extract the backend type from those.
+- Change `ActiveEventLoop` to be a trait.
+- Change `Window` to be a trait.
 - `ActiveEventLoop::create_window` now returns `Box<dyn Window>`.
 - `ApplicationHandler` now uses `dyn ActiveEventLoop`.
 - On Web, let events wake up event loop immediately when using `ControlFlow::Poll`.
- Bump MSRV from `1.70` to `1.85`.
+- Bump MSRV from `1.70` to `1.73`.
 - Changed `ApplicationHandler::user_event` to `user_wake_up`, removing the
  generic user event.

@@ -102,8 +109,10 @@
 - Changed how `ModifiersState` is serialized by Serde.
 - `VideoModeHandle::refresh_rate_millihertz()` and `bit_depth()` now return a `Option<NonZero*>`.
 - `MonitorHandle::position()` now returns an `Option`.
- On macOS, remove custom application delegates. You are now allowed to override the
+- On iOS and macOS, remove custom application delegates. You are now allowed to override the
  application delegate yourself.
+- On iOS, no longer act as-if the application successfully open all URLs. Override
+  `application:didFinishLaunchingWithOptions:` and provide the desired behaviour yourself.
 - On X11, remove our dependency on libXcursor. (#3749)
 - Renamed the following APIs to make it clearer that the sizes apply to the underlying surface:
  - `WindowEvent::Resized` to `SurfaceResized`.
@@ -155,7 +164,6 @@
 - Rename `VideoModeHandle` to `VideoMode`, now it only stores plain data.
 - Make `Fullscreen::Exclusive` contain `(MonitorHandle, VideoMode)`.
 - Reworked the file drag-and-drop API.
- On macOS, the default menu uses the bundle name or falls back to the process name as before.

  The `WindowEvent::DroppedFile`, `WindowEvent::HoveredFile` and `WindowEvent::HoveredFileCancelled`
  events have been removed, and replaced with `WindowEvent::DragEntered`, `WindowEvent::DragMoved`,
@@ -178,18 +186,9 @@
 - Updated `windows-sys` to `v0.59`.
  - To match the corresponding changes in `windows-sys`, the `HWND`, `HMONITOR`, and `HMENU` types
    now alias to `*mut c_void` instead of `isize`.
+- On macOS, no longer need control of the main `NSApplication` class (which means you can now override it yourself).
 - Removed `KeyEventExtModifierSupplement`, and made the fields `text_with_all_modifiers` and
  `key_without_modifiers` public on `KeyEvent` instead.
- Move `window::Fullscreen` to `monitor::Fullscreen`.
- Renamed "super" key to "meta", to match the naming in the W3C specification.
-  `NamedKey::Super` still exists, but it's non-functional and deprecated, `NamedKey::Meta` should be used instead.
- Move `IconExtWindows` into `WinIcon`.
- Move `EventLoopExtPumpEvents` and `PumpStatus` from platform module to `winit::event_loop::pump_events`.
- Move `EventLoopExtRunOnDemand` from platform module to `winit::event_loop::run_on_demand`.
- Use `NamedKey`, `Code` and `Location` from the `keyboard-types` v0.8 crate.
- Deprecate `Window::set_ime_allowed`, `Window::set_ime_cursor_area`, and `Window::set_ime_purpose`.
- `Force::normalized()` now takes a `Option<ToolAngle>` to calculate the perpendicular force.
- On Windows, don't confine cursor to center of window when grabbed and hidden.

 ### Removed

@@ -221,31 +220,13 @@
 - Remove `WindowEvent::Touch` and `Touch` in favor of the new `PointerKind`, `PointerSource` and
 `ButtonSource` as part of the new pointer event overhaul.
 - Remove `Force::altitude_angle`.
- Remove `Window::inner_position`, use the new `Window::surface_position` instead.
- Remove `CustomCursorExtWeb`, use the `CustomCursorSource`.
- Remove `CustomCursor::from_rgba`, use `CustomCursorSource` instead.
- Remove `ApplicationHandler::exited`, the event loop being shut down can now be listened to in
-  the `Drop` impl on the application handler.
- Remove `NamedKey::Space`, match on `Key::Character(" ")` instead.
- Remove `PartialEq` impl for `WindowAttributes`.
- `WindowAttributesExt*` platform extensions; use `WindowAttributes*` instead.
- Remove `Force::Calibrated::altitude_angle` in favor of `ToolAngle::altitude`.
+- Removed `Window::inner_position`, use the new `Window::surface_position` instead.

 ### Fixed

 - On Orbital, `MonitorHandle::name()` now returns `None` instead of a dummy name.
- On Orbital, implement `fullscreen`.
 - On iOS, fixed `SurfaceResized` and `Window::surface_size` not reporting the size of the actual surface.
 - On macOS, fixed the scancode conversion for audio volume keys.
 - On macOS, fixed the scancode conversion for `IntlBackslash`.
 - On macOS, fixed redundant `SurfaceResized` event at window creation.
- On macOS, don't panic on monitors with unknown bit-depths.
- On macOS, fixed crash when closing the window on macOS 26+.
- On Windows, account for mouse wheel lines per scroll setting for `WindowEvent::MouseWheel`.
- On Windows, `Window::theme` will return the correct theme after setting it through `Window::set_theme`.
- On Windows, `Window::set_theme` will change the title bar color immediately now.
- On Windows 11, prevent incorrect shifting when dragging window onto a monitor with different DPI.
- On Windows, avoid returning `SurfaceResized` with size zero when an application is minimized. Let `Window::surface_size` return the pre-minimization window size even while minimized.
- On Web, device events are emitted regardless of cursor type.
- On Wayland, `axis_value120` scroll events now generate `MouseScrollDelta::LineDelta`
- On X11, mouse scroll button events no longer cause duplicated `WindowEvent::MouseWheel` events.
+- On macOS, fixed the behaviour of `pump_app_events` to match what the system expects.
--- a/winit/src/changelog/v0.10.md
+++ b/winit/src/changelog/v0.10.md
--- a/winit/src/changelog/v0.11.md
+++ b/winit/src/changelog/v0.11.md
--- a/winit/src/changelog/v0.12.md
+++ b/winit/src/changelog/v0.12.md
--- a/winit/src/changelog/v0.13.md
+++ b/winit/src/changelog/v0.13.md
--- a/winit/src/changelog/v0.14.md
+++ b/winit/src/changelog/v0.14.md
--- a/winit/src/changelog/v0.15.md
+++ b/winit/src/changelog/v0.15.md
--- a/winit/src/changelog/v0.16.md
+++ b/winit/src/changelog/v0.16.md
--- a/winit/src/changelog/v0.17.md
+++ b/winit/src/changelog/v0.17.md
--- a/winit/src/changelog/v0.18.md
+++ b/winit/src/changelog/v0.18.md
--- a/winit/src/changelog/v0.19.md
+++ b/winit/src/changelog/v0.19.md
--- a/winit/src/changelog/v0.20.md
+++ b/winit/src/changelog/v0.20.md
--- a/winit/src/changelog/v0.21.md
+++ b/winit/src/changelog/v0.21.md
--- a/winit/src/changelog/v0.22.md
+++ b/winit/src/changelog/v0.22.md
--- a/winit/src/changelog/v0.23.md
+++ b/winit/src/changelog/v0.23.md
--- a/winit/src/changelog/v0.24.md
+++ b/winit/src/changelog/v0.24.md
--- a/winit/src/changelog/v0.25.md
+++ b/winit/src/changelog/v0.25.md
--- a/winit/src/changelog/v0.26.md
+++ b/winit/src/changelog/v0.26.md
--- a/winit/src/changelog/v0.27.md
+++ b/winit/src/changelog/v0.27.md
--- a/winit/src/changelog/v0.28.md
+++ b/winit/src/changelog/v0.28.md
--- a/winit/src/changelog/v0.29.md
+++ b/winit/src/changelog/v0.29.md
@@ -250,7 +250,7 @@
 - On Web, fix some `WindowBuilder` methods doing nothing.
 - On Web, fix some `Window` methods using incorrect HTML attributes instead of CSS properties.
 - On Web, fix the bfcache by not using the `beforeunload` event and map bfcache loading/unloading to `Suspended`/`Resumed` events.
- On Web, fix touch input not gaining or losing focus.
+- On Web, fix touch input not gaining or loosing focus.
 - On Web, fix touch location to be as accurate as mouse position.
 - On Web, handle coalesced pointer events, which increases the resolution of pointer inputs.
 - On Web, implement `Window::focus_window()`.
--- a/winit/src/changelog/v0.30.md
+++ b/winit/src/changelog/v0.30.md
@@ -1,61 +1,3 @@
-## 0.30.13
-
-### Added
-
- On Wayland, add `Window::set_resize_increments`.
-
-### Fixed
-
- On macOS, fixed crash when dragging non-file content onto window.
- On X11, fix `set_hittest` not working on some window managers.
- On X11, fix debug mode overflow panic in `set_timestamp`.
- On macOS, fix crash in `set_marked_text` when native Pinyin IME sends out-of-bounds `selected_range`.
- On Windows, fix `WM_IME_SETCONTEXT` IME UI flag masking on `lParam`.
- On Android, populate `KeyEvent::text` and `KeyEvent::text_with_all_modifiers` via `Key::to_text()`
-
-## 0.30.12
-
-### Fixed
-
- On macOS, fix crash on macOS 26 by using objc2's relax-sign-encoding feature.
-
-## 0.30.11
-
-### Fixed
-
- On Windows, fixed crash in should_apps_use_dark_mode() for Windows versions < 17763.
- On Wayland, fixed `pump_events` driven loop deadlocking when loop was not drained before exit.
-
-## 0.30.10
-
-### Added
-
- On Windows, add `IconExtWindows::from_resource_name`.
- On Windows, add `CursorGrabMode::Locked`.
- On Wayland, add `WindowExtWayland::xdg_toplevel`.
-
-### Changed
-
- On macOS, no longer need control of the main `NSApplication` class (which means you can now override it yourself).
- On iOS, remove custom application delegates. You are now allowed to override the
-  application delegate yourself.
- On iOS, no longer act as-if the application successfully open all URLs. Override
-  `application:didFinishLaunchingWithOptions:` and provide the desired behaviour yourself.
-
-### Fixed
-
- On Windows, fixed ~500 ms pause when clicking the title bar during continuous redraw.
- On macOS, `WindowExtMacOS::set_simple_fullscreen` now honors `WindowExtMacOS::set_borderless_game`
- On X11 and Wayland, fixed pump_events with `Some(Duration::Zero)` blocking with `Wait` polling mode
- On Wayland, fixed a crash when consequently calling `set_cursor_grab` without pointer focus.
- On Wayland, ensure that external event loop is woken-up when using pump_events and integrating via `FD`.
- On Wayland, apply fractional scaling to custom cursors.
- On macOS, fixed `run_app_on_demand` returning without closing open windows.
- On macOS, fixed `VideoMode::refresh_rate_millihertz` for fractional refresh rates.
- On macOS, store monitor handle to avoid panics after going in/out of sleep.
- On macOS, allow certain invalid monitor handles and return `None` instead of panicking.
- On Windows, fixed `Ime::Preedit` cursor offset calculation.
-
 ## 0.30.9

 ### Changed
--- a/winit/src/changelog/v0.8.md
+++ b/winit/src/changelog/v0.8.md
--- a/winit/src/changelog/v0.9.md
+++ b/winit/src/changelog/v0.9.md
--- a/winit-core/src/cursor.rs
+++ b/winit-core/src/cursor.rs
@@ -1,16 +1,13 @@
 use core::fmt;
 use std::error::Error;
-use std::hash::Hash;
-use std::ops::Deref;
+use std::hash::{Hash, Hasher};
 use std::sync::Arc;
-use std::time::Duration;

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

-use crate::as_any::AsAny;
+use crate::platform_impl::{PlatformCustomCursor, PlatformCustomCursorSource};

-/// The maximum width and height for a cursor when using [`CustomCursorSource::from_rgba`].
+/// The maximum width and height for a cursor when using [`CustomCursor::from_rgba`].
 pub const MAX_CURSOR_SIZE: u16 = 2048;

 const PIXEL_SIZE: usize = 4;
@@ -51,23 +48,22 @@ impl From<CustomCursor> for Cursor {
 /// # Example
 ///
 /// ```no_run
-/// # use winit_core::event_loop::ActiveEventLoop;
-/// # use winit_core::window::Window;
+/// # use winit::event_loop::ActiveEventLoop;
+/// # use winit::window::Window;
 /// # fn scope(event_loop: &dyn ActiveEventLoop, window: &dyn Window) {
-/// use winit_core::cursor::CustomCursorSource;
+/// use winit::window::CustomCursor;
 ///
 /// let w = 10;
 /// let h = 10;
 /// let rgba = vec![255; (w * h * 4) as usize];
 ///
 /// #[cfg(not(target_family = "wasm"))]
-/// let source = CustomCursorSource::from_rgba(rgba, w, h, w / 2, h / 2).unwrap();
+/// let source = CustomCursor::from_rgba(rgba, w, h, w / 2, h / 2).unwrap();
 ///
 /// #[cfg(target_family = "wasm")]
-/// let source = CustomCursorSource::Url {
-///     url: String::from("http://localhost:3000/cursor.png"),
-///     hotspot_x: 0,
-///     hotspot_y: 0,
+/// let source = {
+///     use winit::platform::web::CustomCursorExtWeb;
+///     CustomCursor::from_url(String::from("http://localhost:3000/cursor.png"), 0, 0)
 /// };
 ///
 /// if let Ok(custom_cursor) = event_loop.create_custom_cursor(source) {
@@ -75,96 +71,50 @@ impl From<CustomCursor> for Cursor {
 /// }
 /// # }
 /// ```
-#[derive(Clone, Debug)]
-pub struct CustomCursor(pub Arc<dyn CustomCursorProvider>);
-
-pub trait CustomCursorProvider: AsAny + fmt::Debug + Send + Sync {
-    /// Whether a cursor was backed by animation.
-    fn is_animated(&self) -> bool;
+#[derive(Clone, Debug, Eq, Hash, PartialEq)]
+pub struct CustomCursor {
+    /// Platforms should make sure this is cheap to clone.
+    pub(crate) inner: PlatformCustomCursor,
 }

-impl PartialEq for CustomCursor {
-    fn eq(&self, other: &Self) -> bool {
-        Arc::ptr_eq(&self.0, &other.0)
+impl CustomCursor {
+    /// Creates a new cursor from an rgba buffer.
+    ///
+    /// The alpha channel is assumed to be **not** premultiplied.
+    pub fn from_rgba(
+        rgba: impl Into<Vec<u8>>,
+        width: u16,
+        height: u16,
+        hotspot_x: u16,
+        hotspot_y: u16,
+    ) -> Result<CustomCursorSource, BadImage> {
+        let _span =
+            tracing::debug_span!("winit::Cursor::from_rgba", width, height, hotspot_x, hotspot_y)
+                .entered();
+
+        Ok(CustomCursorSource {
+            inner: PlatformCustomCursorSource::from_rgba(
+                rgba.into(),
+                width,
+                height,
+                hotspot_x,
+                hotspot_y,
+            )?,
+        })
    }
 }

-impl Eq for CustomCursor {}
-
-impl Hash for CustomCursor {
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        Arc::as_ptr(&self.0).hash(state);
-    }
-}
-
-impl Deref for CustomCursor {
-    type Target = dyn CustomCursorProvider;
-
-    fn deref(&self) -> &Self::Target {
-        self.0.deref()
-    }
-}
-
-impl_dyn_casting!(CustomCursorProvider);
-
 /// Source for [`CustomCursor`].
 ///
 /// See [`CustomCursor`] for more details.
 #[derive(Debug, Clone, Eq, Hash, PartialEq)]
-pub enum CustomCursorSource {
-    /// Cursor that is backed by RGBA image.
-    ///
-    /// See [CustomCursorSource::from_rgba] for more.
-    ///
-    /// ## Platform-specific
-    ///
-    /// - **iOS / Android / Orbital:** Unsupported
-    Image(CursorImage),
-    /// Animated cursor.
-    ///
-    /// See [CustomCursorSource::from_animation] for more.
-    ///
-    /// ## Platform-specific
-    ///
-    /// - **iOS / Android / Wayland / Windows / X11 / macOS / Orbital:** Unsupported
-    Animation(CursorAnimation),
-    /// Creates a new cursor from a URL pointing to an image.
-    /// It uses the [url css function](https://developer.mozilla.org/en-US/docs/Web/CSS/url),
-    /// but browser support for image formats is inconsistent. Using [PNG] is recommended.
-    ///
-    /// [PNG]: https://en.wikipedia.org/wiki/PNG
-    ///
-    /// ## Platform-specific
-    ///
-    /// - **iOS / Android / Wayland / Windows / X11 / macOS / Orbital:** Unsupported
-    Url { hotspot_x: u16, hotspot_y: u16, url: String },
+pub struct CustomCursorSource {
+    // Some platforms don't support custom cursors.
+    #[allow(dead_code)]
+    pub(crate) inner: PlatformCustomCursorSource,
 }

-impl CustomCursorSource {
-    /// Creates a new cursor from an rgba buffer.
-    ///
-    /// The alpha channel is assumed to be **not** premultiplied.
-    pub fn from_rgba(
-        rgba: Vec<u8>,
-        width: u16,
-        height: u16,
-        hotspot_x: u16,
-        hotspot_y: u16,
-    ) -> Result<Self, BadImage> {
-        CursorImage::from_rgba(rgba, width, height, hotspot_x, hotspot_y).map(Self::Image)
-    }
-
-    /// Crates a new animated cursor from multiple [`CustomCursor`]s
-    /// Supplied `cursors` can't be empty or other animations.
-    pub fn from_animation(
-        duration: Duration,
-        cursors: Vec<CustomCursor>,
-    ) -> Result<Self, BadAnimation> {
-        CursorAnimation::new(duration, cursors).map(Self::Animation)
-    }
-}
-
-/// An error produced when using [`CustomCursorSource::from_rgba`] with invalid arguments.
+/// An error produced when using [`CustomCursor::from_rgba`] with invalid arguments.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub enum BadImage {
@@ -214,29 +164,47 @@ impl fmt::Display for BadImage {

 impl Error for BadImage {}

-/// An error produced when using [`CustomCursorSource::from_animation`] with invalid arguments.
-#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-pub enum BadAnimation {
-    /// Produced when no cursors were supplied.
-    Empty,
-    /// Produced when a supplied cursor is an animation.
-    Animation,
-}
+/// Platforms export this directly as `PlatformCustomCursorSource` if they need to only work with
+/// images.
+#[allow(dead_code)]
+#[derive(Debug, Clone, Eq, Hash, PartialEq)]
+pub(crate) struct OnlyCursorImageSource(pub(crate) CursorImage);

-impl fmt::Display for BadAnimation {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::Empty => write!(f, "No cursors supplied"),
-            Self::Animation => write!(f, "A supplied cursor is an animation"),
-        }
+#[allow(dead_code)]
+impl OnlyCursorImageSource {
+    pub(crate) fn from_rgba(
+        rgba: Vec<u8>,
+        width: u16,
+        height: u16,
+        hotspot_x: u16,
+        hotspot_y: u16,
+    ) -> Result<Self, BadImage> {
+        CursorImage::from_rgba(rgba, width, height, hotspot_x, hotspot_y).map(Self)
    }
 }

-impl Error for BadAnimation {}
+/// Platforms export this directly as `PlatformCustomCursor` if they don't implement caching.
+#[allow(dead_code)]
+#[derive(Debug, Clone)]
+pub(crate) struct OnlyCursorImage(pub(crate) Arc<CursorImage>);
+
+impl Hash for OnlyCursorImage {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        Arc::as_ptr(&self.0).hash(state);
+    }
+}
+
+impl PartialEq for OnlyCursorImage {
+    fn eq(&self, other: &Self) -> bool {
+        Arc::ptr_eq(&self.0, &other.0)
+    }
+}
+
+impl Eq for OnlyCursorImage {}

 #[derive(Debug, Clone, Eq, Hash, PartialEq)]
-pub struct CursorImage {
+#[allow(dead_code)]
+pub(crate) struct CursorImage {
    pub(crate) rgba: Vec<u8>,
    pub(crate) width: u16,
    pub(crate) height: u16,
@@ -277,60 +245,22 @@ 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)]
-pub struct CursorAnimation {
-    pub(crate) duration: Duration,
-    pub(crate) cursors: Vec<CustomCursor>,
-}
+// Platforms that don't support cursors will export this as `PlatformCustomCursor`.
+#[derive(Debug, Clone, Hash, PartialEq, Eq)]
+pub(crate) struct NoCustomCursor;

-impl CursorAnimation {
-    pub fn new(duration: Duration, cursors: Vec<CustomCursor>) -> Result<Self, BadAnimation> {
-        if cursors.is_empty() {
-            return Err(BadAnimation::Empty);
-        }
-
-        if cursors.iter().any(|cursor| cursor.is_animated()) {
-            return Err(BadAnimation::Animation);
-        }
-
-        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)
+#[allow(dead_code)]
+impl NoCustomCursor {
+    pub(crate) fn from_rgba(
+        rgba: Vec<u8>,
+        width: u16,
+        height: u16,
+        hotspot_x: u16,
+        hotspot_y: u16,
+    ) -> Result<Self, BadImage> {
+        CursorImage::from_rgba(rgba, width, height, hotspot_x, hotspot_y)?;
+        Ok(Self)
    }
 }
--- a/winit-core/src/error.rs
+++ b/winit-core/src/error.rs
@@ -19,13 +19,7 @@ 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, only a single instance of it is supported (for \
-                     cross-platform compatibility)"
-                )
-            },
+            Self::RecreationAttempt => write!(f, "EventLoop can't be recreated"),
            Self::Os(err) => err.fmt(f),
            Self::ExitFailure(status) => write!(f, "Exit Failure: {status}"),
            Self::NotSupported(err) => err.fmt(f),
@@ -35,7 +29,11 @@ impl fmt::Display for EventLoopError {

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

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

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

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

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

 #[allow(unused_macros)]
 macro_rules! os_error {
-    ($error:expr) => {{ crate::error::OsError::new(line!(), file!(), $error) }};
+    ($error:expr) => {{
+        crate::error::OsError::new(line!(), file!(), $error)
+    }};
 }
--- a/winit-core/src/event.rs
+++ b/winit-core/src/event.rs
--- a/src/event_loop.rs
+++ b/src/event_loop.rs
@@ -0,0 +1,545 @@
+//! 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::marker::PhantomData;
+#[cfg(any(x11_platform, wayland_platform))]
+use std::os::unix::io::{AsFd, AsRawFd, BorrowedFd, RawFd};
+use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
+use std::sync::Arc;
+#[cfg(not(web_platform))]
+use std::time::{Duration, Instant};
+
+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::monitor::MonitorHandle;
+use crate::platform_impl;
+use crate::utils::AsAny;
+use crate::window::{CustomCursor, CustomCursorSource, Theme, Window, WindowAttributes};
+
+/// 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
+pub struct EventLoop {
+    pub(crate) event_loop: platform_impl::EventLoop,
+    pub(crate) _marker: PhantomData<*mut ()>, // Not Send nor Sync
+}
+
+/// 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, 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);
+    }
+}
+
+impl fmt::Debug for EventLoopBuilder {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("EventLoopBuilder").finish_non_exhaustive()
+    }
+}
+
+impl fmt::Debug for EventLoop {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("EventLoop").finish_non_exhaustive()
+    }
+}
+
+/// Set through [`ActiveEventLoop::set_control_flow()`].
+///
+/// Indicates the desired behavior of the event loop after [`about_to_wait`] is called.
+///
+/// Defaults to [`Wait`].
+///
+/// [`Wait`]: Self::Wait
+/// [`about_to_wait`]: crate::application::ApplicationHandler::about_to_wait
+#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
+pub enum ControlFlow {
+    /// When the current loop iteration finishes, immediately begin a new iteration regardless of
+    /// whether or not new events are available to process.
+    Poll,
+
+    /// When the current loop iteration finishes, suspend the thread until another event arrives.
+    #[default]
+    Wait,
+
+    /// When the current loop iteration finishes, suspend the thread until either another event
+    /// arrives or the given time is reached.
+    ///
+    /// Useful for implementing efficient timers. Applications which want to render at the
+    /// display's native refresh rate should instead use [`Poll`] and the VSync functionality
+    /// of a graphics API to reduce odds of missed frames.
+    ///
+    /// [`Poll`]: Self::Poll
+    WaitUntil(Instant),
+}
+
+impl ControlFlow {
+    /// Creates a [`ControlFlow`] that waits until a timeout has expired.
+    ///
+    /// In most cases, this is set to [`WaitUntil`]. However, if the timeout overflows, it is
+    /// instead set to [`Wait`].
+    ///
+    /// [`WaitUntil`]: Self::WaitUntil
+    /// [`Wait`]: Self::Wait
+    pub fn wait_duration(timeout: Duration) -> Self {
+        match Instant::now().checked_add(timeout) {
+            Some(instant) => Self::WaitUntil(instant),
+            None => Self::Wait,
+        }
+    }
+}
+
+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 EventLoop {
+    /// Run the application with the event loop on the calling thread.
+    ///
+    /// See the [`set_control_flow()`] docs on how to change the event loop's behavior.
+    ///
+    /// ## 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(
+        any(web_platform, docsrs),
+        doc = "  [`EventLoopExtWeb::spawn_app()`][crate::platform::web::EventLoopExtWeb::spawn_app()]"
+    )]
+    #[cfg_attr(not(any(web_platform, docsrs)), 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()
+    #[inline]
+    #[cfg(not(all(web_platform, target_feature = "exception-handling")))]
+    pub fn run_app<A: ApplicationHandler>(self, app: A) -> Result<(), EventLoopError> {
+        self.event_loop.run_app(app)
+    }
+
+    /// Creates an [`EventLoopProxy`] that can be used to dispatch user events
+    /// to the main event loop, possibly from another thread.
+    pub fn create_proxy(&self) -> EventLoopProxy {
+        self.event_loop.window_target().create_proxy()
+    }
+
+    /// Gets a persistent reference to the underlying platform display.
+    ///
+    /// See the [`OwnedDisplayHandle`] type for more information.
+    pub fn owned_display_handle(&self) -> OwnedDisplayHandle {
+        self.event_loop.window_target().owned_display_handle()
+    }
+
+    /// Change if or when [`DeviceEvent`]s are captured.
+    ///
+    /// See [`ActiveEventLoop::listen_device_events`] for details.
+    ///
+    /// [`DeviceEvent`]: crate::event::DeviceEvent
+    pub 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)
+    }
+
+    /// Sets the [`ControlFlow`].
+    pub fn set_control_flow(&self, control_flow: ControlFlow) {
+        self.event_loop.window_target().set_control_flow(control_flow);
+    }
+
+    /// Create custom cursor.
+    ///
+    /// ## Platform-specific
+    ///
+    /// **iOS / Android / Orbital:** Unsupported.
+    pub 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()
+    }
+}
+
+pub trait ActiveEventLoop: AsAny {
+    /// 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(
+        any(web_platform, docsrs),
+        doc = "[detailed monitor permissions][crate::platform::web::ActiveEventLoopExtWeb::request_detailed_monitor_permission]."
+    )]
+    #[cfg_attr(not(any(web_platform, docsrs)), 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(
+        any(web_platform, docsrs),
+        doc = "  [detailed monitor permissions][crate::platform::web::ActiveEventLoopExtWeb::request_detailed_monitor_permission]."
+    )]
+    #[cfg_attr(not(any(web_platform, docsrs)), 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;
+
+    /// This exits the event loop.
+    ///
+    /// See [`exiting`][crate::application::ApplicationHandler::exiting].
+    fn exit(&self);
+
+    /// Returns if the [`EventLoop`] is about to stop.
+    ///
+    /// See [`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()
+    }
+}
+
+/// 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 {
+    /// See [`EventLoopProxy::wake_up`] for details.
+    fn wake_up(&self);
+}
+
+/// Control the [`EventLoop`], possibly from a different thread, without referencing it directly.
+#[derive(Clone)]
+pub struct EventLoopProxy {
+    pub(crate) proxy: Arc<dyn EventLoopProxyProvider>,
+}
+
+impl fmt::Debug for EventLoopProxy {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("EventLoopProxy").finish_non_exhaustive()
+    }
+}
+
+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))]
+pub enum DeviceEvents {
+    /// Report device events regardless of window focus.
+    Always,
+    /// Only capture device events while the window is focused.
+    #[default]
+    WhenFocused,
+    /// Never capture device events.
+    Never,
+}
+
+/// A unique identifier of the winit's async request.
+///
+/// This could be used to identify the async request once it's done
+/// and a specific action must be taken.
+///
+/// One of the handling scenarios could be to maintain a working list
+/// containing [`AsyncRequestSerial`] and some closure associated with it.
+/// Then once event is arriving the working list is being traversed and a job
+/// executed and removed from the list.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct AsyncRequestSerial {
+    serial: usize,
+}
+
+impl AsyncRequestSerial {
+    // TODO(kchibisov): Remove `cfg` when the clipboard will be added.
+    #[allow(dead_code)]
+    pub(crate) 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.
+        let serial = CURRENT_SERIAL.fetch_add(1, Ordering::Relaxed);
+        Self { serial }
+    }
+}
--- a/src/icon.rs
+++ b/src/icon.rs
@@ -0,0 +1,118 @@
+use std::error::Error;
+use std::{fmt, io, mem};
+
+use crate::platform_impl::PlatformIcon;
+
+#[repr(C)]
+#[derive(Debug)]
+pub(crate) struct Pixel {
+    pub(crate) r: u8,
+    pub(crate) g: u8,
+    pub(crate) b: u8,
+    pub(crate) a: u8,
+}
+
+pub(crate) const PIXEL_SIZE: usize = mem::size_of::<Pixel>();
+
+#[derive(Debug)]
+/// An error produced when using [`Icon::from_rgba`] with invalid arguments.
+pub enum BadIcon {
+    /// Produced when the length of the `rgba` argument isn't divisible by 4, thus `rgba` can't be
+    /// safely interpreted as 32bpp RGBA pixels.
+    ByteCountNotDivisibleBy4 { byte_count: usize },
+    /// Produced when the number of pixels (`rgba.len() / 4`) isn't equal to `width * height`.
+    /// At least one of your arguments is incorrect.
+    DimensionsVsPixelCount { width: u32, height: u32, width_x_height: usize, pixel_count: usize },
+    /// Produced when underlying OS functionality failed to create the icon
+    OsError(io::Error),
+}
+
+impl fmt::Display for BadIcon {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            BadIcon::ByteCountNotDivisibleBy4 { byte_count } => write!(
+                f,
+                "The length of the `rgba` argument ({byte_count:?}) isn't divisible by 4, making \
+                 it impossible to interpret as 32bpp RGBA pixels.",
+            ),
+            BadIcon::DimensionsVsPixelCount { width, height, width_x_height, pixel_count } => {
+                write!(
+                    f,
+                    "The specified dimensions ({width:?}x{height:?}) don't match the number of \
+                     pixels supplied by the `rgba` argument ({pixel_count:?}). For those \
+                     dimensions, the expected pixel count is {width_x_height:?}.",
+                )
+            },
+            BadIcon::OsError(e) => write!(f, "OS error when instantiating the icon: {e:?}"),
+        }
+    }
+}
+
+impl Error for BadIcon {}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub(crate) struct RgbaIcon {
+    pub(crate) rgba: Vec<u8>,
+    pub(crate) width: u32,
+    pub(crate) height: u32,
+}
+
+/// For platforms which don't have window icons (e.g. Web)
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub(crate) struct NoIcon;
+
+#[allow(dead_code)] // These are not used on every platform
+mod constructors {
+    use super::*;
+
+    impl RgbaIcon {
+        pub fn from_rgba(rgba: Vec<u8>, width: u32, height: u32) -> Result<Self, BadIcon> {
+            if rgba.len() % PIXEL_SIZE != 0 {
+                return Err(BadIcon::ByteCountNotDivisibleBy4 { byte_count: rgba.len() });
+            }
+            let pixel_count = rgba.len() / PIXEL_SIZE;
+            if pixel_count != (width * height) as usize {
+                Err(BadIcon::DimensionsVsPixelCount {
+                    width,
+                    height,
+                    width_x_height: (width * height) as usize,
+                    pixel_count,
+                })
+            } else {
+                Ok(RgbaIcon { rgba, width, height })
+            }
+        }
+    }
+
+    impl NoIcon {
+        pub fn from_rgba(rgba: Vec<u8>, width: u32, height: u32) -> Result<Self, BadIcon> {
+            // Create the rgba icon anyway to validate the input
+            let _ = RgbaIcon::from_rgba(rgba, width, height)?;
+            Ok(NoIcon)
+        }
+    }
+}
+
+/// An icon used for the window titlebar, taskbar, etc.
+#[derive(Clone, Eq, Hash, PartialEq)]
+pub struct Icon {
+    pub(crate) inner: PlatformIcon,
+}
+
+impl fmt::Debug for Icon {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
+        fmt::Debug::fmt(&self.inner, formatter)
+    }
+}
+
+impl Icon {
+    /// Creates an icon from 32bpp RGBA data.
+    ///
+    /// The length of `rgba` must be divisible by 4, and `width * height` must equal
+    /// `rgba.len() / 4`. Otherwise, this will return a `BadIcon` error.
+    pub fn from_rgba(rgba: Vec<u8>, width: u32, height: u32) -> Result<Self, BadIcon> {
+        let _span = tracing::debug_span!("winit::Icon::from_rgba", width, height).entered();
+
+        Ok(Icon { inner: PlatformIcon::from_rgba(rgba, width, height)? })
+    }
+}
--- a/src/keyboard.rs
+++ b/src/keyboard.rs
--- a/winit/src/lib.rs
+++ b/winit/src/lib.rs
@@ -26,14 +26,23 @@
 //! Some user activity, like mouse movement, can generate both a [`WindowEvent`] *and* a
 //! [`DeviceEvent`].
 //!
-//! You can retrieve events by calling [`EventLoop::run_app()`]. This function will dispatch events
-//! for every [`Window`] that was created with that particular [`EventLoop`].
+//! You can retrieve events by calling [`EventLoop::run_app()`]. This function will
+//! dispatch events for every [`Window`] that was created with that particular [`EventLoop`], and
+//! will run until [`exit()`] is used, at which point [`exiting()`] is called.
 //!
 //! Winit no longer uses a `EventLoop::poll_events() -> impl Iterator<Event>`-based event loop
 //! model, since that can't be implemented properly on some platforms (e.g Web, iOS) and works
 //! poorly on most other platforms. However, this model can be re-implemented to an extent with
-//! [`EventLoopExtPumpEvents::pump_app_events()`] [^1]. See that method's documentation for more
-//! reasons about why it's discouraged beyond compatibility reasons.
+#![cfg_attr(
+    any(windows_platform, macos_platform, android_platform, x11_platform, wayland_platform),
+    doc = "[`EventLoopExtPumpEvents::pump_app_events()`][platform::pump_events::EventLoopExtPumpEvents::pump_app_events()]"
+)]
+#![cfg_attr(
+    not(any(windows_platform, macos_platform, android_platform, x11_platform, wayland_platform)),
+    doc = "`EventLoopExtPumpEvents::pump_app_events()`"
+)]
+//! [^1]. See that method's documentation for more reasons about why
+//! it's discouraged beyond compatibility reasons.
 //!
 //!
 //! ```no_run
@@ -49,19 +58,10 @@
 //!
 //! impl ApplicationHandler for App {
 //!     fn can_create_surfaces(&mut self, event_loop: &dyn ActiveEventLoop) {
-//!         // The event loop has launched, and we can initialize our UI state.
-//!
-//!         // Create a simple window with default attributes.
 //!         self.window = Some(event_loop.create_window(WindowAttributes::default()).unwrap());
 //!     }
 //!
-//!     fn window_event(
-//!         &mut self,
-//!         event_loop: &dyn ActiveEventLoop,
-//!         id: WindowId,
-//!         event: WindowEvent,
-//!     ) {
-//!         // Called by `EventLoop::run_app` when a new event happens on the window.
+//!     fn window_event(&mut self, event_loop: &dyn ActiveEventLoop, id: WindowId, event: WindowEvent) {
 //!         match event {
 //!             WindowEvent::CloseRequested => {
 //!                 println!("The close button was pressed; stopping");
@@ -82,18 +82,15 @@
 //!                 // applications which do not always need to. Applications that redraw continuously
 //!                 // can render here instead.
 //!                 self.window.as_ref().unwrap().request_redraw();
-//!             },
+//!             }
 //!             _ => (),
 //!         }
 //!     }
 //! }
 //!
 //! # // Intentionally use `fn main` for clarity
-//! fn main() -> Result<(), Box<dyn std::error::Error>> {
-//!     // Create a new event loop.
-//!     let event_loop = EventLoop::new()?;
-//!
-//!     // Configure settings before launching.
+//! fn main() {
+//!     let event_loop = EventLoop::new().unwrap();
 //!
 //!     // ControlFlow::Poll continuously runs the event loop, even if the OS hasn't
 //!     // dispatched any events. This is ideal for games and similar applications.
@@ -104,10 +101,8 @@
 //!     // input, and uses significantly less power/CPU time than ControlFlow::Poll.
 //!     event_loop.set_control_flow(ControlFlow::Wait);
 //!
-//!     // Launch and begin running the event loop.
-//!     event_loop.run_app(App::default())?;
-//!
-//!     Ok(())
+//!     let mut app = App::default();
+//!     event_loop.run_app(&mut app);
 //! }
 //! ```
 //!
@@ -266,9 +261,9 @@
 //! [`Window::id()`]: window::Window::id
 //! [`WindowEvent`]: event::WindowEvent
 //! [`DeviceEvent`]: event::DeviceEvent
+//! [`exiting()`]: crate::application::ApplicationHandler::exiting
 //! [`raw_window_handle`]: ./window/struct.Window.html#method.raw_window_handle
 //! [`raw_display_handle`]: ./window/struct.Window.html#method.raw_display_handle
-//! [`EventLoopExtPumpEvents::pump_app_events()`]: crate::event_loop::pump_events::EventLoopExtPumpEvents::pump_app_events()
 //! [^1]: `EventLoopExtPumpEvents::pump_app_events()` is only available on Windows, macOS, Android, X11 and Wayland.

 #![deny(rust_2018_idioms)]
@@ -278,23 +273,28 @@
 #![cfg_attr(clippy, deny(warnings))]
 // Doc feature labels can be tested locally by running RUSTDOCFLAGS="--cfg=docsrs" cargo +nightly
 // doc
-#![cfg_attr(docsrs, feature(doc_cfg), doc(auto_cfg(hide(doc, docsrs))))]
+#![cfg_attr(docsrs, feature(doc_auto_cfg, doc_cfg_hide), doc(cfg_hide(doc, docsrs)))]
 #![allow(clippy::missing_safety_doc)]
 #![warn(clippy::uninlined_format_args)]
-// TODO: wasm-binding needs to be updated for that to be resolved, for now just silence it.
-#![cfg_attr(web_platform, allow(unknown_lints, renamed_and_removed_lints, wasm_c_abi))]

 // Re-export DPI types so that users don't have to put it in Cargo.toml.
 #[doc(inline)]
 pub use dpi;
 pub use rwh_06 as raw_window_handle;

+pub mod application;
 #[cfg(any(doc, doctest, test))]
 pub mod changelog;
-pub mod event_loop;
-pub use winit_core::{application, cursor, error, event, icon, keyboard, monitor, window};
 #[macro_use]
-mod os_error;
+pub mod error;
+mod cursor;
+pub mod event;
+pub mod event_loop;
+mod icon;
+pub mod keyboard;
+pub mod monitor;
 mod platform_impl;
+mod utils;
+pub mod window;

 pub mod platform;
--- a/src/monitor.rs
+++ b/src/monitor.rs
@@ -0,0 +1,169 @@
+//! Types useful for interacting with a user's monitors.
+use std::fmt;
+use std::num::{NonZeroU16, NonZeroU32};
+
+use crate::dpi::{PhysicalPosition, PhysicalSize};
+use crate::platform_impl;
+
+/// Describes a fullscreen video mode of a monitor.
+///
+/// Can be retrieved with [`MonitorHandle::video_modes()`].
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct VideoMode {
+    pub(crate) size: PhysicalSize<u32>,
+    pub(crate) bit_depth: Option<NonZeroU16>,
+    pub(crate) refresh_rate_millihertz: Option<NonZeroU32>,
+}
+
+impl VideoMode {
+    /// Returns the resolution of this video mode. This **must not** be used to create your
+    /// rendering surface. Use [`Window::surface_size()`] instead.
+    ///
+    /// [`Window::surface_size()`]: crate::window::Window::surface_size
+    pub fn size(&self) -> PhysicalSize<u32> {
+        self.size
+    }
+
+    /// 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.
+    pub fn bit_depth(&self) -> Option<NonZeroU16> {
+        self.bit_depth
+    }
+
+    /// Returns the refresh rate of this video mode in mHz.
+    pub fn refresh_rate_millihertz(&self) -> Option<NonZeroU32> {
+        self.refresh_rate_millihertz
+    }
+}
+
+impl fmt::Display for VideoMode {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}x{}", self.size.width, self.size.height)?;
+
+        if let Some(refresh_rate) = self.refresh_rate_millihertz {
+            write!(f, "@{refresh_rate}mHz")?;
+        }
+
+        if let Some(bit_depth) = self.bit_depth {
+            write!(f, " ({bit_depth} bpp)")?;
+        }
+
+        Ok(())
+    }
+}
+
+/// Handle to a monitor.
+///
+/// Allows you to retrieve basic information and metadata about a monitor.
+///
+/// Can be used in [`Window`] creation to place the window on a specific
+/// monitor.
+///
+/// This can be retrieved from one of the following methods, which return an
+/// iterator of [`MonitorHandle`]s:
+/// - [`ActiveEventLoop::available_monitors`](crate::event_loop::ActiveEventLoop::available_monitors).
+/// - [`Window::available_monitors`](crate::window::Window::available_monitors).
+///
+/// ## Platform-specific
+///
+/// **Web:** A [`MonitorHandle`] created without
+#[cfg_attr(
+    any(web_platform, docsrs),
+    doc = "[detailed monitor permissions][crate::platform::web::ActiveEventLoopExtWeb::request_detailed_monitor_permission]."
+)]
+#[cfg_attr(not(any(web_platform, docsrs)), doc = "detailed monitor permissions.")]
+/// will always represent the current monitor the browser window is in instead of a specific
+/// monitor. See
+#[cfg_attr(
+    any(web_platform, docsrs),
+    doc = "[`MonitorHandleExtWeb::is_detailed()`][crate::platform::web::MonitorHandleExtWeb::is_detailed]"
+)]
+#[cfg_attr(not(any(web_platform, docsrs)), doc = "`MonitorHandleExtWeb::is_detailed()`")]
+/// to check.
+///
+/// [`Window`]: crate::window::Window
+#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub struct MonitorHandle {
+    pub(crate) inner: platform_impl::MonitorHandle,
+}
+
+impl std::fmt::Debug for MonitorHandle {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.inner.fmt(f)
+    }
+}
+
+impl MonitorHandle {
+    /// Returns a human-readable name of the monitor.
+    ///
+    /// Returns `None` if the monitor doesn't exist anymore.
+    ///
+    /// ## Platform-specific
+    ///
+    /// **Web:** Always returns [`None`] without
+    #[cfg_attr(
+        any(web_platform, docsrs),
+        doc = "[detailed monitor permissions][crate::platform::web::ActiveEventLoopExtWeb::request_detailed_monitor_permission]."
+    )]
+    #[cfg_attr(not(any(web_platform, docsrs)), doc = "detailed monitor permissions.")]
+    #[inline]
+    pub fn name(&self) -> Option<String> {
+        self.inner.name()
+    }
+
+    /// Returns the top-left corner position of the monitor in desktop coordinates.
+    ///
+    /// This position is in the same coordinate system as [`Window::outer_position`].
+    ///
+    /// [`Window::outer_position`]: crate::window::Window::outer_position
+    ///
+    /// ## Platform-specific
+    ///
+    /// **Web:** Always returns [`None`] without
+    #[cfg_attr(
+        any(web_platform, docsrs),
+        doc = "[detailed monitor permissions][crate::platform::web::ActiveEventLoopExtWeb::request_detailed_monitor_permission]."
+    )]
+    #[cfg_attr(not(any(web_platform, docsrs)), doc = "detailed monitor permissions.")]
+    #[inline]
+    pub fn position(&self) -> Option<PhysicalPosition<i32>> {
+        self.inner.position()
+    }
+
+    /// Returns the scale factor of the underlying monitor. To map logical pixels to physical
+    /// pixels and vice versa, use [`Window::scale_factor`].
+    ///
+    /// 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(
+        any(web_platform, docsrs),
+        doc = "  [detailed monitor permissions][crate::platform::web::ActiveEventLoopExtWeb::request_detailed_monitor_permission]."
+    )]
+    #[cfg_attr(not(any(web_platform, docsrs)), doc = "  detailed monitor permissions.")]
+    ///
+    #[rustfmt::skip]
+    /// [`Window::scale_factor`]: crate::window::Window::scale_factor
+    #[inline]
+    pub fn scale_factor(&self) -> f64 {
+        self.inner.scale_factor()
+    }
+
+    /// Returns the currently active video mode of this monitor.
+    #[inline]
+    pub fn current_video_mode(&self) -> Option<VideoMode> {
+        self.inner.current_video_mode()
+    }
+
+    /// Returns all fullscreen video modes supported by this monitor.
+    #[inline]
+    pub fn video_modes(&self) -> impl Iterator<Item = VideoMode> {
+        self.inner.video_modes()
+    }
+}
--- a/winit-android/src/lib.rs
+++ b/winit-android/src/lib.rs
@@ -62,26 +62,17 @@
 //! If your application is currently based on `NativeActivity` via the `ndk-glue` crate and building
 //! with `cargo apk`, then the minimal changes would be:
 //! 1. Remove `ndk-glue` from your `Cargo.toml`
-//! 2. Enable the `"android-native-activity"` feature for Winit: `winit = { version =
-//!    "0.31.0-beta.2", features = [ "android-native-activity" ] }`
+//! 2. Enable the `"android-native-activity"` feature for Winit: `winit = { version = "0.30.9",
+//!    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};
-pub use crate::event_loop::{
-    ActiveEventLoop, EventLoop, EventLoopProxy, PlatformSpecificEventLoopAttributes,
-    PlatformSpecificWindowAttributes, Window,
-};
+use crate::event_loop::{ActiveEventLoop, EventLoop, EventLoopBuilder};
+use crate::window::{Window, WindowAttributes};

 /// Additional methods on [`EventLoop`] that are specific to Android.
 pub trait EventLoopExtAndroid {
@@ -89,6 +80,12 @@ 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.
@@ -102,25 +99,31 @@ pub trait WindowExtAndroid {
    fn config(&self) -> ConfigurationRef;
 }

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

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

-impl ActiveEventLoopExtAndroid for dyn CoreActiveEventLoop + '_ {
+impl ActiveEventLoopExtAndroid for dyn ActiveEventLoop + '_ {
    fn android_app(&self) -> &AndroidApp {
-        let event_loop = self.cast_ref::<ActiveEventLoop>().unwrap();
+        let event_loop =
+            self.as_any().downcast_ref::<crate::platform_impl::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
    ///
@@ -133,6 +136,18 @@ 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
@@ -161,5 +176,16 @@ 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-uikit/src/lib.rs
+++ b/winit-uikit/src/lib.rs
@@ -1,4 +1,4 @@
-//! # Winit's UIKit (iOS/tvOS/visionOS) backend
+//! # iOS / UIKit
 //!
 //! Winit has [the same iOS version requirements as `rustc`][rustc-ios-version], although it's
 //! frequently only tested on newer iOS versions.
@@ -85,9 +85,12 @@
 //!
 //!  - applicationDidBecomeActive is Resumed
 //!  - applicationWillResignActive is Suspended
-//!  - applicationWillTerminate corresponds to `Drop`ping the application handler.
+//!  - applicationWillTerminate is LoopExiting
 //!
-//! Note that an app may not receive the `Drop` event if suspended; it might be SIGKILL'ed.
+//! Keep in mind that after LoopExiting event is received every attempt to draw with
+//! opengl will result in segfault.
+//!
+//! Also note that app may not receive the LoopExiting event if suspended; it might be SIGKILL'ed.
 //!
 //! ## Custom `UIApplicationDelegate`
 //!
@@ -98,36 +101,24 @@
 //! 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 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};

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

 /// Additional methods on [`Window`] that are specific to iOS.
 pub trait WindowExtIOS {
    /// 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
-    /// this to [`MonitorHandleProvider::scale_factor()`].
+    /// this to [`MonitorHandle::scale_factor()`].
    ///
    /// [`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 set_scale_factor(&self, scale_factor: f64);

    /// Sets the valid orientations for the [`Window`].
@@ -221,25 +212,25 @@ pub trait WindowExtIOS {
 impl WindowExtIOS for dyn Window + '_ {
    #[inline]
    fn set_scale_factor(&self, scale_factor: f64) {
-        let window = self.cast_ref::<UIKitWindow>().unwrap();
+        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().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::<UIKitWindow>().unwrap();
+        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().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::<UIKitWindow>().unwrap();
+        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().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::<UIKitWindow>().unwrap();
+        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
        window.maybe_wait_on_main(move |w| {
            w.set_preferred_screen_edges_deferring_system_gestures(edges)
        });
@@ -247,19 +238,19 @@ impl WindowExtIOS for dyn Window + '_ {

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

@@ -270,7 +261,7 @@ impl WindowExtIOS for dyn Window + '_ {
        minimum_number_of_touches: u8,
        maximum_number_of_touches: u8,
    ) {
-        let window = self.cast_ref::<UIKitWindow>().unwrap();
+        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
        window.maybe_wait_on_main(move |w| {
            w.recognize_pan_gesture(
                should_recognize,
@@ -282,41 +273,27 @@ impl WindowExtIOS for dyn Window + '_ {

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

-/// 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 {
+/// Additional methods on [`WindowAttributes`] that are specific to iOS.
+pub trait WindowAttributesExtIOS {
    /// 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
-    /// this to [`MonitorHandleProvider::scale_factor()`].
+    /// this to [`MonitorHandle::scale_factor()`].
    ///
    /// [`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()
-    pub fn with_scale_factor(mut self, scale_factor: f64) -> Self {
-        self.scale_factor = Some(scale_factor);
-        self
-    }
+    fn with_scale_factor(self, scale_factor: f64) -> Self;

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

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

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

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

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

-impl PlatformWindowAttributes for WindowAttributesIos {
-    fn box_clone(&self) -> Box<dyn PlatformWindowAttributes> {
-        Box::from(self.clone())
+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
    }
 }

@@ -404,14 +395,12 @@ 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::<UIKitMonitorHandle>().unwrap();
-        objc2::rc::Retained::as_ptr(monitor.ui_screen(mtm)) as *mut c_void
+        objc2::rc::Retained::as_ptr(self.inner.ui_screen(mtm)) as *mut c_void
    }

    #[inline]
    fn preferred_video_mode(&self) -> VideoMode {
-        let monitor = self.cast_ref::<UIKitMonitorHandle>().unwrap();
-        monitor.preferred_video_mode()
+        self.inner.preferred_video_mode()
    }
 }

--- a/winit-appkit/src/lib.rs
+++ b/winit-appkit/src/lib.rs
@@ -17,12 +17,13 @@
 //! 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::{DefinedClass, MainThreadMarker, MainThreadOnly, define_class, msg_send};
+//! use objc2::{define_class, msg_send, DefinedClass, MainThreadMarker, MainThreadOnly};
 //! use objc2_app_kit::{NSApplication, NSApplicationDelegate};
-//! use objc2_foundation::{NSArray, NSObject, NSObjectProtocol, NSURL};
+//! use objc2_foundation::{NSArray, NSURL, NSObject, NSObjectProtocol};
 //! use winit::event_loop::EventLoop;
 //!
 //! define_class!(
@@ -63,39 +64,16 @@
 //!     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 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};

-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;
+use crate::application::ApplicationHandler;
+use crate::event_loop::{ActiveEventLoop, EventLoopBuilder};
+use crate::monitor::MonitorHandle;
+use crate::window::{Window, WindowAttributes, WindowId};

 /// Additional methods on [`Window`] that are specific to MacOS.
 pub trait WindowExtMacOS {
@@ -172,9 +150,7 @@ pub trait WindowExtMacOS {
    /// Getter for the [`WindowExtMacOS::set_option_as_alt`].
    fn option_as_alt(&self) -> OptionAsAlt;

-    /// Disable the Menu Bar and Dock in Simple or Borderless Fullscreen mode. Useful for games.
-    /// The effect is applied when [`WindowExtMacOS::set_simple_fullscreen`] or
-    /// [`Window::set_fullscreen`] is called.
+    /// Disable the Menu Bar and Dock in Borderless Fullscreen mode. Useful for games.
    fn set_borderless_game(&self, borderless_game: bool);

    /// Getter for the [`WindowExtMacOS::set_borderless_game`].
@@ -191,109 +167,109 @@ pub trait WindowExtMacOS {
 impl WindowExtMacOS for dyn Window + '_ {
    #[inline]
    fn simple_fullscreen(&self) -> bool {
-        let window = self.cast_ref::<AppKitWindow>().unwrap();
+        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
        window.maybe_wait_on_main(|w| w.simple_fullscreen())
    }

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

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

    #[inline]
    fn set_has_shadow(&self, has_shadow: bool) {
-        let window = self.cast_ref::<AppKitWindow>().unwrap();
+        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().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::<AppKitWindow>().unwrap();
+        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
        window.maybe_wait_on_main(|w| w.set_tabbing_identifier(identifier))
    }

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

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

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

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

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

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

-/// Window attributes that are specific to MacOS.
+/// Additional methods on [`WindowAttributes`] that are specific to MacOS.
 ///
 /// **Note:** Properties dealing with the titlebar will be overwritten by the
 /// [`WindowAttributes::with_decorations`] method:
@@ -322,158 +298,127 @@ pub enum ActivationPolicy {
 /// - `with_titlebar_hidden`
 /// - `with_titlebar_buttons_hidden`
 /// - `with_fullsize_content_view`
-///
-/// [`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 {
+pub trait WindowAttributesExtMacOS {
    /// Enables click-and-drag behavior for the entire window, not just the titlebar.
-    #[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
-    }
-
+    fn with_movable_by_window_background(self, movable_by_window_background: bool) -> Self;
    /// Makes the titlebar transparent and allows the content to appear behind it.
-    #[inline]
-    pub fn with_titlebar_transparent(mut self, titlebar_transparent: bool) -> Self {
-        self.titlebar_transparent = titlebar_transparent;
-        self
-    }
-
-    /// Hides the window titlebar.
-    #[inline]
-    pub fn with_titlebar_hidden(mut self, titlebar_hidden: bool) -> Self {
-        self.titlebar_hidden = titlebar_hidden;
-        self
-    }
-
-    /// Hides the window titlebar buttons.
-    #[inline]
-    pub fn with_titlebar_buttons_hidden(mut self, titlebar_buttons_hidden: bool) -> Self {
-        self.titlebar_buttons_hidden = titlebar_buttons_hidden;
-        self
-    }
-
+    fn with_titlebar_transparent(self, titlebar_transparent: bool) -> Self;
    /// Hides the window title.
-    #[inline]
-    pub fn with_title_hidden(mut self, title_hidden: bool) -> Self {
-        self.title_hidden = title_hidden;
-        self
-    }
-
+    fn with_title_hidden(self, title_hidden: bool) -> Self;
+    /// Hides the window titlebar.
+    fn with_titlebar_hidden(self, titlebar_hidden: bool) -> Self;
+    /// Hides the window titlebar buttons.
+    fn with_titlebar_buttons_hidden(self, titlebar_buttons_hidden: bool) -> Self;
    /// Makes the window content appear behind the titlebar.
-    #[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
-    }
-
+    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;
    /// Window accepts click-through mouse events.
-    #[inline]
-    pub fn with_accepts_first_mouse(mut self, accepts_first_mouse: bool) -> Self {
-        self.accepts_first_mouse = accepts_first_mouse;
-        self
-    }
-
+    fn with_accepts_first_mouse(self, accepts_first_mouse: bool) -> Self;
    /// Defines the window tabbing identifier.
    ///
    /// <https://developer.apple.com/documentation/appkit/nswindow/1644704-tabbingidentifier>
-    #[inline]
-    pub fn with_tabbing_identifier(mut self, tabbing_identifier: &str) -> Self {
-        self.tabbing_identifier.replace(tabbing_identifier.to_string());
-        self
-    }
-
+    fn with_tabbing_identifier(self, identifier: &str) -> Self;
    /// Set how the <kbd>Option</kbd> keys are interpreted.
    ///
    /// See [`WindowExtMacOS::set_option_as_alt`] for details on what this means if set.
-    #[inline]
-    pub fn with_option_as_alt(mut self, option_as_alt: OptionAsAlt) -> Self {
-        self.option_as_alt = option_as_alt;
-        self
-    }
-
+    fn with_option_as_alt(self, option_as_alt: OptionAsAlt) -> Self;
    /// See [`WindowExtMacOS::set_borderless_game`] for details on what this means if set.
-    #[inline]
-    pub fn with_borderless_game(mut self, borderless_game: bool) -> Self {
-        self.borderless_game = borderless_game;
-        self
-    }
-
+    fn with_borderless_game(self, borderless_game: bool) -> Self;
    /// See [`WindowExtMacOS::set_unified_titlebar`] for details on what this means if set.
-    #[inline]
-    pub fn with_unified_titlebar(mut self, unified_titlebar: bool) -> Self {
-        self.unified_titlebar = unified_titlebar;
-        self
-    }
-
+    fn with_unified_titlebar(self, unified_titlebar: bool) -> 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;
+}
+
+impl WindowAttributesExtMacOS for WindowAttributes {
    #[inline]
-    pub fn with_panel(mut self, panel: bool) -> Self {
-        self.panel = panel;
+    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
    }
-}

-impl Default for WindowAttributesMacOS {
    #[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,
-        }
+    fn with_titlebar_transparent(mut self, titlebar_transparent: bool) -> Self {
+        self.platform_specific.titlebar_transparent = titlebar_transparent;
+        self
    }
-}

-impl PlatformWindowAttributes for WindowAttributesMacOS {
-    fn box_clone(&self) -> Box<dyn PlatformWindowAttributes> {
-        Box::from(self.clone())
+    #[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
    }
 }

@@ -532,18 +477,44 @@ 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 the identifier of the monitor for Cocoa.
+    fn native_id(&self) -> u32;
    /// Returns a pointer to the NSScreen representing this monitor.
    fn ns_screen(&self) -> Option<*mut c_void>;
 }

 impl MonitorHandleExtMacOS for MonitorHandle {
+    #[inline]
+    fn native_id(&self) -> u32 {
+        self.inner.native_identifier()
+    }
+
    fn ns_screen(&self) -> Option<*mut c_void> {
-        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 _)
+        self.inner.ns_screen(mtm).map(|s| objc2::rc::Retained::as_ptr(&s) as _)
    }
 }

@@ -565,26 +536,34 @@ pub trait ActiveEventLoopExtMacOS {

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

    fn hide_other_applications(&self) {
-        let event_loop =
-            self.cast_ref::<AppKitActiveEventLoop>().expect("non macOS event loop on macOS");
+        let event_loop = self
+            .as_any()
+            .downcast_ref::<crate::platform_impl::ActiveEventLoop>()
+            .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::<AppKitActiveEventLoop>().expect("non macOS event loop on macOS");
+        let event_loop = self
+            .as_any()
+            .downcast_ref::<crate::platform_impl::ActiveEventLoop>()
+            .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::<AppKitActiveEventLoop>().expect("non macOS event loop on macOS");
+        let event_loop = self
+            .as_any()
+            .downcast_ref::<crate::platform_impl::ActiveEventLoop>()
+            .expect("non macOS event loop on macOS");
        event_loop.allows_automatic_window_tabbing()
    }
 }
@@ -608,3 +587,52 @@ 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/mod.rs
+++ b/src/platform/mod.rs
@@ -0,0 +1,46 @@
+//! Contains traits with platform-specific methods in them.
+//!
+//! Only the modules corresponding to the platform you're compiling to will be available.
+
+#[cfg(any(android_platform, docsrs))]
+pub mod android;
+#[cfg(any(ios_platform, docsrs))]
+pub mod ios;
+#[cfg(any(macos_platform, docsrs))]
+pub mod macos;
+#[cfg(any(orbital_platform, docsrs))]
+pub mod orbital;
+#[cfg(any(x11_platform, wayland_platform, docsrs))]
+pub mod startup_notify;
+#[cfg(any(wayland_platform, docsrs))]
+pub mod wayland;
+#[cfg(any(web_platform, docsrs))]
+pub mod web;
+#[cfg(any(windows_platform, docsrs))]
+pub mod windows;
+#[cfg(any(x11_platform, docsrs))]
+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;
--- a/src/platform/orbital.rs
+++ b/src/platform/orbital.rs
@@ -0,0 +1,6 @@
+//! # 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/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.
@@ -47,19 +47,19 @@ pub trait EventLoopExtPumpEvents {
    /// buffered and handled outside of Winit include:
    /// - `RedrawRequested` events, used to schedule rendering.
    ///
-    ///   macOS for example uses a `drawRect` callback to drive rendering
-    ///   within applications and expects rendering to be finished before
-    ///   the `drawRect` callback returns.
+    ///     macOS for example uses a `drawRect` callback to drive rendering
+    ///     within applications and expects rendering to be finished before
+    ///     the `drawRect` callback returns.
    ///
-    ///   For portability it's strongly recommended that applications should
-    ///   keep their rendering inside the closure provided to Winit.
+    ///     For portability it's strongly recommended that applications should
+    ///     keep their rendering inside the closure provided to Winit.
    /// - Any lifecycle events, such as `Suspended` / `Resumed`.
    ///
-    ///   The handling of these events needs to be synchronized with the
-    ///   operating system and it would never be appropriate to buffer a
-    ///   notification that your application has been suspended or resumed and
-    ///   then handled that later since there would always be a chance that
-    ///   other lifecycle events occur while the event is buffered.
+    ///     The handling of these events needs to be synchronized with the
+    ///     operating system and it would never be appropriate to buffer a
+    ///     notification that your application has been suspended or resumed and
+    ///     then handled that later since there would always be a chance that
+    ///     other lifecycle events occur while the event is buffered.
    ///
    /// ## Supported Platforms
    ///
@@ -83,22 +83,18 @@ pub trait EventLoopExtPumpEvents {
    /// - **Windows**: The implementation will use `PeekMessage` when checking for window messages
    ///   to avoid blocking your external event loop.
    ///
-    /// - **MacOS**: The implementation works in terms of stopping the global application whenever
-    ///   the application `RunLoop` indicates that it is preparing to block and wait for new events.
+    /// - **MacOS**: Certain actions like resizing the window will enter a "modal" state, where
+    ///   `pump_app_events` will process events internally, and block until the resize is over.
    ///
-    ///   This is very different to the polling APIs that are available on other
-    ///   platforms (the lower level polling primitives on MacOS are private
-    ///   implementation details for `NSApplication` which aren't accessible to
-    ///   application developers)
+    ///   Thus, if you render or run your game code outside of `ApplicationHandler`, your
+    ///   application will freeze while the window resizes. The recommended approach is to render
+    ///   inside [`WindowEvent::RedrawRequested`] instead.
    ///
-    ///   It's likely this will be less efficient than polling on other OSs and
-    ///   it also means the `NSApplication` is stopped while outside of the Winit
-    ///   event loop - and that's observable (for example to crates like `rfd`)
-    ///   because the `NSApplication` is global state.
+    ///   Furthermore, when pumping events the `NSApplication` is still considered stopped to
+    ///   crates like `rfd` that inspect [`-[NSApplication isRunning]`][isrunning].
    ///
-    ///   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.
+    /// [`WindowEvent::RedrawRequested`]: crate::event::WindowEvent::RedrawRequested
+    /// [isrunning]: https://developer.apple.com/documentation/appkit/nsapplication/isrunning?language=objc
    fn pump_app_events<A: ApplicationHandler>(
        &mut self,
        timeout: Option<Duration>,
@@ -106,6 +102,16 @@ pub trait EventLoopExtPumpEvents {
    ) -> PumpStatus;
 }

+impl EventLoopExtPumpEvents for EventLoop {
+    fn pump_app_events<A: ApplicationHandler>(
+        &mut self,
+        timeout: Option<Duration>,
+        app: A,
+    ) -> PumpStatus {
+        self.event_loop.pump_app_events(timeout, app)
+    }
+}
+
 /// The return status for `pump_events`
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
 pub enum PumpStatus {
--- a/winit-core/src/event_loop/run_on_demand.rs
+++ b/winit-core/src/event_loop/run_on_demand.rs
@@ -1,9 +1,9 @@
 use crate::application::ApplicationHandler;
 use crate::error::EventLoopError;
+use crate::event_loop::EventLoop;
 #[cfg(doc)]
 use crate::{
-    event_loop::{ActiveEventLoop, pump_events::EventLoopExtPumpEvents},
-    window::Window,
+    event_loop::ActiveEventLoop, platform::pump_events::EventLoopExtPumpEvents, window::Window,
 };

 /// Additional methods on [`EventLoop`] to return control flow to the caller.
@@ -11,8 +11,9 @@ pub trait EventLoopExtRunOnDemand {
    /// Run the application with the event loop on the calling thread.
    ///
    /// Unlike [`EventLoop::run_app`], this function accepts non-`'static` (i.e. non-`move`)
-    /// state and it is possible to return control back to the caller without consuming the
-    /// `EventLoop` (by using [`exit()`]) and so the event loop can be re-run after it has exit.
+    /// closures and it is possible to return control back to the caller without
+    /// consuming the `EventLoop` (by using [`exit()`]) and
+    /// so the event loop can be re-run after it has exit.
    ///
    /// It's expected that each run of the loop will be for orthogonal instantiations of your
    /// Winit application, but internally each instantiation may re-use some common window
@@ -29,7 +30,14 @@ pub trait EventLoopExtRunOnDemand {
    ///
    /// # Caveats
    /// - This extension isn't available on all platforms, since it's not always possible to return
-    ///   to the caller (specifically this is impossible on iOS and Web).
+    ///   to the caller (specifically this is impossible on iOS and Web - though with the Web
+    ///   backend it is possible to use
+    #[cfg_attr(
+        any(web_platform, docsrs),
+        doc = "  [`EventLoopExtWeb::spawn_app()`][crate::platform::web::EventLoopExtWeb::spawn_app()]"
+    )]
+    #[cfg_attr(not(any(web_platform, docsrs)), doc = "  `EventLoopExtWeb::spawn_app()`")]
+    ///   [^1] more than once instead).
    /// - No [`Window`] state can be carried between separate runs of the event loop.
    ///
    /// You are strongly encouraged to use [`EventLoop::run_app()`] for portability, unless you
@@ -48,7 +56,28 @@ pub trait EventLoopExtRunOnDemand {
    ///   are delivered via callbacks based on an event loop that is internal to the browser itself.
    /// - **iOS:** It's not possible to stop and start an `UIApplication` repeatedly on iOS.
    ///
+    /// [^1]: `spawn_app()` is only available on the Web platforms.
+    ///
    /// [`exit()`]: ActiveEventLoop::exit()
    /// [`set_control_flow()`]: ActiveEventLoop::set_control_flow()
    fn run_app_on_demand<A: ApplicationHandler>(&mut self, app: A) -> Result<(), EventLoopError>;
 }
+
+impl EventLoopExtRunOnDemand for EventLoop {
+    fn run_app_on_demand<A: ApplicationHandler>(&mut self, app: A) -> 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/src/platform/scancode.rs
+++ b/winit/src/platform/scancode.rs
--- a/winit/src/platform/startup_notify.rs
+++ b/winit/src/platform/startup_notify.rs
@@ -27,7 +27,7 @@ use crate::error::{NotSupportedError, RequestError};
 use crate::event_loop::{ActiveEventLoop, AsyncRequestSerial};
 #[cfg(wayland_platform)]
 use crate::platform::wayland::ActiveEventLoopExtWayland;
-use crate::window::{ActivationToken, Window};
+use crate::window::{ActivationToken, Window, WindowAttributes};

 /// The variable which is used mostly on X11.
 const X11_VAR: &str = "DESKTOP_STARTUP_ID";
@@ -75,12 +75,15 @@ impl EventLoopExtStartupNotify for dyn ActiveEventLoop + '_ {
 impl WindowExtStartupNotify for dyn Window + '_ {
    fn request_activation_token(&self) -> Result<AsyncRequestSerial, RequestError> {
        #[cfg(wayland_platform)]
-        if let Some(window) = self.cast_ref::<crate::platform_impl::wayland::Window>() {
+        if let Some(window) = self.as_any().downcast_ref::<crate::platform_impl::wayland::Window>()
+        {
            return window.request_activation_token();
        }

        #[cfg(x11_platform)]
-        if let Some(window) = self.cast_ref::<crate::platform_impl::x11::Window>() {
+        if let Some(window) =
+            self.as_any().downcast_ref::<crate::platform_impl::x11::window::Window>()
+        {
            return window.request_activation_token();
        }

@@ -88,24 +91,26 @@ impl WindowExtStartupNotify for dyn Window + '_ {
    }
 }

+impl WindowAttributesExtStartupNotify for WindowAttributes {
+    fn with_activation_token(mut self, token: ActivationToken) -> Self {
+        self.platform_specific.activation_token = Some(token);
+        self
+    }
+}
+
 /// Remove the activation environment variables from the current process.
 ///
 /// This is wise to do before running child processes,
 /// which may not to support the activation token.
 pub fn reset_activation_token_env() {
-    unsafe {
-        env::remove_var(X11_VAR);
-        env::remove_var(WAYLAND_VAR);
-    }
+    env::remove_var(X11_VAR);
+    env::remove_var(WAYLAND_VAR);
 }

 /// Set environment variables responsible for activation token.
 ///
 /// This could be used before running daemon processes.
 pub fn set_activation_token_env(token: ActivationToken) {
-    let token = token.into_raw();
-    unsafe {
-        env::set_var(X11_VAR, &token);
-        env::set_var(WAYLAND_VAR, token);
-    }
+    env::set_var(X11_VAR, &token.token);
+    env::set_var(WAYLAND_VAR, token.token);
 }
--- a/src/platform/wayland.rs
+++ b/src/platform/wayland.rs
@@ -0,0 +1,112 @@
+//! # 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 crate::event_loop::{ActiveEventLoop, EventLoop, EventLoopBuilder};
+use crate::monitor::MonitorHandle;
+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.as_any().downcast_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 {}
+
+impl WindowExtWayland for dyn CoreWindow + '_ {}
+
+/// 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
+    }
+}
+
+/// Additional methods on `MonitorHandle` that are specific to Wayland.
+pub trait MonitorHandleExtWayland {
+    /// Returns the inner identifier of the monitor.
+    fn native_id(&self) -> u32;
+}
+
+impl MonitorHandleExtWayland for MonitorHandle {
+    #[inline]
+    fn native_id(&self) -> u32 {
+        self.inner.native_identifier()
+    }
+}
--- a/winit-web/src/lib.rs
+++ b/winit-web/src/lib.rs
@@ -13,10 +13,10 @@
 //! yourself.
 //!
 //! [canvas]: https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement
-//! [with_canvas]: WindowAttributesWeb::with_canvas
+//! [with_canvas]: WindowAttributesExtWeb::with_canvas
 //! [get]: WindowExtWeb::canvas
-//! [insert]: WindowAttributesWeb::with_append
-//! [wasm_bindgen]: https://docs.rs/wasm-bindgen
+//! [insert]: WindowAttributesExtWeb::with_append
+#![cfg_attr(not(web_platform), doc = "[wasm_bindgen]: https://docs.rs/wasm-bindgen")]
 //! [Rust and WebAssembly book]: https://rustwasm.github.io/book
 //!
 //! ## CSS properties
@@ -41,67 +41,37 @@
 //! [`WindowEvent::PointerLeft`]: crate::event::WindowEvent::PointerLeft
 //! [`Window::set_outer_position()`]: crate::window::Window::set_outer_position

-// 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.
-
-macro_rules! os_error {
-    ($error:expr) => {{ winit_core::error::OsError::new(line!(), file!(), $error) }};
-}
-
-mod r#async;
-mod cursor;
-mod event;
-pub(crate) mod event_loop;
-mod lock;
-pub(crate) mod main_thread;
-mod monitor;
-pub(crate) mod web_sys;
-pub(crate) mod window;
-
 use std::cell::Ref;
 use std::error::Error;
 use std::fmt::{self, Display, Formatter};
 use std::future::Future;
 use std::pin::Pin;
-use std::sync::Arc;
 use std::task::{Context, Poll};
+use std::time::Duration;

-use ::web_sys::HtmlCanvasElement;
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
-use winit_core::cursor::{CustomCursor, CustomCursorSource};
-use winit_core::error::NotSupportedError;
-use winit_core::event_loop::ActiveEventLoop;
-use winit_core::monitor::MonitorHandleProvider;
-use winit_core::window::{PlatformWindowAttributes, Window};
+#[cfg(web_platform)]
+use web_sys::HtmlCanvasElement;

-pub use self::event_loop::{EventLoop, PlatformSpecificEventLoopAttributes};
-use self::web_sys as backend;
-use self::window::Window as WebWindow;
-use crate::cursor::CustomCursorFuture as PlatformCustomCursorFuture;
-use crate::event_loop::ActiveEventLoop as WebActiveEventLoop;
-use crate::main_thread::{MainThreadMarker, MainThreadSafe};
-use crate::monitor::{
+use crate::application::ApplicationHandler;
+use crate::cursor::CustomCursorSource;
+use crate::error::NotSupportedError;
+use crate::event_loop::{ActiveEventLoop, EventLoop};
+use crate::monitor::MonitorHandle;
+use crate::platform_impl::PlatformCustomCursorSource;
+#[cfg(web_platform)]
+use crate::platform_impl::{
+    CustomCursorFuture as PlatformCustomCursorFuture,
    HasMonitorPermissionFuture as PlatformHasMonitorPermissionFuture,
-    MonitorHandle as WebMonitorHandle, MonitorPermissionFuture as PlatformMonitorPermissionFuture,
+    MonitorPermissionFuture as PlatformMonitorPermissionFuture,
    OrientationLockFuture as PlatformOrientationLockFuture,
 };
+use crate::window::{CustomCursor, Window, WindowAttributes};
+
+#[cfg(not(web_platform))]
+#[doc(hidden)]
+pub struct HtmlCanvasElement;

 pub trait WindowExtWeb {
    /// Only returns the canvas if called from inside the window context (the
@@ -135,51 +105,43 @@ pub trait WindowExtWeb {
 impl WindowExtWeb for dyn Window + '_ {
    #[inline]
    fn canvas(&self) -> Option<Ref<'_, HtmlCanvasElement>> {
-        self.cast_ref::<WebWindow>().expect("non Web window on Web").canvas()
+        self.as_any()
+            .downcast_ref::<crate::platform_impl::Window>()
+            .expect("non Web window on Web")
+            .canvas()
    }

    fn prevent_default(&self) -> bool {
-        self.cast_ref::<WebWindow>().expect("non Web window on Web").prevent_default()
+        self.as_any()
+            .downcast_ref::<crate::platform_impl::Window>()
+            .expect("non Web window on Web")
+            .prevent_default()
    }

    fn set_prevent_default(&self, prevent_default: bool) {
-        self.cast_ref::<WebWindow>()
+        self.as_any()
+            .downcast_ref::<crate::platform_impl::Window>()
            .expect("non Web window on Web")
            .set_prevent_default(prevent_default)
    }

    fn is_cursor_lock_raw(&self) -> bool {
-        self.cast_ref::<WebWindow>().expect("non Web window on Web").is_cursor_lock_raw()
+        self.as_any()
+            .downcast_ref::<crate::platform_impl::Window>()
+            .expect("non Web window on Web")
+            .is_cursor_lock_raw()
    }
 }

-#[derive(Clone, Debug)]
-pub struct WindowAttributesWeb {
-    pub(crate) canvas: Option<Arc<MainThreadSafe<backend::RawCanvasType>>>,
-    pub(crate) prevent_default: bool,
-    pub(crate) focusable: bool,
-    pub(crate) append: bool,
-}
-
-impl WindowAttributesWeb {
+pub trait WindowAttributesExtWeb {
    /// Pass an [`HtmlCanvasElement`] to be used for this [`Window`]. If [`None`],
-    /// the default one will be created.
+    /// [`WindowAttributes::default()`] will create one.
    ///
    /// In any case, the canvas won't be automatically inserted into the Web page.
    ///
    /// [`None`] by default.
-    pub fn with_canvas(mut self, canvas: Option<HtmlCanvasElement>) -> Self {
-        match canvas {
-            Some(canvas) => {
-                let main_thread = MainThreadMarker::new()
-                    .expect("received a `HtmlCanvasElement` outside the window context");
-                self.canvas = Some(Arc::new(MainThreadSafe::new(main_thread, canvas)));
-            },
-            None => self.canvas = None,
-        }
-
-        self
-    }
+    #[cfg_attr(not(web_platform), doc = "", doc = "[`HtmlCanvasElement`]: #only-available-on-wasm")]
+    fn with_canvas(self, canvas: Option<HtmlCanvasElement>) -> Self;

    /// Sets whether `event.preventDefault()` should be called on events on the
    /// canvas that have side effects.
@@ -187,55 +149,68 @@ impl WindowAttributesWeb {
    /// See [`WindowExtWeb::set_prevent_default()`] for more details.
    ///
    /// Enabled by default.
-    pub fn with_prevent_default(mut self, prevent_default: bool) -> Self {
-        self.prevent_default = prevent_default;
-        self
-    }
+    fn with_prevent_default(self, prevent_default: bool) -> Self;

    /// Whether the canvas should be focusable using the tab key. This is necessary to capture
    /// canvas keyboard events.
    ///
    /// Enabled by default.
-    pub fn with_focusable(mut self, focusable: bool) -> Self {
-        self.focusable = focusable;
-        self
-    }
+    fn with_focusable(self, focusable: bool) -> Self;

    /// On window creation, append the canvas element to the Web page if it isn't already.
    ///
    /// Disabled by default.
-    pub fn with_append(mut self, append: bool) -> Self {
-        self.append = append;
+    fn with_append(self, append: bool) -> Self;
+}
+
+impl WindowAttributesExtWeb for WindowAttributes {
+    fn with_canvas(mut self, canvas: Option<HtmlCanvasElement>) -> Self {
+        self.platform_specific.set_canvas(canvas);
        self
    }
-}

-impl PlatformWindowAttributes for WindowAttributesWeb {
-    fn box_clone(&self) -> Box<dyn PlatformWindowAttributes> {
-        Box::from(self.clone())
+    fn with_prevent_default(mut self, prevent_default: bool) -> Self {
+        self.platform_specific.prevent_default = prevent_default;
+        self
    }
-}

-impl PartialEq for WindowAttributesWeb {
-    fn eq(&self, other: &Self) -> bool {
-        (match (&self.canvas, &other.canvas) {
-            (Some(this), Some(other)) => Arc::ptr_eq(this, other),
-            (None, None) => true,
-            _ => false,
-        }) && self.prevent_default.eq(&other.prevent_default)
-            && self.focusable.eq(&other.focusable)
-            && self.append.eq(&other.append)
+    fn with_focusable(mut self, focusable: bool) -> Self {
+        self.platform_specific.focusable = focusable;
+        self
    }
-}

-impl Default for WindowAttributesWeb {
-    fn default() -> Self {
-        Self { canvas: None, prevent_default: true, focusable: true, append: false }
+    fn with_append(mut self, append: bool) -> Self {
+        self.platform_specific.append = append;
+        self
    }
 }

 /// Additional methods on `EventLoop` that are specific to the Web.
 pub trait EventLoopExtWeb {
+    /// Initializes the winit event loop.
+    ///
+    /// Unlike
+    #[cfg_attr(all(web_platform, target_feature = "exception-handling"), doc = "`run_app()`")]
+    #[cfg_attr(
+        not(all(web_platform, target_feature = "exception-handling")),
+        doc = "[`run_app()`]"
+    )]
+    /// [^1], this returns immediately, and doesn't throw an exception in order to
+    /// satisfy its [`!`] return type.
+    ///
+    /// Once the event loop has been destroyed, it's possible to reinitialize another event loop
+    /// by calling this function again. This can be useful if you want to recreate the event loop
+    /// while the WebAssembly module is still loaded. For example, this can be used to recreate the
+    /// event loop when switching between tabs on a single page application.
+    #[rustfmt::skip]
+    ///
+    #[cfg_attr(
+        not(all(web_platform, target_feature = "exception-handling")),
+        doc = "[`run_app()`]: EventLoop::run_app()"
+    )]
+    /// [^1]: `run_app()` is _not_ available on Wasm when the target supports `exception-handling`.
+    fn spawn_app<A: ApplicationHandler + 'static>(self, app: A);
+
    /// Sets the strategy for [`ControlFlow::Poll`].
    ///
    /// See [`PollStrategy`].
@@ -278,21 +253,49 @@ pub trait EventLoopExtWeb {
    ///
    /// [`MonitorHandle`]s don't automatically make use of this after permission is granted. New
    /// [`MonitorHandle`]s have to be created instead.
-    ///
-    /// [`MonitorHandle`]: crate::monitor::MonitorHandle
    fn request_detailed_monitor_permission(&self) -> MonitorPermissionFuture;

    /// Returns whether the user has given permission to access detailed monitor information.
    ///
    /// [`MonitorHandle`]s don't automatically make use of detailed monitor information after
    /// permission is granted. New [`MonitorHandle`]s have to be created instead.
-    ///
-    /// [`MonitorHandle`]: crate::monitor::MonitorHandle
-    ///
-    /// [`MonitorHandle`]: crate::monitor::MonitorHandle
    fn has_detailed_monitor_permission(&self) -> HasMonitorPermissionFuture;
 }

+impl EventLoopExtWeb for EventLoop {
+    fn spawn_app<A: ApplicationHandler + 'static>(self, app: A) {
+        self.event_loop.spawn_app(app);
+    }
+
+    fn set_poll_strategy(&self, strategy: PollStrategy) {
+        self.event_loop.set_poll_strategy(strategy);
+    }
+
+    fn poll_strategy(&self) -> PollStrategy {
+        self.event_loop.poll_strategy()
+    }
+
+    fn set_wait_until_strategy(&self, strategy: WaitUntilStrategy) {
+        self.event_loop.set_wait_until_strategy(strategy);
+    }
+
+    fn wait_until_strategy(&self) -> WaitUntilStrategy {
+        self.event_loop.wait_until_strategy()
+    }
+
+    fn has_multiple_screens(&self) -> Result<bool, NotSupportedError> {
+        self.event_loop.has_multiple_screens()
+    }
+
+    fn request_detailed_monitor_permission(&self) -> MonitorPermissionFuture {
+        MonitorPermissionFuture(self.event_loop.request_detailed_monitor_permission())
+    }
+
+    fn has_detailed_monitor_permission(&self) -> HasMonitorPermissionFuture {
+        HasMonitorPermissionFuture(self.event_loop.has_detailed_monitor_permission())
+    }
+}
+
 pub trait ActiveEventLoopExtWeb {
    /// Sets the strategy for [`ControlFlow::Poll`].
    ///
@@ -345,71 +348,94 @@ pub trait ActiveEventLoopExtWeb {
    ///
    /// [`MonitorHandle`]s don't automatically make use of this after permission is granted. New
    /// [`MonitorHandle`]s have to be created instead.
-    ///
-    /// [`MonitorHandle`]: crate::monitor::MonitorHandle
    fn request_detailed_monitor_permission(&self) -> MonitorPermissionFuture;

    /// Returns whether the user has given permission to access detailed monitor information.
    ///
    /// [`MonitorHandle`]s don't automatically make use of detailed monitor information after
    /// permission is granted. New [`MonitorHandle`]s have to be created instead.
-    ///
-    /// [`MonitorHandle`]: crate::monitor::MonitorHandle
    fn has_detailed_monitor_permission(&self) -> bool;
 }

 impl ActiveEventLoopExtWeb for dyn ActiveEventLoop + '_ {
    #[inline]
    fn create_custom_cursor_async(&self, source: CustomCursorSource) -> CustomCursorFuture {
-        let event_loop = self.cast_ref::<WebActiveEventLoop>().expect("non Web event loop on Web");
+        let event_loop = self
+            .as_any()
+            .downcast_ref::<crate::platform_impl::ActiveEventLoop>()
+            .expect("non Web event loop on Web");
        event_loop.create_custom_cursor_async(source)
    }

    #[inline]
    fn set_poll_strategy(&self, strategy: PollStrategy) {
-        let event_loop = self.cast_ref::<WebActiveEventLoop>().expect("non Web event loop on Web");
+        let event_loop = self
+            .as_any()
+            .downcast_ref::<crate::platform_impl::ActiveEventLoop>()
+            .expect("non Web event loop on Web");
        event_loop.set_poll_strategy(strategy);
    }

    #[inline]
    fn poll_strategy(&self) -> PollStrategy {
-        let event_loop = self.cast_ref::<WebActiveEventLoop>().expect("non Web event loop on Web");
+        let event_loop = self
+            .as_any()
+            .downcast_ref::<crate::platform_impl::ActiveEventLoop>()
+            .expect("non Web event loop on Web");
        event_loop.poll_strategy()
    }

    #[inline]
    fn set_wait_until_strategy(&self, strategy: WaitUntilStrategy) {
-        let event_loop = self.cast_ref::<WebActiveEventLoop>().expect("non Web event loop on Web");
+        let event_loop = self
+            .as_any()
+            .downcast_ref::<crate::platform_impl::ActiveEventLoop>()
+            .expect("non Web event loop on Web");
        event_loop.set_wait_until_strategy(strategy);
    }

    #[inline]
    fn wait_until_strategy(&self) -> WaitUntilStrategy {
-        let event_loop = self.cast_ref::<WebActiveEventLoop>().expect("non Web event loop on Web");
+        let event_loop = self
+            .as_any()
+            .downcast_ref::<crate::platform_impl::ActiveEventLoop>()
+            .expect("non Web event loop on Web");
        event_loop.wait_until_strategy()
    }

    #[inline]
    fn is_cursor_lock_raw(&self) -> bool {
-        let event_loop = self.cast_ref::<WebActiveEventLoop>().expect("non Web event loop on Web");
+        let event_loop = self
+            .as_any()
+            .downcast_ref::<crate::platform_impl::ActiveEventLoop>()
+            .expect("non Web event loop on Web");
        event_loop.is_cursor_lock_raw()
    }

    #[inline]
    fn has_multiple_screens(&self) -> Result<bool, NotSupportedError> {
-        let event_loop = self.cast_ref::<WebActiveEventLoop>().expect("non Web event loop on Web");
+        let event_loop = self
+            .as_any()
+            .downcast_ref::<crate::platform_impl::ActiveEventLoop>()
+            .expect("non Web event loop on Web");
        event_loop.has_multiple_screens()
    }

    #[inline]
    fn request_detailed_monitor_permission(&self) -> MonitorPermissionFuture {
-        let event_loop = self.cast_ref::<WebActiveEventLoop>().expect("non Web event loop on Web");
+        let event_loop = self
+            .as_any()
+            .downcast_ref::<crate::platform_impl::ActiveEventLoop>()
+            .expect("non Web event loop on Web");
        MonitorPermissionFuture(event_loop.request_detailed_monitor_permission())
    }

    #[inline]
    fn has_detailed_monitor_permission(&self) -> bool {
-        let event_loop = self.cast_ref::<WebActiveEventLoop>().expect("non Web event loop on Web");
+        let event_loop = self
+            .as_any()
+            .downcast_ref::<crate::platform_impl::ActiveEventLoop>()
+            .expect("non Web event loop on Web");
        event_loop.has_detailed_monitor_permission()
    }
 }
@@ -465,6 +491,76 @@ pub enum WaitUntilStrategy {
    Worker,
 }

+pub trait CustomCursorExtWeb {
+    /// Returns if this cursor is an animation.
+    fn is_animation(&self) -> bool;
+
+    /// Creates a new cursor from a URL pointing to an image.
+    /// It uses the [url css function](https://developer.mozilla.org/en-US/docs/Web/CSS/url),
+    /// but browser support for image formats is inconsistent. Using [PNG] is recommended.
+    ///
+    /// [PNG]: https://en.wikipedia.org/wiki/PNG
+    fn from_url(url: String, hotspot_x: u16, hotspot_y: u16) -> CustomCursorSource;
+
+    /// Crates a new animated cursor from multiple [`CustomCursor`]s.
+    /// Supplied `cursors` can't be empty or other animations.
+    fn from_animation(
+        duration: Duration,
+        cursors: Vec<CustomCursor>,
+    ) -> Result<CustomCursorSource, BadAnimation>;
+}
+
+impl CustomCursorExtWeb for CustomCursor {
+    fn is_animation(&self) -> bool {
+        self.inner.animation
+    }
+
+    fn from_url(url: String, hotspot_x: u16, hotspot_y: u16) -> CustomCursorSource {
+        CustomCursorSource { inner: PlatformCustomCursorSource::Url { url, hotspot_x, hotspot_y } }
+    }
+
+    fn from_animation(
+        duration: Duration,
+        cursors: Vec<CustomCursor>,
+    ) -> Result<CustomCursorSource, BadAnimation> {
+        if cursors.is_empty() {
+            return Err(BadAnimation::Empty);
+        }
+
+        if cursors.iter().any(CustomCursor::is_animation) {
+            return Err(BadAnimation::Animation);
+        }
+
+        Ok(CustomCursorSource {
+            inner: PlatformCustomCursorSource::Animation { duration, cursors },
+        })
+    }
+}
+
+/// An error produced when using [`CustomCursor::from_animation`] with invalid arguments.
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub enum BadAnimation {
+    /// Produced when no cursors were supplied.
+    Empty,
+    /// Produced when a supplied cursor is an animation.
+    Animation,
+}
+
+impl fmt::Display for BadAnimation {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Empty => write!(f, "No cursors supplied"),
+            Self::Animation => write!(f, "A supplied cursor is an animation"),
+        }
+    }
+}
+
+impl Error for BadAnimation {}
+
+#[cfg(not(web_platform))]
+struct PlatformCustomCursorFuture;
+
 #[derive(Debug)]
 pub struct CustomCursorFuture(pub(crate) PlatformCustomCursorFuture);

@@ -472,7 +568,7 @@ impl Future for CustomCursorFuture {
    type Output = Result<CustomCursor, CustomCursorError>;

    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        Pin::new(&mut self.0).poll(cx).map_ok(|cursor| CustomCursor(Arc::new(cursor)))
+        Pin::new(&mut self.0).poll(cx).map_ok(|cursor| CustomCursor { inner: cursor })
    }
 }

@@ -494,6 +590,9 @@ impl Display for CustomCursorError {

 impl Error for CustomCursorError {}

+#[cfg(not(web_platform))]
+struct PlatformMonitorPermissionFuture;
+
 /// Can be dropped without aborting the request for detailed monitor permissions.
 #[derive(Debug)]
 pub struct MonitorPermissionFuture(pub(crate) PlatformMonitorPermissionFuture);
@@ -536,6 +635,9 @@ impl Display for MonitorPermissionError {

 impl Error for MonitorPermissionError {}

+#[cfg(not(web_platform))]
+struct PlatformHasMonitorPermissionFuture;
+
 #[derive(Debug)]
 pub struct HasMonitorPermissionFuture(PlatformHasMonitorPermissionFuture);

@@ -548,8 +650,6 @@ impl Future for HasMonitorPermissionFuture {
 }

 /// Additional methods on [`MonitorHandle`] that are specific to the Web.
-///
-/// [`MonitorHandle`]: crate::monitor::MonitorHandle
 pub trait MonitorHandleExtWeb {
    /// Returns whether the screen is internal to the device or external.
    ///
@@ -577,31 +677,28 @@ pub trait MonitorHandleExtWeb {
    /// specific monitor.
    ///
    /// See [`ActiveEventLoopExtWeb::request_detailed_monitor_permission()`].
-    ///
-    /// [`MonitorHandle`]: crate::monitor::MonitorHandle
    fn is_detailed(&self) -> bool;
 }

-impl MonitorHandleExtWeb for dyn MonitorHandleProvider + '_ {
+impl MonitorHandleExtWeb for MonitorHandle {
    fn is_internal(&self) -> Option<bool> {
-        self.cast_ref::<WebMonitorHandle>().unwrap().is_internal()
+        self.inner.is_internal()
    }

    fn orientation(&self) -> OrientationData {
-        self.cast_ref::<WebMonitorHandle>().unwrap().orientation()
+        self.inner.orientation()
    }

    fn request_lock(&self, orientation_lock: OrientationLock) -> OrientationLockFuture {
-        let future = self.cast_ref::<WebMonitorHandle>().unwrap().request_lock(orientation_lock);
-        OrientationLockFuture(future)
+        OrientationLockFuture(self.inner.request_lock(orientation_lock))
    }

    fn unlock(&self) -> Result<(), OrientationLockError> {
-        self.cast_ref::<WebMonitorHandle>().unwrap().unlock()
+        self.inner.unlock()
    }

    fn is_detailed(&self) -> bool {
-        self.cast_ref::<WebMonitorHandle>().unwrap().is_detailed()
+        self.inner.is_detailed()
    }
 }

@@ -626,7 +723,7 @@ pub enum Orientation {
    Portrait,
 }

-/// Screen orientation lock options. Represents which orientations a user can use.
+/// Screen orientation lock options. Reoresents which orientations a user can use.
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
 pub enum OrientationLock {
    /// User is free to use any orientation.
@@ -651,6 +748,9 @@ pub enum OrientationLock {
    },
 }

+#[cfg(not(web_platform))]
+struct PlatformOrientationLockFuture;
+
 /// Can be dropped without aborting the request to lock the screen.
 #[derive(Debug)]
 pub struct OrientationLockFuture(PlatformOrientationLockFuture);
--- a/src/platform/windows.rs
+++ b/src/platform/windows.rs
@@ -1,44 +1,22 @@
-//! # Winit Win32 / Windows backend
+//! # Windows
 //!
 //! The supported OS version is Windows 7 or higher, though Windows 10 is
 //! tested regularly.
-#![cfg(target_os = "windows")] // FIXME(madsmtm): Allow compiling on all platforms.
-
-#[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;
-mod raw_input;
-mod window;
-mod window_state;
-
 use std::borrow::Borrow;
 use std::ffi::c_void;
 use std::ops::Deref;
 use std::path::Path;
-use std::sync::Arc;

-use ::dpi::PhysicalSize;
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
+#[cfg(windows_platform)]
 use windows_sys::Win32::Foundation::HANDLE;
-use winit_core::event::DeviceId;
-use winit_core::icon::{BadIcon, Icon};
-use winit_core::window::{PlatformWindowAttributes, Window as CoreWindow};

-pub use self::event_loop::{EventLoop, PlatformSpecificEventLoopAttributes};
-use self::icon::{RaiiIcon, SelectedCursor};
-pub use self::keyboard::{physicalkey_to_scancode, scancode_to_physicalkey};
-pub use self::monitor::{MonitorHandle, VideoModeHandle};
-pub use self::window::Window;
+use crate::dpi::PhysicalSize;
+use crate::event::DeviceId;
+use crate::event_loop::EventLoopBuilder;
+use crate::monitor::MonitorHandle;
+use crate::window::{BadIcon, Icon, Window, WindowAttributes};

 /// Window Handle type used by Win32 API
 pub type HWND = *mut c_void;
@@ -140,24 +118,24 @@ pub enum CornerPreference {
 ///
 /// See [`WindowBorrowExtWindows::any_thread`] for more information.
 #[derive(Clone, Debug)]
-pub struct AnyThread<W: CoreWindow>(W);
+pub struct AnyThread<W: Window>(W);

-impl<W: CoreWindow> AnyThread<W> {
+impl<W: Window> AnyThread<W> {
    /// Get a reference to the inner window.
    #[inline]
-    pub fn get_ref(&self) -> &dyn CoreWindow {
+    pub fn get_ref(&self) -> &dyn Window {
        &self.0
    }
 }

-impl<W: CoreWindow> Deref for AnyThread<W> {
+impl<W: Window> Deref for AnyThread<W> {
    type Target = W;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
 }

-impl<W: CoreWindow> rwh_06::HasWindowHandle for AnyThread<W> {
+impl<W: Window> rwh_06::HasWindowHandle for AnyThread<W> {
    fn window_handle(&self) -> Result<rwh_06::WindowHandle<'_>, rwh_06::HandleError> {
        // SAFETY: The top level user has asserted this is only used safely.
        unsafe { self.get_ref().window_handle_any_thread() }
@@ -232,13 +210,36 @@ pub trait EventLoopBuilderExtWindows {
        F: FnMut(*const c_void) -> bool + 'static;
 }

+impl EventLoopBuilderExtWindows for EventLoopBuilder {
+    #[inline]
+    fn with_any_thread(&mut self, any_thread: bool) -> &mut Self {
+        self.platform_specific.any_thread = any_thread;
+        self
+    }
+
+    #[inline]
+    fn with_dpi_aware(&mut self, dpi_aware: bool) -> &mut Self {
+        self.platform_specific.dpi_aware = dpi_aware;
+        self
+    }
+
+    #[inline]
+    fn with_msg_hook<F>(&mut self, callback: F) -> &mut Self
+    where
+        F: FnMut(*const c_void) -> bool + 'static,
+    {
+        self.platform_specific.msg_hook = Some(Box::new(callback));
+        self
+    }
+}
+
 /// Additional methods on `Window` that are specific to Windows.
 pub trait WindowExtWindows {
    /// Enables or disables mouse and keyboard input to the specified window.
    ///
    /// A window must be enabled before it can be activated.
    /// If an application has create a modal dialog box by disabling its owner window
-    /// (as described in [`WindowAttributesWindows::with_owner_window`]), the application must
+    /// (as described in [`WindowAttributesExtWindows::with_owner_window`]), the application must
    /// enable the owner window before destroying the dialog box.
    /// Otherwise, another window will receive the keyboard focus and be activated.
    ///
@@ -285,15 +286,6 @@ pub trait WindowExtWindows {
    /// Supported starting with Windows 11 Build 22000.
    fn set_corner_preference(&self, preference: CornerPreference);

-    /// Sets if the reported [`winit_core::event::WindowEvent::MouseWheel`] event
-    /// should account for scroll speed system settings.
-    ///
-    /// The default scroll speed on Windows is 3 lines/characters per scroll,
-    /// this will be 1 if you set it to false.
-    ///
-    /// The default is `true`.
-    fn set_use_system_scroll_speed(&self, should_use: bool);
-
    /// Get the raw window handle for this [`Window`] without checking for thread affinity.
    ///
    /// Window handles in Win32 have a property called "thread affinity" that ties them to their
@@ -349,40 +341,40 @@ pub trait WindowExtWindows {
    ) -> Result<rwh_06::WindowHandle<'_>, rwh_06::HandleError>;
 }

-impl WindowExtWindows for dyn CoreWindow + '_ {
+impl WindowExtWindows for dyn Window + '_ {
    #[inline]
    fn set_enable(&self, enabled: bool) {
-        let window = self.cast_ref::<Window>().unwrap();
+        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
        window.set_enable(enabled)
    }

    #[inline]
    fn set_taskbar_icon(&self, taskbar_icon: Option<Icon>) {
-        let window = self.cast_ref::<Window>().unwrap();
+        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
        window.set_taskbar_icon(taskbar_icon)
    }

    #[inline]
    fn set_skip_taskbar(&self, skip: bool) {
-        let window = self.cast_ref::<Window>().unwrap();
+        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
        window.set_skip_taskbar(skip)
    }

    #[inline]
    fn set_undecorated_shadow(&self, shadow: bool) {
-        let window = self.cast_ref::<Window>().unwrap();
+        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
        window.set_undecorated_shadow(shadow)
    }

    #[inline]
    fn set_system_backdrop(&self, backdrop_type: BackdropType) {
-        let window = self.cast_ref::<Window>().unwrap();
+        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
        window.set_system_backdrop(backdrop_type)
    }

    #[inline]
    fn set_border_color(&self, color: Option<Color>) {
-        let window = self.cast_ref::<Window>().unwrap();
+        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
        window.set_border_color(color.unwrap_or(Color::NONE))
    }

@@ -391,31 +383,26 @@ impl WindowExtWindows for dyn CoreWindow + '_ {
        // The windows docs don't mention NONE as a valid options but it works in practice and is
        // useful to circumvent the Windows option "Show accent color on title bars and
        // window borders"
-        let window = self.cast_ref::<Window>().unwrap();
+        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
        window.set_title_background_color(color.unwrap_or(Color::NONE))
    }

    #[inline]
    fn set_title_text_color(&self, color: Color) {
-        let window = self.cast_ref::<Window>().unwrap();
+        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
        window.set_title_text_color(color)
    }

    #[inline]
    fn set_corner_preference(&self, preference: CornerPreference) {
-        let window = self.cast_ref::<Window>().unwrap();
+        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
        window.set_corner_preference(preference)
    }

-    fn set_use_system_scroll_speed(&self, should_use: bool) {
-        let window = self.cast_ref::<Window>().unwrap();
-        window.set_use_system_scroll_speed(should_use)
-    }
-
    unsafe fn window_handle_any_thread(
        &self,
    ) -> Result<rwh_06::WindowHandle<'_>, rwh_06::HandleError> {
-        let window = self.cast_ref::<Window>().unwrap();
+        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
        unsafe {
            let handle = window.rwh_06_no_thread_check()?;

@@ -428,7 +415,7 @@ impl WindowExtWindows for dyn CoreWindow + '_ {
 /// Additional methods for anything that dereference to [`Window`].
 ///
 /// [`Window`]: crate::window::Window
-pub trait WindowBorrowExtWindows: Borrow<dyn CoreWindow> + Sized {
+pub trait WindowBorrowExtWindows: Borrow<dyn Window> + Sized {
    /// Create an object that allows accessing the inner window handle in a thread-unsafe way.
    ///
    /// It is possible to call [`window_handle_any_thread`] to get around Windows's thread
@@ -449,59 +436,17 @@ pub trait WindowBorrowExtWindows: Borrow<dyn CoreWindow> + Sized {
    /// [`window_handle_any_thread`]: WindowExtWindows::window_handle_any_thread
    unsafe fn any_thread(self) -> AnyThread<Self>
    where
-        Self: CoreWindow,
+        Self: Window,
    {
        AnyThread(self)
    }
 }

-impl<W: Borrow<dyn CoreWindow> + Sized> WindowBorrowExtWindows for W {}
+impl<W: Borrow<dyn Window> + Sized> WindowBorrowExtWindows for W {}

-#[derive(Clone, Debug)]
-pub struct WindowAttributesWindows {
-    pub(crate) owner: Option<HWND>,
-    pub(crate) menu: Option<HMENU>,
-    pub(crate) taskbar_icon: Option<Icon>,
-    pub(crate) no_redirection_bitmap: bool,
-    pub(crate) drag_and_drop: bool,
-    pub(crate) skip_taskbar: bool,
-    pub(crate) class_name: String,
-    pub(crate) decoration_shadow: bool,
-    pub(crate) backdrop_type: BackdropType,
-    pub(crate) clip_children: bool,
-    pub(crate) border_color: Option<Color>,
-    pub(crate) title_background_color: Option<Color>,
-    pub(crate) title_text_color: Option<Color>,
-    pub(crate) corner_preference: Option<CornerPreference>,
-    pub(crate) use_system_wheel_speed: bool,
-}
-
-impl Default for WindowAttributesWindows {
-    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,
-            use_system_wheel_speed: true,
-        }
-    }
-}
-
-unsafe impl Send for WindowAttributesWindows {}
-unsafe impl Sync for WindowAttributesWindows {}
-
-impl WindowAttributesWindows {
+/// Additional methods on `WindowAttributes` that are specific to Windows.
+#[allow(rustdoc::broken_intra_doc_links)]
+pub trait WindowAttributesExtWindows {
    /// Set an owner to the window to be created. Can be used to create a dialog box, for example.
    /// This only works when [`WindowAttributes::with_parent_window`] isn't called or set to `None`.
    /// Can be used in combination with
@@ -514,12 +459,7 @@ impl WindowAttributesWindows {
    /// - An owned window is hidden when its owner is minimized.
    ///
    /// For more information, see <https://docs.microsoft.com/en-us/windows/win32/winmsg/window-features#owned-windows>
-    ///
-    /// [`WindowAttributes::with_parent_window`]: winit_core::window::WindowAttributes::with_parent_window
-    pub fn with_owner_window(mut self, parent: HWND) -> Self {
-        self.owner = Some(parent);
-        self
-    }
+    fn with_owner_window(self, parent: HWND) -> Self;

    /// Sets a menu on the window to be created.
    ///
@@ -530,24 +470,18 @@ impl WindowAttributesWindows {
    /// Note: Dark mode cannot be supported for win32 menus, it's simply not possible to change how
    /// the menus look. If you use this, it is recommended that you combine it with
    /// `with_theme(Some(Theme::Light))` to avoid a jarring effect.
-    ///
-    /// [`CreateMenu`]: windows_sys::Win32::UI::WindowsAndMessaging::CreateMenu"
-    pub fn with_menu(mut self, menu: HMENU) -> Self {
-        self.menu = Some(menu);
-        self
-    }
+    #[cfg_attr(
+        windows_platform,
+        doc = "[`CreateMenu`]: windows_sys::Win32::UI::WindowsAndMessaging::CreateMenu"
+    )]
+    #[cfg_attr(not(windows_platform), doc = "[`CreateMenu`]: #only-available-on-windows")]
+    fn with_menu(self, menu: HMENU) -> Self;

    /// This sets `ICON_BIG`. A good ceiling here is 256x256.
-    pub fn with_taskbar_icon(mut self, taskbar_icon: Option<Icon>) -> Self {
-        self.taskbar_icon = taskbar_icon;
-        self
-    }
+    fn with_taskbar_icon(self, taskbar_icon: Option<Icon>) -> Self;

    /// This sets `WS_EX_NOREDIRECTIONBITMAP`.
-    pub fn with_no_redirection_bitmap(mut self, flag: bool) -> Self {
-        self.no_redirection_bitmap = flag;
-        self
-    }
+    fn with_no_redirection_bitmap(self, flag: bool) -> Self;

    /// Enables or disables drag and drop support (enabled by default). Will interfere with other
    /// crates that use multi-threaded COM API (`CoInitializeEx` with `COINIT_MULTITHREADED`
@@ -555,94 +489,153 @@ impl WindowAttributesWindows {
    /// attempt to initialize COM API regardless of this option. Currently only fullscreen mode
    /// does that, but there may be more in the future. If you need COM API with
    /// `COINIT_MULTITHREADED` you must initialize it before calling any winit functions. See <https://docs.microsoft.com/en-us/windows/win32/api/objbase/nf-objbase-coinitialize#remarks> for more information.
-    pub fn with_drag_and_drop(mut self, flag: bool) -> Self {
-        self.drag_and_drop = flag;
-        self
-    }
+    fn with_drag_and_drop(self, flag: bool) -> Self;

    /// Whether show or hide the window icon in the taskbar.
-    pub fn with_skip_taskbar(mut self, skip: bool) -> Self {
-        self.skip_taskbar = skip;
-        self
-    }
+    fn with_skip_taskbar(self, skip: bool) -> Self;

    /// Customize the window class name.
-    pub fn with_class_name<S: Into<String>>(mut self, class_name: S) -> Self {
-        self.class_name = class_name.into();
-        self
-    }
+    fn with_class_name<S: Into<String>>(self, class_name: S) -> Self;

    /// Shows or hides the background drop shadow for undecorated windows.
    ///
    /// The shadow is hidden by default.
    /// Enabling the shadow causes a thin 1px line to appear on the top of the window.
-    pub fn with_undecorated_shadow(mut self, shadow: bool) -> Self {
-        self.decoration_shadow = shadow;
-        self
-    }
+    fn with_undecorated_shadow(self, shadow: bool) -> Self;

    /// Sets system-drawn backdrop type.
    ///
    /// Requires Windows 11 build 22523+.
-    pub fn with_system_backdrop(mut self, backdrop_type: BackdropType) -> Self {
-        self.backdrop_type = backdrop_type;
-        self
-    }
+    fn with_system_backdrop(self, backdrop_type: BackdropType) -> Self;

    /// This sets or removes `WS_CLIPCHILDREN` style.
-    pub fn with_clip_children(mut self, flag: bool) -> Self {
-        self.clip_children = flag;
-        self
-    }
+    fn with_clip_children(self, flag: bool) -> Self;

    /// Sets the color of the window border.
    ///
    /// Supported starting with Windows 11 Build 22000.
-    pub fn with_border_color(mut self, color: Option<Color>) -> Self {
-        self.border_color = Some(color.unwrap_or(Color::NONE));
-        self
-    }
+    fn with_border_color(self, color: Option<Color>) -> Self;

    /// Sets the background color of the title bar.
    ///
    /// Supported starting with Windows 11 Build 22000.
-    pub fn with_title_background_color(mut self, color: Option<Color>) -> Self {
-        self.title_background_color = Some(color.unwrap_or(Color::NONE));
-        self
-    }
+    fn with_title_background_color(self, color: Option<Color>) -> Self;

    /// Sets the color of the window title.
    ///
    /// Supported starting with Windows 11 Build 22000.
-    pub fn with_title_text_color(mut self, color: Color) -> Self {
-        self.title_text_color = Some(color);
-        self
-    }
+    fn with_title_text_color(self, color: Color) -> Self;

    /// Sets the preferred style of the window corners.
    ///
    /// Supported starting with Windows 11 Build 22000.
-    pub fn with_corner_preference(mut self, corners: CornerPreference) -> Self {
-        self.corner_preference = Some(corners);
+    fn with_corner_preference(self, corners: CornerPreference) -> Self;
+}
+
+impl WindowAttributesExtWindows for WindowAttributes {
+    #[inline]
+    fn with_owner_window(mut self, parent: HWND) -> Self {
+        self.platform_specific.owner = Some(parent);
        self
    }

-    /// Sets if the reported [`winit_core::event::WindowEvent::MouseWheel`] event
-    /// should account for scroll speed system settings.
-    ///
-    /// The default scroll speed on Windows is 3 lines/characters per scroll,
-    /// this will be 1 if you set it to false.
-    ///
-    /// The default is `true`.
-    pub fn with_use_system_scroll_speed(mut self, should_use: bool) -> Self {
-        self.use_system_wheel_speed = should_use;
+    #[inline]
+    fn with_menu(mut self, menu: HMENU) -> Self {
+        self.platform_specific.menu = Some(menu);
+        self
+    }
+
+    #[inline]
+    fn with_taskbar_icon(mut self, taskbar_icon: Option<Icon>) -> Self {
+        self.platform_specific.taskbar_icon = taskbar_icon;
+        self
+    }
+
+    #[inline]
+    fn with_no_redirection_bitmap(mut self, flag: bool) -> Self {
+        self.platform_specific.no_redirection_bitmap = flag;
+        self
+    }
+
+    #[inline]
+    fn with_drag_and_drop(mut self, flag: bool) -> Self {
+        self.platform_specific.drag_and_drop = flag;
+        self
+    }
+
+    #[inline]
+    fn with_skip_taskbar(mut self, skip: bool) -> Self {
+        self.platform_specific.skip_taskbar = skip;
+        self
+    }
+
+    #[inline]
+    fn with_class_name<S: Into<String>>(mut self, class_name: S) -> Self {
+        self.platform_specific.class_name = class_name.into();
+        self
+    }
+
+    #[inline]
+    fn with_undecorated_shadow(mut self, shadow: bool) -> Self {
+        self.platform_specific.decoration_shadow = shadow;
+        self
+    }
+
+    #[inline]
+    fn with_system_backdrop(mut self, backdrop_type: BackdropType) -> Self {
+        self.platform_specific.backdrop_type = backdrop_type;
+        self
+    }
+
+    #[inline]
+    fn with_clip_children(mut self, flag: bool) -> Self {
+        self.platform_specific.clip_children = flag;
+        self
+    }
+
+    #[inline]
+    fn with_border_color(mut self, color: Option<Color>) -> Self {
+        self.platform_specific.border_color = Some(color.unwrap_or(Color::NONE));
+        self
+    }
+
+    #[inline]
+    fn with_title_background_color(mut self, color: Option<Color>) -> Self {
+        self.platform_specific.title_background_color = Some(color.unwrap_or(Color::NONE));
+        self
+    }
+
+    #[inline]
+    fn with_title_text_color(mut self, color: Color) -> Self {
+        self.platform_specific.title_text_color = Some(color);
+        self
+    }
+
+    #[inline]
+    fn with_corner_preference(mut self, corners: CornerPreference) -> Self {
+        self.platform_specific.corner_preference = Some(corners);
        self
    }
 }

-impl PlatformWindowAttributes for WindowAttributesWindows {
-    fn box_clone(&self) -> Box<dyn PlatformWindowAttributes> {
-        Box::from(self.clone())
+/// Additional methods on `MonitorHandle` that are specific to Windows.
+pub trait MonitorHandleExtWindows {
+    /// Returns the name of the monitor adapter specific to the Win32 API.
+    fn native_id(&self) -> String;
+
+    /// Returns the handle of the monitor - `HMONITOR`.
+    fn hmonitor(&self) -> HMONITOR;
+}
+
+impl MonitorHandleExtWindows for MonitorHandle {
+    #[inline]
+    fn native_id(&self) -> String {
+        self.inner.native_identifier()
+    }
+
+    #[inline]
+    fn hmonitor(&self) -> HMONITOR {
+        self.inner.hmonitor()
    }
 }

@@ -654,14 +647,19 @@ pub trait DeviceIdExtWindows {
    fn persistent_identifier(&self) -> Option<String>;
 }

+#[cfg(windows_platform)]
 impl DeviceIdExtWindows for DeviceId {
    fn persistent_identifier(&self) -> Option<String> {
        let raw_id = self.into_raw();
-        if raw_id != 0 { raw_input::get_raw_input_device_name(raw_id as HANDLE) } else { None }
+        if raw_id != 0 {
+            crate::platform_impl::raw_input::get_raw_input_device_name(raw_id as HANDLE)
+        } else {
+            None
+        }
    }
 }

-/// Windows specific `Icon`.
+/// Additional methods on `Icon` that are specific to Windows.
 ///
 /// Windows icons can be created from files, or from the [`embedded resources`](https://learn.microsoft.com/en-us/windows/win32/menurc/about-resource-files).
 ///
@@ -673,12 +671,7 @@ impl DeviceIdExtWindows for DeviceId {
 /// `filename` is the name of the file that contains the resource.
 ///
 /// More information about the `ICON` resource can be found at [`Microsoft Learn`](https://learn.microsoft.com/en-us/windows/win32/menurc/icon-resource) portal.
-#[derive(Clone, PartialEq, Eq, Hash)]
-pub struct WinIcon {
-    pub(crate) inner: Arc<RaiiIcon>,
-}
-
-impl WinIcon {
+pub trait IconExtWindows: Sized {
    /// Create an icon from a file path.
    ///
    /// Specify `size` to load a specific icon size from the file, or `None` to load the default
@@ -686,31 +679,22 @@ impl WinIcon {
    ///
    /// In cases where the specified size does not exist in the file, Windows may perform scaling
    /// to get an icon of the desired size.
-    pub fn from_path<P: AsRef<Path>>(
-        path: P,
-        size: Option<PhysicalSize<u32>>,
-    ) -> Result<Self, BadIcon> {
-        Self::from_path_impl(path, size)
-    }
+    fn from_path<P: AsRef<Path>>(path: P, size: Option<PhysicalSize<u32>>)
+        -> Result<Self, BadIcon>;

    /// Create an icon from a resource embedded in this executable or library by its ordinal id.
    ///
    /// The valid `ordinal` values range from 1 to [`u16::MAX`] (inclusive). The value `0` is an
    /// invalid ordinal id, but it can be used with [`from_resource_name`] as `"0"`.
    ///
-    /// [`from_resource_name`]: Self::from_resource_name
+    /// [`from_resource_name`]: IconExtWindows::from_resource_name
    ///
    /// Specify `size` to load a specific icon size from the file, or `None` to load the default
    /// icon size from the file.
    ///
    /// In cases where the specified size does not exist in the file, Windows may perform scaling
    /// to get an icon of the desired size.
-    pub fn from_resource(
-        resource_id: u16,
-        size: Option<PhysicalSize<u32>>,
-    ) -> Result<Self, BadIcon> {
-        Self::from_resource_impl(resource_id, size)
-    }
+    fn from_resource(ordinal: u16, size: Option<PhysicalSize<u32>>) -> Result<Self, BadIcon>;

    /// Create an icon from a resource embedded in this executable or library by its name.
    ///
@@ -735,16 +719,17 @@ impl WinIcon {
    /// `"002"`, etc.) cannot be used as valid resource names, and instead should be passed into
    /// [`from_resource`]:
    ///
-    /// [`from_resource`]: Self::from_resource
+    /// [`from_resource`]: IconExtWindows::from_resource
    ///
    /// ```rust,no_run
-    /// use winit::platform::windows::WinIcon;
+    /// use winit::platform::windows::IconExtWindows;
+    /// use winit::window::Icon;
    ///
-    /// assert!(WinIcon::from_resource_name("app", None).is_ok());
-    /// assert!(WinIcon::from_resource(1, None).is_ok());
-    /// assert!(WinIcon::from_resource(27, None).is_ok());
-    /// assert!(WinIcon::from_resource_name("27", None).is_err());
-    /// assert!(WinIcon::from_resource_name("0027", None).is_err());
+    /// assert!(Icon::from_resource_name("app", None).is_ok());
+    /// assert!(Icon::from_resource(1, None).is_ok());
+    /// assert!(Icon::from_resource(27, None).is_ok());
+    /// assert!(Icon::from_resource_name("27", None).is_err());
+    /// assert!(Icon::from_resource_name("0027", None).is_err());
    /// ```
    ///
    /// While `0` cannot be used as an ordinal id (see [`from_resource`]), it can be used as a
@@ -753,21 +738,30 @@ impl WinIcon {
    /// [`from_resource`]: IconExtWindows::from_resource
    ///
    /// ```rust,no_run
-    /// # use winit::platform::windows::WinIcon;
-    /// # use winit::icon::Icon;
-    /// assert!(WinIcon::from_resource_name("0", None).is_ok());
-    /// assert!(WinIcon::from_resource(0, None).is_err());
+    /// # use winit::platform::windows::IconExtWindows;
+    /// # use winit::window::Icon;
+    /// assert!(Icon::from_resource_name("0", None).is_ok());
+    /// assert!(Icon::from_resource(0, None).is_err());
    /// ```
-    pub fn from_resource_name(
-        resource_name: &str,
-        size: Option<PhysicalSize<u32>>,
-    ) -> Result<Self, BadIcon> {
-        Self::from_resource_name_impl(resource_name, size)
-    }
+    fn from_resource_name(name: &str, size: Option<PhysicalSize<u32>>) -> Result<Self, BadIcon>;
 }

-impl From<WinIcon> for Icon {
-    fn from(value: WinIcon) -> Self {
-        Self(Arc::new(value))
+impl IconExtWindows for Icon {
+    fn from_path<P: AsRef<Path>>(
+        path: P,
+        size: Option<PhysicalSize<u32>>,
+    ) -> Result<Self, BadIcon> {
+        let win_icon = crate::platform_impl::WinIcon::from_path(path, size)?;
+        Ok(Icon { inner: win_icon })
+    }
+
+    fn from_resource(ordinal: u16, size: Option<PhysicalSize<u32>>) -> Result<Self, BadIcon> {
+        let win_icon = crate::platform_impl::WinIcon::from_resource(ordinal, size)?;
+        Ok(Icon { inner: win_icon })
+    }
+
+    fn from_resource_name(name: &str, size: Option<PhysicalSize<u32>>) -> Result<Self, BadIcon> {
+        let win_icon = crate::platform_impl::WinIcon::from_resource_name(name, size)?;
+        Ok(Icon { inner: win_icon })
    }
 }
--- a/winit-x11/src/lib.rs
+++ b/winit-x11/src/lib.rs
@@ -1,30 +1,11 @@
 //! # X11
-
-use dpi::Size;
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
-use winit_core::event_loop::ActiveEventLoop as CoreActiveEventLoop;
-use winit_core::window::{ActivationToken, PlatformWindowAttributes, Window as CoreWindow};

-pub use crate::event_loop::{ActiveEventLoop, EventLoop};
-pub use crate::window::Window;
-
-macro_rules! os_error {
-    ($error:expr) => {{ winit_core::error::OsError::new(line!(), file!(), $error) }};
-}
-
-mod activation;
-mod atoms;
-mod dnd;
-mod event_loop;
-mod event_processor;
-pub mod ffi;
-mod ime;
-mod monitor;
-mod util;
-mod window;
-mod xdisplay;
-mod xsettings;
+use crate::dpi::Size;
+use crate::event_loop::{ActiveEventLoop, EventLoop, EventLoopBuilder};
+use crate::monitor::MonitorHandle;
+use crate::window::{Window as CoreWindow, WindowAttributes};

 /// X window type. Maps directly to
 /// [`_NET_WM_WINDOW_TYPE`](https://specifications.freedesktop.org/wm-spec/wm-spec-1.5.html).
@@ -99,21 +80,19 @@ pub type XWindow = u32;
 #[inline]
 pub fn register_xlib_error_hook(hook: XlibErrorHook) {
    // Append new hook.
-    crate::event_loop::XLIB_ERROR_HOOKS.lock().unwrap().push(hook);
+    crate::platform_impl::XLIB_ERROR_HOOKS.lock().unwrap().push(hook);
 }

 /// Additional methods on [`ActiveEventLoop`] that are specific to X11.
-///
-/// [`ActiveEventLoop`]: winit_core::event_loop::ActiveEventLoop
 pub trait ActiveEventLoopExtX11 {
-    /// True if the event loop uses X11.
+    /// True if the [`ActiveEventLoop`] uses X11.
    fn is_x11(&self) -> bool;
 }

-impl ActiveEventLoopExtX11 for dyn CoreActiveEventLoop + '_ {
+impl ActiveEventLoopExtX11 for dyn ActiveEventLoop + '_ {
    #[inline]
    fn is_x11(&self) -> bool {
-        self.cast_ref::<ActiveEventLoop>().is_some()
+        self.as_any().downcast_ref::<crate::platform_impl::x11::ActiveEventLoop>().is_some()
    }
 }

@@ -123,7 +102,14 @@ pub trait EventLoopExtX11 {
    fn is_x11(&self) -> bool;
 }

-/// Additional methods when building event loop that are specific to X11.
+impl EventLoopExtX11 for EventLoop {
+    #[inline]
+    fn is_x11(&self) -> bool {
+        !self.event_loop.is_wayland()
+    }
+}
+
+/// Additional methods on [`EventLoopBuilder`] that are specific to X11.
 pub trait EventLoopBuilderExtX11 {
    /// Force using X11.
    fn with_x11(&mut self) -> &mut Self;
@@ -135,6 +121,20 @@ pub trait EventLoopBuilderExtX11 {
    fn with_any_thread(&mut self, any_thread: bool) -> &mut Self;
 }

+impl EventLoopBuilderExtX11 for EventLoopBuilder {
+    #[inline]
+    fn with_x11(&mut self) -> &mut Self {
+        self.platform_specific.forced_backend = Some(crate::platform_impl::Backend::X);
+        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 X11.
 ///
 /// [`Window`]: crate::window::Window
@@ -142,52 +142,12 @@ pub trait WindowExtX11 {}

 impl WindowExtX11 for dyn CoreWindow {}

-#[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) struct ApplicationName {
-    pub(crate) general: String,
-    pub(crate) instance: String,
-}
-
-#[derive(Clone, Debug)]
-pub struct WindowAttributesX11 {
-    pub(crate) name: Option<ApplicationName>,
-    pub(crate) activation_token: Option<ActivationToken>,
-    pub(crate) visual_id: Option<XVisualID>,
-    pub(crate) screen_id: Option<i32>,
-    pub(crate) base_size: Option<Size>,
-    pub(crate) override_redirect: bool,
-    pub(crate) x11_window_types: Vec<WindowType>,
-
-    /// The parent window to embed this window into.
-    pub(crate) embed_window: Option<XWindow>,
-}
-
-impl Default for WindowAttributesX11 {
-    fn default() -> Self {
-        Self {
-            name: None,
-            activation_token: None,
-            visual_id: None,
-            screen_id: None,
-            base_size: None,
-            override_redirect: false,
-            x11_window_types: vec![WindowType::Normal],
-            embed_window: None,
-        }
-    }
-}
-
-impl WindowAttributesX11 {
+/// Additional methods on [`WindowAttributes`] that are specific to X11.
+pub trait WindowAttributesExtX11 {
    /// Create this window with a specific X11 visual.
-    pub fn with_x11_visual(mut self, visual_id: XVisualID) -> Self {
-        self.visual_id = Some(visual_id);
-        self
-    }
+    fn with_x11_visual(self, visual_id: XVisualID) -> Self;

-    pub fn with_x11_screen(mut self, screen_id: i32) -> Self {
-        self.screen_id = Some(screen_id);
-        self
-    }
+    fn with_x11_screen(self, screen_id: i32) -> Self;

    /// Build window with the given `general` and `instance` names.
    ///
@@ -197,39 +157,27 @@ impl WindowAttributesX11 {
    ///
    /// 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)
-    pub fn with_name(mut self, general: impl Into<String>, instance: impl Into<String>) -> Self {
-        self.name = Some(ApplicationName { general: general.into(), instance: instance.into() });
-        self
-    }
+    fn with_name(self, general: impl Into<String>, instance: impl Into<String>) -> Self;

    /// Build window with override-redirect flag; defaults to false.
-    pub fn with_override_redirect(mut self, override_redirect: bool) -> Self {
-        self.override_redirect = override_redirect;
-        self
-    }
+    fn with_override_redirect(self, override_redirect: bool) -> Self;

    /// Build window with `_NET_WM_WINDOW_TYPE` hints; defaults to `Normal`.
-    pub fn with_x11_window_type(mut self, x11_window_types: Vec<WindowType>) -> Self {
-        self.x11_window_types = x11_window_types;
-        self
-    }
+    fn with_x11_window_type(self, x11_window_type: Vec<WindowType>) -> Self;

    /// Build window with base size hint.
    ///
    /// ```
    /// # use winit::dpi::{LogicalSize, PhysicalSize};
    /// # use winit::window::{Window, WindowAttributes};
-    /// # use winit::platform::x11::WindowAttributesX11;
+    /// # use winit::platform::x11::WindowAttributesExtX11;
    /// // Specify the size in logical dimensions like this:
-    /// WindowAttributesX11::default().with_base_size(LogicalSize::new(400.0, 200.0));
+    /// WindowAttributes::default().with_base_size(LogicalSize::new(400.0, 200.0));
    ///
    /// // Or specify the size in physical dimensions like this:
-    /// WindowAttributesX11::default().with_base_size(PhysicalSize::new(400, 200));
+    /// WindowAttributes::default().with_base_size(PhysicalSize::new(400, 200));
    /// ```
-    pub fn with_base_size<S: Into<Size>>(mut self, base_size: S) -> Self {
-        self.base_size = Some(base_size.into());
-        self
-    }
+    fn with_base_size<S: Into<Size>>(self, base_size: S) -> Self;

    /// Embed this window into another parent window.
    ///
@@ -238,28 +186,70 @@ impl WindowAttributesX11 {
    /// ```no_run
    /// use winit::window::{Window, WindowAttributes};
    /// use winit::event_loop::ActiveEventLoop;
-    /// use winit::platform::x11::{XWindow, WindowAttributesX11};
+    /// use winit::platform::x11::{XWindow, WindowAttributesExtX11};
    /// # fn create_window(event_loop: &dyn ActiveEventLoop) -> Result<(), Box<dyn std::error::Error>> {
    /// let parent_window_id = std::env::args().nth(1).unwrap().parse::<XWindow>()?;
-    /// let window_x11_attributes = WindowAttributesX11::default().with_embed_parent_window(parent_window_id);
-    /// let window_attributes = WindowAttributes::default().with_platform_attributes(Box::new(window_x11_attributes));
+    /// let window_attributes = WindowAttributes::default().with_embed_parent_window(parent_window_id);
    /// let window = event_loop.create_window(window_attributes)?;
    /// # Ok(()) }
    /// ```
-    pub fn with_embed_parent_window(mut self, parent_window_id: XWindow) -> Self {
-        self.embed_window = Some(parent_window_id);
+    fn with_embed_parent_window(self, parent_window_id: XWindow) -> Self;
+}
+
+impl WindowAttributesExtX11 for WindowAttributes {
+    #[inline]
+    fn with_x11_visual(mut self, visual_id: XVisualID) -> Self {
+        self.platform_specific.x11.visual_id = Some(visual_id);
        self
    }

    #[inline]
-    pub fn with_activation_token(mut self, token: ActivationToken) -> Self {
-        self.activation_token = Some(token);
+    fn with_x11_screen(mut self, screen_id: i32) -> Self {
+        self.platform_specific.x11.screen_id = Some(screen_id);
+        self
+    }
+
+    #[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
+    }
+
+    #[inline]
+    fn with_override_redirect(mut self, override_redirect: bool) -> Self {
+        self.platform_specific.x11.override_redirect = override_redirect;
+        self
+    }
+
+    #[inline]
+    fn with_x11_window_type(mut self, x11_window_types: Vec<WindowType>) -> Self {
+        self.platform_specific.x11.x11_window_types = x11_window_types;
+        self
+    }
+
+    #[inline]
+    fn with_base_size<S: Into<Size>>(mut self, base_size: S) -> Self {
+        self.platform_specific.x11.base_size = Some(base_size.into());
+        self
+    }
+
+    #[inline]
+    fn with_embed_parent_window(mut self, parent_window_id: XWindow) -> Self {
+        self.platform_specific.x11.embed_window = Some(parent_window_id);
        self
    }
 }

-impl PlatformWindowAttributes for WindowAttributesX11 {
-    fn box_clone(&self) -> Box<dyn PlatformWindowAttributes> {
-        Box::from(self.clone())
+/// Additional methods on `MonitorHandle` that are specific to X11.
+pub trait MonitorHandleExtX11 {
+    /// Returns the inner identifier of the monitor.
+    fn native_id(&self) -> u32;
+}
+
+impl MonitorHandleExtX11 for MonitorHandle {
+    #[inline]
+    fn native_id(&self) -> u32 {
+        self.inner.native_identifier()
    }
 }
--- a/src/platform_impl/android/keycodes.rs
+++ b/src/platform_impl/android/keycodes.rs
@@ -1,8 +1,7 @@
-use android_activity::AndroidApp;
 use android_activity::input::{KeyAction, KeyEvent, KeyMapChar, Keycode};
-use winit_core::keyboard::{
-    Key, KeyCode, KeyLocation, NamedKey, NativeKey, NativeKeyCode, PhysicalKey,
-};
+use android_activity::AndroidApp;
+
+use crate::keyboard::{Key, KeyCode, KeyLocation, NamedKey, NativeKey, NativeKeyCode, PhysicalKey};

 pub fn to_physical_key(keycode: Keycode) -> PhysicalKey {
    PhysicalKey::Code(match keycode {
@@ -109,7 +108,6 @@ pub fn to_physical_key(keycode: Keycode) -> PhysicalKey {
        Keycode::MediaStop => KeyCode::MediaStop,
        Keycode::MediaNext => KeyCode::MediaTrackNext,
        Keycode::MediaPrevious => KeyCode::MediaTrackPrevious,
-        Keycode::MediaEject => KeyCode::Eject,

        Keycode::Plus => KeyCode::Equal,
        Keycode::Minus => KeyCode::Minus,
@@ -132,11 +130,7 @@ pub fn to_physical_key(keycode: Keycode) -> PhysicalKey {
        // These are exactly the same
        Keycode::ScrollLock => KeyCode::ScrollLock,

-        Keycode::Eisu => KeyCode::Lang2,
-        Keycode::Muhenkan => KeyCode::NonConvert,
-        Keycode::Henkan => KeyCode::Convert,
        Keycode::Yen => KeyCode::IntlYen,
-        Keycode::Ro => KeyCode::IntlRo,
        Keycode::Kana => KeyCode::Lang1,
        Keycode::KatakanaHiragana => KeyCode::KanaMode,

@@ -149,8 +143,8 @@ pub fn to_physical_key(keycode: Keycode) -> PhysicalKey {
        Keycode::AltLeft => KeyCode::AltLeft,
        Keycode::AltRight => KeyCode::AltRight,

-        Keycode::MetaLeft => KeyCode::MetaLeft,
-        Keycode::MetaRight => KeyCode::MetaRight,
+        Keycode::MetaLeft => KeyCode::SuperLeft,
+        Keycode::MetaRight => KeyCode::SuperRight,

        Keycode::LeftBracket => KeyCode::BracketLeft,
        Keycode::RightBracket => KeyCode::BracketRight,
@@ -159,14 +153,6 @@ pub fn to_physical_key(keycode: Keycode) -> PhysicalKey {
        Keycode::Sleep => KeyCode::Sleep, // what about SoftSleep?
        Keycode::Wakeup => KeyCode::WakeUp,

-        Keycode::CapsLock => KeyCode::CapsLock,
-        Keycode::Help => KeyCode::Help,
-
-        Keycode::Back => KeyCode::BrowserBack,
-        Keycode::Forward => KeyCode::BrowserForward,
-        Keycode::Refresh => KeyCode::BrowserRefresh,
-        Keycode::Search => KeyCode::BrowserSearch,
-
        keycode => return PhysicalKey::Unidentified(NativeKeyCode::Android(keycode.into())),
    })
 }
@@ -323,7 +309,7 @@ pub fn to_logical(key_char: Option<KeyMapChar>, keycode: Keycode) -> Key {
            ShiftLeft => Key::Named(NamedKey::Shift),
            ShiftRight => Key::Named(NamedKey::Shift),
            Tab => Key::Named(NamedKey::Tab),
-            Space => Key::Character(" ".into()),
+            Space => Key::Named(NamedKey::Space),
            Sym => Key::Named(NamedKey::Symbol),
            Explorer => Key::Named(NamedKey::LaunchWebBrowser),
            Envelope => Key::Named(NamedKey::LaunchMail),
@@ -354,8 +340,8 @@ pub fn to_logical(key_char: Option<KeyMapChar>, keycode: Keycode) -> Key {
            CtrlRight => Key::Named(NamedKey::Control),
            CapsLock => Key::Named(NamedKey::CapsLock),
            ScrollLock => Key::Named(NamedKey::ScrollLock),
-            MetaLeft => Key::Named(NamedKey::Meta),
-            MetaRight => Key::Named(NamedKey::Meta),
+            MetaLeft => Key::Named(NamedKey::Super),
+            MetaRight => Key::Named(NamedKey::Super),
            Function => Key::Named(NamedKey::Fn),
            Sysrq => Key::Named(NamedKey::PrintScreen),
            Break => Key::Named(NamedKey::Pause),
--- a/src/platform_impl/android/mod.rs
+++ b/src/platform_impl/android/mod.rs
@@ -1,5 +1,4 @@
 use std::cell::Cell;
-use std::fmt;
 use std::hash::Hash;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Mutex};
@@ -9,26 +8,32 @@ 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 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::{
+
+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::{
    ActiveEventLoop as RootActiveEventLoop, ControlFlow, DeviceEvents,
    EventLoopProxy as CoreEventLoopProxy, EventLoopProxyProvider,
    OwnedDisplayHandle as CoreOwnedDisplayHandle,
 };
-use winit_core::monitor::{Fullscreen, MonitorHandle as CoreMonitorHandle};
-use winit_core::window::{
-    self, CursorGrabMode, ImeCapabilities, ImePurpose, ImeRequest, ImeRequestError,
+use crate::monitor::{MonitorHandle as RootMonitorHandle, VideoMode};
+use crate::platform::pump_events::PumpStatus;
+use crate::window::{
+    self, CursorGrabMode, CustomCursor, CustomCursorSource, Fullscreen, ImePurpose,
    ResizeDirection, Theme, Window as CoreWindow, WindowAttributes, WindowButtons, WindowId,
    WindowLevel,
 };

-use crate::keycodes;
+mod keycodes;
+
+pub(crate) use crate::cursor::{
+    NoCustomCursor as PlatformCustomCursor, NoCustomCursor as PlatformCustomCursorSource,
+};
+pub(crate) use crate::icon::NoIcon as PlatformIcon;

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

@@ -39,17 +44,16 @@ fn min_timeout(a: Option<Duration>, b: Option<Duration>) -> Option<Duration> {
    a.map_or(b, |a_timeout| b.map_or(Some(a_timeout), |b_timeout| Some(a_timeout.min(b_timeout))))
 }

-#[derive(Clone, Debug)]
+#[derive(Clone)]
 struct SharedFlagSetter {
    flag: Arc<AtomicBool>,
 }
 impl SharedFlagSetter {
-    fn set(&self) -> bool {
+    pub fn set(&self) -> bool {
        self.flag.compare_exchange(false, true, Ordering::AcqRel, Ordering::Relaxed).is_ok()
    }
 }

-#[derive(Debug)]
 struct SharedFlag {
    flag: Arc<AtomicBool>,
 }
@@ -59,37 +63,31 @@ 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 {
-    fn new() -> Self {
+    pub fn new() -> Self {
        Self { flag: Arc::new(AtomicBool::new(false)) }
    }

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

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

 #[derive(Clone)]
-struct RedrawRequester {
+pub struct RedrawRequester {
    flag: SharedFlagSetter,
    waker: AndroidAppWaker,
 }

-impl fmt::Debug for RedrawRequester {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("RedrawRequester").field("flag", &self.flag).finish_non_exhaustive()
-    }
-}
-
 impl RedrawRequester {
    fn new(flag: &SharedFlag, waker: AndroidAppWaker) -> Self {
        RedrawRequester { flag: flag.setter(), waker }
    }

-    fn request_redraw(&self) {
+    pub fn request_redraw(&self) {
        if self.flag.set() {
            // Only explicitly try to wake up the main loop when the flag
            // value changes
@@ -98,9 +96,8 @@ impl RedrawRequester {
    }
 }

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

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

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

 impl EventLoop {
-    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);
-        }
-
+    pub(crate) fn new(
+        attributes: &PlatformSpecificEventLoopAttributes,
+    ) -> Result<Self, EventLoopError> {
        let android_app = attributes.android_app.as_ref().expect(
            "An `AndroidApp` as passed to android_main() is required to create an `EventLoop` on \
             Android",
@@ -164,7 +157,7 @@ impl EventLoop {
        })
    }

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

@@ -473,23 +466,16 @@ impl EventLoop {
                            &mut self.combining_accent,
                        );

-                        let logical_key = keycodes::to_logical(key_char, keycode);
-                        let text = if state == event::ElementState::Pressed {
-                            logical_key.to_text().map(smol_str::SmolStr::new)
-                        } else {
-                            None
-                        };
-
                        let event = event::WindowEvent::KeyboardInput {
                            device_id: Some(DeviceId::from_raw(key.device_id() as i64)),
                            event: event::KeyEvent {
                                state,
                                physical_key: keycodes::to_physical_key(keycode),
-                                logical_key,
+                                logical_key: keycodes::to_logical(key_char, keycode),
                                location: keycodes::to_location(keycode),
                                repeat: key.repeat_count() > 0,
-                                text: text.clone(),
-                                text_with_all_modifiers: text,
+                                text: None,
+                                text_with_all_modifiers: None,
                                key_without_modifiers: keycodes::to_logical(key_char, keycode),
                            },
                            is_synthetic: false,
@@ -507,6 +493,10 @@ impl EventLoop {
        input_status
    }

+    pub fn run_app<A: ApplicationHandler>(mut self, app: A) -> Result<(), EventLoopError> {
+        self.run_app_on_demand(app)
+    }
+
    pub fn run_app_on_demand<A: ApplicationHandler>(
        &mut self,
        mut app: A,
@@ -553,6 +543,8 @@ impl EventLoop {
        if self.exiting() {
            self.loop_running = false;

+            app.exiting(&self.window_target);
+
            PumpStatus::Exit(0)
        } else {
            PumpStatus::Continue
@@ -647,12 +639,6 @@ pub struct EventLoopProxy {
    waker: AndroidAppWaker,
 }

-impl fmt::Debug for EventLoopProxy {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("EventLoopProxy").field("wake_up", &self.wake_up).finish_non_exhaustive()
-    }
-}
-
 impl EventLoopProxy {
    fn new(waker: AndroidAppWaker) -> Self {
        Self { wake_up: AtomicBool::new(false), waker }
@@ -666,7 +652,6 @@ impl EventLoopProxyProvider for EventLoopProxy {
    }
 }

-#[derive(Debug)]
 pub struct ActiveEventLoop {
    pub(crate) app: AndroidApp,
    control_flow: Cell<ControlFlow>,
@@ -700,11 +685,11 @@ impl RootActiveEventLoop for ActiveEventLoop {
        Err(NotSupportedError::new("create_custom_cursor is not supported").into())
    }

-    fn available_monitors(&self) -> Box<dyn Iterator<Item = CoreMonitorHandle>> {
+    fn available_monitors(&self) -> Box<dyn Iterator<Item = RootMonitorHandle>> {
        Box::new(std::iter::empty())
    }

-    fn primary_monitor(&self) -> Option<CoreMonitorHandle> {
+    fn primary_monitor(&self) -> Option<RootMonitorHandle> {
        None
    }

@@ -759,10 +744,8 @@ impl rwh_06::HasDisplayHandle for OwnedDisplayHandle {
 #[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
 pub struct PlatformSpecificWindowAttributes;

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

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

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

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

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

@@ -829,15 +808,15 @@ impl CoreWindow for Window {
        GLOBAL_WINDOW
    }

-    fn primary_monitor(&self) -> Option<CoreMonitorHandle> {
+    fn primary_monitor(&self) -> Option<RootMonitorHandle> {
        None
    }

-    fn available_monitors(&self) -> Box<dyn Iterator<Item = CoreMonitorHandle>> {
+    fn available_monitors(&self) -> Box<dyn Iterator<Item = RootMonitorHandle>> {
        Box::new(std::iter::empty())
    }

-    fn current_monitor(&self) -> Option<CoreMonitorHandle> {
+    fn current_monitor(&self) -> Option<RootMonitorHandle> {
        None
    }

@@ -941,37 +920,16 @@ impl CoreWindow for Window {

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

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

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

-    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);
-            },
+    fn set_ime_allowed(&self, allowed: bool) {
+        if allowed {
+            self.app.show_soft_input(true);
+        } else {
+            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) {}
@@ -1034,6 +992,41 @@ 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")
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct MonitorHandle;
+
+impl MonitorHandle {
+    pub fn name(&self) -> Option<String> {
+        unreachable!()
+    }
+
+    pub fn position(&self) -> Option<PhysicalPosition<i32>> {
+        unreachable!()
+    }
+
+    pub fn scale_factor(&self) -> f64 {
+        unreachable!()
+    }
+
+    pub fn current_video_mode(&self) -> Option<VideoMode> {
+        unreachable!()
+    }
+
+    pub fn video_modes(&self) -> std::iter::Empty<VideoMode> {
+        unreachable!()
+    }
+}
+
 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/apple/appkit/app.rs
+++ b/src/platform_impl/apple/appkit/app.rs
@@ -1,18 +1,17 @@
 #![allow(clippy::unnecessary_cast)]

 use std::cell::Cell;
+use std::mem;
 use std::rc::Rc;
-use std::{mem, ptr};

 use dispatch2::MainThreadBound;
 use objc2::runtime::{Imp, Sel};
 use objc2::sel;
 use objc2_app_kit::{NSApplication, NSEvent, NSEventModifierFlags, NSEventType};
 use objc2_foundation::MainThreadMarker;
-use tracing::trace_span;
-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);

@@ -22,10 +21,6 @@ static ORIGINAL: MainThreadBound<Cell<Option<SendEvent>>> = {
 };

 extern "C-unwind" fn send_event(app: &NSApplication, sel: Sel, event: &NSEvent) {
-    // This can be a bit noisy, since `event` is fairly large. Note that you can use
-    // `RUST_LOG='trace,winit_appkit::app=warn'` if you're debugging and want TRACE-level logs but
-    // not this.
-    let _entered = trace_span!("sendEvent:", ?event).entered();
    let mtm = MainThreadMarker::from(app);

    // Normally, holding Cmd + any key never sends us a `keyUp` event for that key.
@@ -35,8 +30,8 @@ extern "C-unwind" fn send_event(app: &NSApplication, sel: Sel, event: &NSEvent)
    // For posterity, there are some undocumented event types
    // (https://github.com/servo/cocoa-rs/issues/155)
    // but that doesn't really matter here.
-    let event_type = event.r#type();
-    let modifier_flags = event.modifierFlags();
+    let event_type = unsafe { event.r#type() };
+    let modifier_flags = unsafe { event.modifierFlags() };
    if event_type == NSEventType::KeyUp && modifier_flags.contains(NSEventModifierFlags::Command) {
        if let Some(key_window) = app.keyWindow() {
            key_window.sendEvent(event);
@@ -80,7 +75,9 @@ pub(crate) fn override_send_event(global_app: &NSApplication) {
    let overridden = unsafe { mem::transmute::<SendEvent, Imp>(send_event) };

    // If we've already overridden the method, don't do anything.
-    if ptr::fn_addr_eq(overridden, method.implementation()) {
+    // FIXME(madsmtm): Use `std::ptr::fn_addr_eq` (Rust 1.85) once available in MSRV.
+    #[allow(unknown_lints, unpredictable_function_pointer_comparisons)]
+    if overridden == method.implementation() {
        return;
    }

@@ -101,15 +98,15 @@ pub(crate) fn override_send_event(global_app: &NSApplication) {
 }

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

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

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

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

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

    #[test]
--- a/src/platform_impl/apple/appkit/app_state.rs
+++ b/src/platform_impl/apple/appkit/app_state.rs
@@ -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, MainRunLoop};
-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::event_loop::{ActiveEventLoop, notify_windows_of_exit, stop_app_immediately};
+use super::super::event_handler::EventHandler;
+use super::super::event_loop_proxy::EventLoopProxy;
+use super::event_loop::{stop_app_immediately, ActiveEventLoop};
 use super::menu;
-use super::observer::EventLoopWaker;
+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 {
@@ -25,23 +25,16 @@ pub(super) struct AppState {
    activation_policy: Option<NSApplicationActivationPolicy>,
    default_menu: bool,
    activate_ignoring_other_apps: bool,
-    run_loop: MainRunLoop,
+    run_loop: RunLoop,
    event_loop_proxy: Arc<EventLoopProxy>,
    event_handler: EventHandler,
-    stop_on_launch: Cell<bool>,
-    stop_before_wait: Cell<bool>,
-    stop_after_wait: Cell<bool>,
-    stop_on_redraw: Cell<bool>,
-    /// Whether `applicationDidFinishLaunching:` has been run or not.
+    /// Whether `NSApplicationDidFinishLaunchingNotification` has been sent.
    is_launched: Cell<bool>,
-    /// Whether an `EventLoop` is currently running.
-    is_running: Cell<bool>,
    /// Whether the user has requested the event loop to exit.
    exit: Cell<bool>,
    control_flow: Cell<ControlFlow>,
    waker: RefCell<EventLoopWaker>,
    start_time: Cell<Option<Instant>>,
-    wait_timeout: Cell<Option<Instant>>,
    pending_redraw: RefCell<Vec<WindowId>>,
    // NOTE: This is strongly referenced by our `NSWindowDelegate` and our `NSView` subclass, and
    // as such should be careful to not add fields that, in turn, strongly reference those.
@@ -58,7 +51,7 @@ impl AppState {
        activation_policy: Option<NSApplicationActivationPolicy>,
        default_menu: bool,
        activate_ignoring_other_apps: bool,
-    ) -> Option<Rc<Self>> {
+    ) -> 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));
        }));
@@ -68,24 +61,19 @@ impl AppState {
            activation_policy,
            default_menu,
            activate_ignoring_other_apps,
-            run_loop: MainRunLoop::get(mtm),
+            run_loop: RunLoop::main(mtm),
            event_loop_proxy,
            event_handler: EventHandler::new(),
-            stop_on_launch: Cell::new(false),
-            stop_before_wait: Cell::new(false),
-            stop_after_wait: Cell::new(false),
-            stop_on_redraw: Cell::new(false),
            is_launched: Cell::new(false),
-            is_running: Cell::new(false),
            exit: Cell::new(false),
            control_flow: Cell::new(ControlFlow::default()),
            waker: RefCell::new(EventLoopWaker::new()),
            start_time: Cell::new(None),
-            wait_timeout: Cell::new(None),
            pending_redraw: RefCell::new(vec![]),
        });

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

    pub fn get(mtm: MainThreadMarker) -> Rc<Self> {
@@ -96,14 +84,17 @@ impl AppState {
            .clone()
    }

-    // NOTE: This notification will, globally, only be emitted once,
-    // no matter how many `EventLoop`s the user creates.
    pub fn did_finish_launching(self: &Rc<Self>, _notification: &NSNotification) {
+        trace_scope!("NSApplicationDidFinishLaunchingNotification");
+        // NOTE: This notification will, globally, only be emitted once,
+        // no matter how many `EventLoop`s the user creates. There is no other
+        // way to know this information, other than to keep track of it
+        // ourselves.
        self.is_launched.set(true);

        let app = NSApplication::sharedApplication(self.mtm);
-        // We need to delay setting the activation policy and activating the app
-        // until `applicationDidFinishLaunching` has been called. Otherwise the
+        // We need to delay setting the activation policy and activating the app until
+        // `NSApplicationDidFinishLaunchingNotification` has been sent. Otherwise the
        // menu bar is initially unresponsive on macOS 10.15.
        if let Some(activation_policy) = self.activation_policy {
            app.setActivationPolicy(activation_policy);
@@ -116,7 +107,7 @@ impl AppState {
            // - https://github.com/rust-windowing/winit/issues/261
            // - https://github.com/rust-windowing/winit/issues/3958
            let is_bundled =
-                NSRunningApplication::currentApplication().bundleIdentifier().is_some();
+                unsafe { NSRunningApplication::currentApplication().bundleIdentifier().is_some() };
            if !is_bundled {
                app.setActivationPolicy(NSApplicationActivationPolicy::Regular);
            }
@@ -133,29 +124,12 @@ impl AppState {

        self.waker.borrow_mut().start();

-        self.set_is_running(true);
        self.dispatch_init_events();
-
-        // If the application is being launched via `EventLoop::pump_app_events()` then we'll
-        // want to stop the app once it is launched (and return to the external loop)
-        //
-        // In this case we still want to consider Winit's `EventLoop` to be "running",
-        // so we call `start_running()` above.
-        if self.stop_on_launch.get() {
-            // NOTE: the original idea had been to only stop the underlying `RunLoop`
-            // for the app but that didn't work as expected (`-[NSApplication run]`
-            // effectively ignored the attempt to stop the RunLoop and re-started it).
-            //
-            // So we return from `pump_events` by stopping the application.
-            let app = NSApplication::sharedApplication(self.mtm);
-            stop_app_immediately(&app);
-        }
    }

    pub fn will_terminate(self: &Rc<Self>, _notification: &NSNotification) {
-        let app = NSApplication::sharedApplication(self.mtm);
-        notify_windows_of_exit(&app);
-        self.event_handler.terminate();
+        trace_scope!("NSApplicationWillTerminateNotification");
+        // TODO: Notify every window that it will be destroyed, like done in iOS?
        self.internal_exit();
    }

@@ -163,63 +137,26 @@ impl AppState {
    /// of the given closure.
    pub fn set_event_handler<R>(
        &self,
-        handler: impl ApplicationHandler,
+        handler: &mut dyn ApplicationHandler,
        closure: impl FnOnce() -> R,
    ) -> R {
-        self.event_handler.set(Box::new(handler), closure)
+        self.event_handler.set(handler, closure)
    }

    pub fn event_loop_proxy(&self) -> &Arc<EventLoopProxy> {
        &self.event_loop_proxy
    }

-    /// If `pump_events` is called to progress the event loop then we
-    /// bootstrap the event loop via `-[NSApplication run]` but will use
-    /// `CFRunLoopRunInMode` for subsequent calls to `pump_events`.
-    pub fn set_stop_on_launch(&self) {
-        self.stop_on_launch.set(true);
-    }
-
-    pub fn set_stop_before_wait(&self, value: bool) {
-        self.stop_before_wait.set(value)
-    }
-
-    pub fn set_stop_after_wait(&self, value: bool) {
-        self.stop_after_wait.set(value)
-    }
-
-    pub fn set_stop_on_redraw(&self, value: bool) {
-        self.stop_on_redraw.set(value)
-    }
-
-    pub fn set_wait_timeout(&self, value: Option<Instant>) {
-        self.wait_timeout.set(value)
-    }
-
-    /// Clears the `running` state and resets the `control_flow` state when an `EventLoop` exits.
-    ///
-    /// NOTE: that if the `NSApplication` has been launched then that state is preserved,
-    /// and we won't need to re-launch the app if subsequent EventLoops are run.
    pub fn internal_exit(self: &Rc<Self>) {
-        self.set_is_running(false);
-        self.set_stop_on_redraw(false);
-        self.set_stop_before_wait(false);
-        self.set_stop_after_wait(false);
-        self.set_wait_timeout(None);
+        self.with_handler(|app, event_loop| {
+            app.exiting(event_loop);
+        });
    }

    pub fn is_launched(&self) -> bool {
        self.is_launched.get()
    }

-    pub fn set_is_running(&self, value: bool) {
-        self.is_running.set(value)
-    }
-
-    pub fn is_running(&self) -> bool {
-        self.is_running.get()
-    }
-
    pub fn exit(&self) {
        self.exit.set(true)
    }
@@ -247,14 +184,6 @@ impl AppState {
            self.with_handler(|app, event_loop| {
                app.window_event(event_loop, window_id, WindowEvent::RedrawRequested);
            });
-
-            // `pump_events` will request to stop immediately _after_ dispatching RedrawRequested
-            // events as a way to ensure that `pump_events` can't block an external loop
-            // indefinitely
-            if self.stop_on_redraw.get() {
-                let app = NSApplication::sharedApplication(self.mtm);
-                stop_app_immediately(&app);
-            }
        }
    }

@@ -263,7 +192,7 @@ impl AppState {
        if !pending_redraw.contains(&window_id) {
            pending_redraw.push(window_id);
        }
-        self.run_loop.wake_up();
+        self.run_loop.wakeup();
    }

    #[track_caller]
@@ -308,16 +237,10 @@ impl AppState {
    // Called by RunLoopObserver after finishing waiting for new events
    pub fn wakeup(self: &Rc<Self>) {
        // Return when in event handler due to https://github.com/rust-windowing/winit/issues/1779
-        // (we have registered to observe all modes, including modal event loops).
-        if !self.event_handler.ready() || !self.is_running() {
+        if !self.event_handler.ready() {
            return;
        }

-        if self.stop_after_wait.get() {
-            let app = NSApplication::sharedApplication(self.mtm);
-            stop_app_immediately(&app);
-        }
-
        let start = self.start_time.get().unwrap();
        let cause = match self.control_flow() {
            ControlFlow::Poll => StartCause::Poll,
@@ -337,8 +260,9 @@ impl AppState {
    // Called by RunLoopObserver before waiting for new events
    pub fn cleared(self: &Rc<Self>) {
        // Return when in event handler due to https://github.com/rust-windowing/winit/issues/1779
-        // (we have registered to observe all modes, including modal event loops).
-        if !self.event_handler.ready() || !self.is_running() {
+        // 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 !self.event_handler.ready() {
            return;
        }

@@ -355,27 +279,14 @@ impl AppState {
        if self.exiting() {
            let app = NSApplication::sharedApplication(self.mtm);
            stop_app_immediately(&app);
-            notify_windows_of_exit(&app);
        }

-        if self.stop_before_wait.get() {
-            let app = NSApplication::sharedApplication(self.mtm);
-            stop_app_immediately(&app);
-        }
        self.start_time.set(Some(Instant::now()));
-        let wait_timeout = self.wait_timeout.get(); // configured by pump_events
        let app_timeout = match self.control_flow() {
            ControlFlow::Wait => None,
            ControlFlow::Poll => Some(Instant::now()),
            ControlFlow::WaitUntil(instant) => Some(instant),
        };
-        self.waker.borrow_mut().start_at(min_timeout(wait_timeout, app_timeout));
+        self.waker.borrow_mut().start_at(app_timeout);
    }
 }
-
-/// Returns the minimum `Option<Instant>`, taking into account that `None`
-/// equates to an infinite timeout, not a zero timeout (so can't just use
-/// `Option::min`)
-fn min_timeout(a: Option<Instant>, b: Option<Instant>) -> Option<Instant> {
-    a.map_or(b, |a_timeout| b.map_or(Some(a_timeout), |b_timeout| Some(a_timeout.min(b_timeout))))
-}
--- a/src/platform_impl/apple/appkit/cursor.rs
+++ b/src/platform_impl/apple/appkit/cursor.rs
@@ -0,0 +1,224 @@
+use std::ffi::c_uchar;
+use std::slice;
+use std::sync::OnceLock;
+
+use objc2::rc::Retained;
+use objc2::runtime::Sel;
+use objc2::{available, msg_send, sel, AllocAnyThread, ClassType};
+use objc2_app_kit::{NSBitmapImageRep, NSCursor, NSDeviceRGBColorSpace, NSImage};
+use objc2_foundation::{
+    ns_string, NSData, NSDictionary, NSNumber, NSObject, NSPoint, NSSize, NSString,
+};
+
+use crate::cursor::{CursorImage, OnlyCursorImageSource};
+use crate::error::RequestError;
+use crate::window::CursorIcon;
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct CustomCursor(pub(crate) Retained<NSCursor>);
+
+// SAFETY: NSCursor is immutable and thread-safe
+// TODO(madsmtm): Put this logic in objc2-app-kit itself
+unsafe impl Send for CustomCursor {}
+unsafe impl Sync for CustomCursor {}
+
+impl CustomCursor {
+    pub(crate) fn new(cursor: OnlyCursorImageSource) -> Result<CustomCursor, RequestError> {
+        cursor_from_image(&cursor.0).map(Self)
+    }
+}
+
+pub(crate) fn cursor_from_image(cursor: &CursorImage) -> Result<Retained<NSCursor>, RequestError> {
+    let width = cursor.width;
+    let height = cursor.height;
+
+    let bitmap = unsafe {
+        NSBitmapImageRep::initWithBitmapDataPlanes_pixelsWide_pixelsHigh_bitsPerSample_samplesPerPixel_hasAlpha_isPlanar_colorSpaceName_bytesPerRow_bitsPerPixel(
+            NSBitmapImageRep::alloc(),
+            std::ptr::null_mut::<*mut c_uchar>(),
+            width as isize,
+            height as isize,
+            8,
+            4,
+            true,
+            false,
+            NSDeviceRGBColorSpace,
+            width as isize * 4,
+            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 image = unsafe {
+        NSImage::initWithSize(NSImage::alloc(), NSSize::new(width.into(), height.into()))
+    };
+    unsafe { image.addRepresentation(&bitmap) };
+
+    let hotspot = NSPoint::new(cursor.hotspot_x as f64, cursor.hotspot_y as f64);
+
+    Ok(NSCursor::initWithImage_hotSpot(NSCursor::alloc(), &image, hotspot))
+}
+
+pub(crate) fn default_cursor() -> Retained<NSCursor> {
+    NSCursor::arrowCursor()
+}
+
+unsafe fn try_cursor_from_selector(sel: Sel) -> Option<Retained<NSCursor>> {
+    let cls = NSCursor::class();
+    if unsafe { msg_send![cls, respondsToSelector: sel] } {
+        let cursor: Retained<NSCursor> = unsafe { msg_send![cls, performSelector: sel] };
+        Some(cursor)
+    } else {
+        tracing::warn!("cursor `{sel}` appears to be invalid");
+        None
+    }
+}
+
+macro_rules! def_undocumented_cursor {
+    {$(
+        $(#[$($m:meta)*])*
+        fn $name:ident();
+    )*} => {$(
+        $(#[$($m)*])*
+        #[allow(non_snake_case)]
+        fn $name() -> Retained<NSCursor> {
+            unsafe { try_cursor_from_selector(sel!($name)).unwrap_or_else(|| default_cursor()) }
+        }
+    )*};
+}
+
+def_undocumented_cursor!(
+    // Undocumented cursors: https://stackoverflow.com/a/46635398/5435443
+    fn _helpCursor();
+    fn _zoomInCursor();
+    fn _zoomOutCursor();
+    fn _windowResizeNorthEastCursor();
+    fn _windowResizeNorthWestCursor();
+    fn _windowResizeSouthEastCursor();
+    fn _windowResizeSouthWestCursor();
+    fn _windowResizeNorthEastSouthWestCursor();
+    fn _windowResizeNorthWestSouthEastCursor();
+
+    // While these two are available, the former just loads a white arrow,
+    // and the latter loads an ugly deflated beachball!
+    // pub fn _moveCursor();
+    // pub fn _waitCursor();
+
+    // An even more undocumented cursor...
+    // https://bugs.eclipse.org/bugs/show_bug.cgi?id=522349
+    fn busyButClickableCursor();
+);
+
+// Note that loading `busybutclickable` with this code won't animate
+// the frames; instead you'll just get them all in a column.
+unsafe fn load_webkit_cursor(name: &NSString) -> Retained<NSCursor> {
+    // Snatch a cursor from WebKit; They fit the style of the native
+    // cursors, and will seem completely standard to macOS users.
+    //
+    // https://stackoverflow.com/a/21786835/5435443
+    let root = ns_string!(
+        "/System/Library/Frameworks/ApplicationServices.framework/Versions/A/Frameworks/\
+         HIServices.framework/Versions/A/Resources/cursors"
+    );
+    let cursor_path = root.stringByAppendingPathComponent(name);
+
+    let pdf_path = cursor_path.stringByAppendingPathComponent(ns_string!("cursor.pdf"));
+    let image = NSImage::initByReferencingFile(NSImage::alloc(), &pdf_path).unwrap();
+
+    // 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,
+        ]
+    };
+    let mut x = 0.0;
+    if let Some(n) = info.objectForKey(ns_string!("hotx")) {
+        if let Ok(n) = n.downcast::<NSNumber>() {
+            x = n.as_cgfloat();
+        }
+    }
+    let mut y = 0.0;
+    if let Some(n) = info.objectForKey(ns_string!("hoty")) {
+        if let Ok(n) = n.downcast::<NSNumber>() {
+            y = n.as_cgfloat();
+        }
+    }
+
+    let hotspot = NSPoint::new(x, y);
+    NSCursor::initWithImage_hotSpot(NSCursor::alloc(), &image, hotspot)
+}
+
+fn webkit_move() -> Retained<NSCursor> {
+    unsafe { load_webkit_cursor(ns_string!("move")) }
+}
+
+fn webkit_cell() -> Retained<NSCursor> {
+    unsafe { load_webkit_cursor(ns_string!("cell")) }
+}
+
+pub(crate) fn invisible_cursor() -> Retained<NSCursor> {
+    // 16x16 GIF data for invisible cursor
+    // You can reproduce this via ImageMagick.
+    // $ convert -size 16x16 xc:none cursor.gif
+    static CURSOR_BYTES: &[u8] = &[
+        0x47, 0x49, 0x46, 0x38, 0x39, 0x61, 0x10, 0x00, 0x10, 0x00, 0xf0, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x21, 0xf9, 0x04, 0x01, 0x00, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x00,
+        0x00, 0x00, 0x10, 0x00, 0x10, 0x00, 0x00, 0x02, 0x0e, 0x84, 0x8f, 0xa9, 0xcb, 0xed, 0x0f,
+        0xa3, 0x9c, 0xb4, 0xda, 0x8b, 0xb3, 0x3e, 0x05, 0x00, 0x3b,
+    ];
+
+    fn new_invisible() -> Retained<NSCursor> {
+        // TODO: Consider using `dataWithBytesNoCopy:`
+        let data = NSData::with_bytes(CURSOR_BYTES);
+        let image = NSImage::initWithData(NSImage::alloc(), &data).unwrap();
+        let hotspot = NSPoint::new(0.0, 0.0);
+        NSCursor::initWithImage_hotSpot(NSCursor::alloc(), &image, hotspot)
+    }
+
+    // Cache this for efficiency
+    static CURSOR: OnceLock<CustomCursor> = OnceLock::new();
+    CURSOR.get_or_init(|| CustomCursor(new_invisible())).0.clone()
+}
+
+#[allow(deprecated)]
+pub(crate) fn cursor_from_icon(icon: CursorIcon) -> Retained<NSCursor> {
+    match icon {
+        CursorIcon::Default => default_cursor(),
+        CursorIcon::Pointer => NSCursor::pointingHandCursor(),
+        CursorIcon::Grab => NSCursor::openHandCursor(),
+        CursorIcon::Grabbing => NSCursor::closedHandCursor(),
+        CursorIcon::Text => NSCursor::IBeamCursor(),
+        CursorIcon::VerticalText => NSCursor::IBeamCursorForVerticalLayout(),
+        CursorIcon::Copy => NSCursor::dragCopyCursor(),
+        CursorIcon::Alias => NSCursor::dragLinkCursor(),
+        CursorIcon::NotAllowed | CursorIcon::NoDrop => NSCursor::operationNotAllowedCursor(),
+        CursorIcon::ContextMenu => NSCursor::contextualMenuCursor(),
+        CursorIcon::Crosshair => NSCursor::crosshairCursor(),
+        CursorIcon::EResize => NSCursor::resizeRightCursor(),
+        CursorIcon::NResize => NSCursor::resizeUpCursor(),
+        CursorIcon::WResize => NSCursor::resizeLeftCursor(),
+        CursorIcon::SResize => NSCursor::resizeDownCursor(),
+        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 => _zoomInCursor(),
+        CursorIcon::ZoomOut if available!(macos = 15.0) => unsafe { NSCursor::zoomOutCursor() },
+        CursorIcon::ZoomOut => _zoomOutCursor(),
+        CursorIcon::NeResize => _windowResizeNorthEastCursor(),
+        CursorIcon::NwResize => _windowResizeNorthWestCursor(),
+        CursorIcon::SeResize => _windowResizeSouthEastCursor(),
+        CursorIcon::SwResize => _windowResizeSouthWestCursor(),
+        CursorIcon::NeswResize => _windowResizeNorthEastSouthWestCursor(),
+        CursorIcon::NwseResize => _windowResizeNorthWestSouthEastCursor(),
+        // This is the wrong semantics for `Wait`, but it's the same as
+        // what's used in Safari and Chrome.
+        CursorIcon::Wait | CursorIcon::Progress => busyButClickableCursor(),
+        CursorIcon::Move | CursorIcon::AllScroll => webkit_move(),
+        CursorIcon::Cell => webkit_cell(),
+        _ => default_cursor(),
+    }
+}
--- a/src/platform_impl/apple/appkit/event.rs
+++ b/src/platform_impl/apple/appkit/event.rs
@@ -3,17 +3,17 @@ use std::ptr::NonNull;
 use dispatch2::run_on_main;
 use objc2::rc::Retained;
 use objc2_app_kit::{NSEvent, NSEventModifierFlags, NSEventSubtype, NSEventType};
-use objc2_core_foundation::{CFData, CFRetained};
+use objc2_core_foundation::{CFData, CFDataGetBytePtr, CFRetained};
 use objc2_foundation::NSPoint;
 use smol_str::SmolStr;
-use winit_core::event::{ElementState, KeyEvent, Modifiers};
-use winit_core::keyboard::{
+
+use super::ffi;
+use crate::event::{ElementState, KeyEvent, Modifiers};
+use crate::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 {
@@ -30,7 +30,7 @@ pub fn get_modifierless_char(scancode: u16) -> Key {
        return Key::Unidentified(NativeKey::MacOS(scancode));
    };

-    let layout = layout_data.byte_ptr().cast();
+    let layout = unsafe { CFDataGetBytePtr(layout_data).cast() };
    let keyboard_type = run_on_main(|_mtm| unsafe { ffi::LMGetKbdType() });

    let mut result_len = 0;
@@ -67,7 +67,9 @@ pub fn get_modifierless_char(scancode: u16) -> Key {

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

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

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

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

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

        let logical_key = match text_with_all_modifiers.as_ref() {
            // Only checking for ctrl and cmd here, not checking for alt because we DO want to
-            // include its effect in the key. For example if -on the German layout- one
+            // include its effect in the key. For example if -on the Germay layout- one
            // presses alt+8, the logical key should be "{"
            // Also not checking if this is a release event because then this issue would
            // still affect the key release.
@@ -166,11 +168,11 @@ pub fn code_to_key(key: PhysicalKey, scancode: u16) -> Key {
    Key::Named(match code {
        KeyCode::Enter => NamedKey::Enter,
        KeyCode::Tab => NamedKey::Tab,
-        KeyCode::Space => return Key::Character(" ".into()),
+        KeyCode::Space => NamedKey::Space,
        KeyCode::Backspace => NamedKey::Backspace,
        KeyCode::Escape => NamedKey::Escape,
-        KeyCode::MetaRight => NamedKey::Meta,
-        KeyCode::MetaLeft => NamedKey::Meta,
+        KeyCode::SuperRight => NamedKey::Super,
+        KeyCode::SuperLeft => NamedKey::Super,
        KeyCode::ShiftLeft => NamedKey::Shift,
        KeyCode::AltLeft => NamedKey::Alt,
        KeyCode::ControlLeft => NamedKey::Control,
@@ -240,8 +242,8 @@ pub fn code_to_location(key: PhysicalKey) -> KeyLocation {
    };

    match code {
-        KeyCode::MetaRight => KeyLocation::Right,
-        KeyCode::MetaLeft => KeyLocation::Left,
+        KeyCode::SuperRight => KeyLocation::Right,
+        KeyCode::SuperLeft => KeyLocation::Left,
        KeyCode::ShiftLeft => KeyLocation::Left,
        KeyCode::AltLeft => KeyLocation::Left,
        KeyCode::ControlLeft => KeyLocation::Left,
@@ -300,15 +302,15 @@ const NX_DEVICERALTKEYMASK: NSEventModifierFlags = NSEventModifierFlags(0x000000
 const NX_DEVICERCTLKEYMASK: NSEventModifierFlags = NSEventModifierFlags(0x00002000);

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

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

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

@@ -324,15 +326,16 @@ pub(super) fn event_mods(event: &NSEvent) -> Modifiers {
    pressed_mods.set(ModifiersKeys::LALT, flags.contains(NX_DEVICELALTKEYMASK));
    pressed_mods.set(ModifiersKeys::RALT, flags.contains(NX_DEVICERALTKEYMASK));

-    state.set(ModifiersState::META, flags.contains(NSEventModifierFlags::Command));
-    pressed_mods.set(ModifiersKeys::LMETA, flags.contains(NX_DEVICELCMDKEYMASK));
-    pressed_mods.set(ModifiersKeys::RMETA, flags.contains(NX_DEVICERCMDKEYMASK));
+    state.set(ModifiersState::SUPER, flags.contains(NSEventModifierFlags::Command));
+    pressed_mods.set(ModifiersKeys::LSUPER, flags.contains(NX_DEVICELCMDKEYMASK));
+    pressed_mods.set(ModifiersKeys::RSUPER, flags.contains(NX_DEVICERCMDKEYMASK));

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

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

-pub fn physicalkey_to_scancode(physical_key: PhysicalKey) -> Option<u32> {
+pub(crate) fn physicalkey_to_scancode(physical_key: PhysicalKey) -> Option<u32> {
    let code = match physical_key {
        PhysicalKey::Code(code) => code,
        PhysicalKey::Unidentified(_) => return None,
@@ -405,8 +409,8 @@ pub fn physicalkey_to_scancode(physical_key: PhysicalKey) -> Option<u32> {
        KeyCode::Backquote => Some(0x32),
        KeyCode::Backspace => Some(0x33),
        KeyCode::Escape => Some(0x35),
-        KeyCode::MetaRight => Some(0x36),
-        KeyCode::MetaLeft => Some(0x37),
+        KeyCode::SuperRight => Some(0x36),
+        KeyCode::SuperLeft => Some(0x37),
        KeyCode::ShiftLeft => Some(0x38),
        KeyCode::CapsLock => Some(0x39),
        KeyCode::AltLeft => Some(0x3a),
@@ -477,7 +481,7 @@ pub fn physicalkey_to_scancode(physical_key: PhysicalKey) -> Option<u32> {
    }
 }

-pub fn scancode_to_physicalkey(scancode: u32) -> PhysicalKey {
+pub(crate) 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
@@ -551,8 +555,8 @@ pub fn scancode_to_physicalkey(scancode: u32) -> PhysicalKey {
        0x33 => KeyCode::Backspace,
        // 0x34 => unknown, // kVK_Powerbook_KeypadEnter
        0x35 => KeyCode::Escape,
-        0x36 => KeyCode::MetaRight,
-        0x37 => KeyCode::MetaLeft,
+        0x36 => KeyCode::SuperRight,
+        0x37 => KeyCode::SuperLeft,
        0x38 => KeyCode::ShiftLeft,
        0x39 => KeyCode::CapsLock,
        0x3a => KeyCode::AltLeft,
--- a/src/platform_impl/apple/appkit/event_loop.rs
+++ b/src/platform_impl/apple/appkit/event_loop.rs
@@ -1,38 +1,37 @@
 use std::rc::Rc;
 use std::sync::Arc;
-use std::time::{Duration, Instant};
+use std::time::Duration;

-use objc2::rc::{Retained, autoreleasepool};
+use objc2::rc::{autoreleasepool, Retained};
 use objc2::runtime::ProtocolObject;
-use objc2::{MainThreadMarker, available};
+use objc2::{available, MainThreadMarker};
 use objc2_app_kit::{
    NSApplication, NSApplicationActivationPolicy, NSApplicationDidFinishLaunchingNotification,
-    NSApplicationWillTerminateNotification, NSWindow,
+    NSApplicationWillTerminateNotification, NSEventMask, NSWindow,
+};
+use objc2_foundation::{
+    NSDate, NSDefaultRunLoopMode, NSNotificationCenter, NSObjectProtocol, NSTimeInterval,
 };
-use objc2_core_foundation::{CFIndex, CFRunLoopActivity, kCFRunLoopCommonModes};
-use objc2_foundation::{NSNotificationCenter, NSObjectProtocol};
 use rwh_06::HasDisplayHandle;
-use tracing::debug_span;
-use winit_common::core_foundation::{MainRunLoop, MainRunLoopObserver, tracing_observers};
-use winit_common::foundation::create_observer;
-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 crate::ActivationPolicy;
-use crate::window::Window;
+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 RootMonitorHandle;
+use crate::platform::macos::ActivationPolicy;
+use crate::platform::pump_events::PumpStatus;
+use crate::platform_impl::Window;
+use crate::window::{CustomCursor as RootCustomCursor, CustomCursorSource, Theme};

 #[derive(Debug)]
 pub struct ActiveEventLoop {
@@ -65,29 +64,25 @@ impl RootActiveEventLoop for ActiveEventLoop {

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

    fn create_custom_cursor(
        &self,
        source: CustomCursorSource,
-    ) -> Result<CoreCustomCursor, RequestError> {
-        Ok(CoreCustomCursor(Arc::new(CustomCursor::new(source)?)))
+    ) -> Result<RootCustomCursor, RequestError> {
+        Ok(RootCustomCursor { inner: CustomCursor::new(source.inner)? })
    }

-    fn available_monitors(&self) -> Box<dyn Iterator<Item = CoreMonitorHandle>> {
-        Box::new(
-            monitor::available_monitors()
-                .into_iter()
-                .map(|monitor| CoreMonitorHandle(Arc::new(monitor))),
-        )
+    fn available_monitors(&self) -> Box<dyn Iterator<Item = RootMonitorHandle>> {
+        Box::new(monitor::available_monitors().into_iter().map(|inner| RootMonitorHandle { inner }))
    }

-    fn primary_monitor(&self) -> Option<winit_core::monitor::MonitorHandle> {
+    fn primary_monitor(&self) -> Option<crate::monitor::MonitorHandle> {
        let monitor = monitor::primary_monitor();
-        Some(CoreMonitorHandle(Arc::new(monitor)))
+        Some(RootMonitorHandle { inner: monitor })
    }

    fn listen_device_events(&self, _allowed: DeviceEvents) {}
@@ -135,7 +130,6 @@ impl rwh_06::HasDisplayHandle for ActiveEventLoop {
    }
 }

-#[derive(Debug)]
 pub struct EventLoop {
    /// Store a reference to the application for convenience.
    ///
@@ -144,6 +138,9 @@ pub struct EventLoop {
    app: Retained<NSApplication>,
    app_state: Rc<AppState>,

+    /// Whether an outer event loop is running.
+    pump_has_sent_init: bool,
+
    window_target: ActiveEventLoop,

    // Since macOS 10.11, we no longer need to remove the observers before they are deallocated;
@@ -152,17 +149,13 @@ pub struct EventLoop {
    // Though we do still need to keep the observers around to prevent them from being deallocated.
    _did_finish_launching_observer: Retained<ProtocolObject<dyn NSObjectProtocol>>,
    _will_terminate_observer: Retained<ProtocolObject<dyn NSObjectProtocol>>,
-
-    _tracing_observers: Option<(MainRunLoopObserver, MainRunLoopObserver)>,
-    _before_waiting_observer: MainRunLoopObserver,
-    _after_waiting_observer: MainRunLoopObserver,
 }

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

 impl Default for PlatformSpecificEventLoopAttributes {
@@ -172,7 +165,9 @@ impl Default for PlatformSpecificEventLoopAttributes {
 }

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

@@ -188,8 +183,7 @@ 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);
@@ -197,7 +191,16 @@ impl EventLoop {
        // Override `sendEvent:` on the application to forward to our application state.
        override_send_event(&app);

-        let center = NSNotificationCenter::defaultCenter();
+        // Queue `NSApplicationDidFinishLaunchingNotification` and generally
+        // make sure the application is fully initialized (once the run loop
+        // starts).
+        //
+        // This is technically only necessary when using `pump_app_events`
+        // (`app.run()` will do it for us in `run_app_on_demand`), but we
+        // might as well do it everywhere.
+        unsafe { app.finishLaunching() };
+
+        let center = unsafe { NSNotificationCenter::defaultCenter() };

        let weak_app_state = Rc::downgrade(&app_state);
        let _did_finish_launching_observer = create_observer(
@@ -205,7 +208,6 @@ impl EventLoop {
            // `applicationDidFinishLaunching:`
            unsafe { NSApplicationDidFinishLaunchingNotification },
            move |notification| {
-                let _entered = debug_span!("NSApplicationDidFinishLaunchingNotification").entered();
                if let Some(app_state) = weak_app_state.upgrade() {
                    app_state.did_finish_launching(notification);
                }
@@ -218,55 +220,21 @@ impl EventLoop {
            // `applicationWillTerminate:`
            unsafe { NSApplicationWillTerminateNotification },
            move |notification| {
-                let _entered = debug_span!("NSApplicationWillTerminateNotification").entered();
                if let Some(app_state) = weak_app_state.upgrade() {
                    app_state.will_terminate(notification);
                }
            },
        );

-        let main_loop = MainRunLoop::get(mtm);
-        let mode = unsafe { kCFRunLoopCommonModes }.unwrap();
-
-        // Tracing observers have the lowest and highest orderings.
-        let _tracing_observers = tracing_observers(mtm).inspect(|(start, end)| {
-            main_loop.add_observer(start, mode);
-            main_loop.add_observer(end, mode);
-        });
-
-        let app_state_clone = Rc::clone(&app_state);
-        let _before_waiting_observer = MainRunLoopObserver::new(
-            mtm,
-            CFRunLoopActivity::BeforeWaiting,
-            true,
-            // Queued with the second-lowest priority (tracing observers use the lowest) to ensure
-            // it is processed after other observers.
-            CFIndex::MAX - 1,
-            move |_| app_state_clone.cleared(),
-        );
-        main_loop.add_observer(&_before_waiting_observer, mode);
-
-        let app_state_clone = Rc::clone(&app_state);
-        let _after_waiting_observer = MainRunLoopObserver::new(
-            mtm,
-            CFRunLoopActivity::AfterWaiting,
-            true,
-            // Queued with the second-highest priority (tracing observers use the highest) to
-            // ensure it is processed before other observers.
-            CFIndex::MIN + 1,
-            move |_| app_state_clone.wakeup(),
-        );
-        main_loop.add_observer(&_after_waiting_observer, mode);
+        setup_control_flow_observers(mtm);

        Ok(EventLoop {
            app,
            app_state: app_state.clone(),
+            pump_has_sent_init: false,
            window_target: ActiveEventLoop { app_state, mtm },
            _did_finish_launching_observer,
            _will_terminate_observer,
-            _tracing_observers,
-            _before_waiting_observer,
-            _after_waiting_observer,
        })
    }

@@ -274,29 +242,30 @@ impl EventLoop {
        &self.window_target
    }

-    // NB: we don't base this on `pump_events` because for `MacOs` we can't support
-    // `pump_events` elegantly (we just ask to run the loop for a "short" amount of
-    // time and so a layered implementation would end up using a lot of CPU due to
-    // redundant wake ups.
+    pub fn run_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,
-        app: A,
+        mut app: A,
    ) -> Result<(), EventLoopError> {
        self.app_state.clear_exit();
-        self.app_state.set_event_handler(app, || {
+        self.app_state.set_event_handler(&mut app, || {
            autoreleasepool(|_| {
-                // clear / normalize pump_events state
-                self.app_state.set_wait_timeout(None);
-                self.app_state.set_stop_before_wait(false);
-                self.app_state.set_stop_after_wait(false);
-                self.app_state.set_stop_on_redraw(false);
-
                if self.app_state.is_launched() {
-                    debug_assert!(!self.app_state.is_running());
-                    self.app_state.set_is_running(true);
+                    // The `NSApplicationDidFinishLaunchingNotification` notification is globally
+                    // only delivered once, but for the purpose of our events, we want to act
+                    // as-if an entirely new event loop has been started on each invocation of
+                    // `run_app_on_demand`.
                    self.app_state.dispatch_init_events();
                }

+                // NOTE: We don't base this on `pump_events` because
+                // `nextEventMatchingMask:untilDate:inMode:dequeue:` is worse supported,
+                // especially as the top-level handler. In part because this sets the `isRunning`
+                // flag (which is used by crates like `rfd`), while `nextEventMatchingMask` won't.
+                //
                // NOTE: Make sure to not run the application re-entrantly, as that'd be confusing.
                self.app.run();

@@ -310,53 +279,47 @@ impl EventLoop {
    pub fn pump_app_events<A: ApplicationHandler>(
        &mut self,
        timeout: Option<Duration>,
-        app: A,
+        mut app: A,
    ) -> PumpStatus {
-        self.app_state.set_event_handler(app, || {
+        self.app_state.set_event_handler(&mut app, || {
            autoreleasepool(|_| {
-                // As a special case, if the application hasn't been launched yet then we at least
-                // run the loop until it has fully launched.
-                if !self.app_state.is_launched() {
-                    debug_assert!(!self.app_state.is_running());
-
-                    self.app_state.set_stop_on_launch();
-                    self.app.run();
-
-                    // Note: we dispatch `NewEvents(Init)` + `Resumed` events after the application
-                    // has launched
-                } else if !self.app_state.is_running() {
-                    // Even though the application may have been launched, it's possible we aren't
-                    // running if the `EventLoop` was run before and has since
-                    // exited. This indicates that we just starting to re-run
-                    // the same `EventLoop` again.
-                    self.app_state.set_is_running(true);
+                if self.app_state.is_launched() && !self.pump_has_sent_init {
+                    // If the application is already launched, we won't get the re-initialization
+                    // events. Dispatch them here instead.
                    self.app_state.dispatch_init_events();
-                } else {
-                    // Only run for as long as the given `Duration` allows so we don't block the
-                    // external loop.
-                    match timeout {
-                        Some(Duration::ZERO) => {
-                            self.app_state.set_wait_timeout(None);
-                            self.app_state.set_stop_before_wait(true);
-                        },
-                        Some(duration) => {
-                            self.app_state.set_stop_before_wait(false);
-                            let timeout = Instant::now() + duration;
-                            self.app_state.set_wait_timeout(Some(timeout));
-                            self.app_state.set_stop_after_wait(true);
-                        },
-                        None => {
-                            self.app_state.set_wait_timeout(None);
-                            self.app_state.set_stop_before_wait(false);
-                            self.app_state.set_stop_after_wait(true);
-                        },
-                    }
-                    self.app_state.set_stop_on_redraw(true);
-                    self.app.run();
+                }
+                self.pump_has_sent_init = true;
+
+                // Only run for as long as the given `Duration` allows so we don't block the
+                // external loop.
+                let expiration_date = match timeout {
+                    Some(Duration::ZERO) => unsafe { NSDate::distantPast() },
+                    Some(duration) => unsafe {
+                        NSDate::dateWithTimeIntervalSinceNow(
+                            duration.as_secs_f64() as NSTimeInterval
+                        )
+                    },
+                    None => unsafe { NSDate::distantFuture() },
+                };
+
+                // Wait for an event to arrive within the specified duration,
+                // and let the application handle it if one did.
+                let event = unsafe {
+                    self.app.nextEventMatchingMask_untilDate_inMode_dequeue(
+                        NSEventMask::Any,
+                        Some(&expiration_date),
+                        NSDefaultRunLoopMode,
+                        true,
+                    )
+                };
+                if let Some(event) = event {
+                    unsafe { self.app.sendEvent(&event) };
                }

                if self.app_state.exiting() {
                    self.app_state.internal_exit();
+                    // If we start again, we'll emit a new set of initialization events.
+                    self.pump_has_sent_init = false;
                    PumpStatus::Exit(0)
                } else {
                    PumpStatus::Continue
@@ -383,19 +346,3 @@ pub(super) fn stop_app_immediately(app: &NSApplication) {
        app.postEvent_atStart(&dummy_event().unwrap(), true);
    });
 }
-
-/// Tell all windows to close.
-///
-/// This will synchronously trigger `WindowEvent::Destroyed` within
-/// `windowWillClose:`, giving the application one last chance to handle
-/// those events. It doesn't matter if the user also ends up closing the
-/// windows in `Window`'s `Drop` impl, once a window has been closed once, it
-/// stays closed.
-///
-/// This ensures that no windows linger on after the event loop has exited,
-/// see <https://github.com/rust-windowing/winit/issues/4135>.
-pub(super) fn notify_windows_of_exit(app: &NSApplication) {
-    for window in app.windows() {
-        window.close();
-    }
-}
--- a/src/platform_impl/apple/appkit/ffi.rs
+++ b/src/platform_impl/apple/appkit/ffi.rs
@@ -1,19 +1,36 @@
 // TODO: Upstream these

-#![allow(non_upper_case_globals)]
+#![allow(dead_code, non_snake_case, non_upper_case_globals)]

 use std::ffi::c_void;

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

+pub const kCGDisplayBlendNormal: f32 = 0.0;
+pub const kCGDisplayBlendSolidColor: f32 = 1.0;
+
+pub type CGDisplayFadeReservationToken = u32;
+pub const kCGDisplayFadeReservationInvalidToken: CGDisplayFadeReservationToken = 0;
+
+pub const IO1BitIndexedPixels: &str = "P";
+pub const IO2BitIndexedPixels: &str = "PP";
+pub const IO4BitIndexedPixels: &str = "PPPP";
+pub const IO8BitIndexedPixels: &str = "PPPPPPPP";
 pub const IO16BitDirectPixels: &str = "-RRRRRGGGGGBBBBB";
 pub const IO32BitDirectPixels: &str = "--------RRRRRRRRGGGGGGGGBBBBBBBB";
+
 pub const kIO30BitDirectPixels: &str = "--RRRRRRRRRRGGGGGGGGGGBBBBBBBBBB";
 pub const kIO64BitDirectPixels: &str = "-16R16G16B16";

+pub const kIO16BitFloatPixels: &str = "-16FR16FG16FB16";
+pub const kIO32BitFloatPixels: &str = "-32FR32FG32FB32";
+
+pub const IOYUV422Pixels: &str = "Y4U2V2";
+pub const IO8BitOverlayPixels: &str = "O8";
+
 // `CGDisplayCreateUUIDFromDisplayID` comes from the `ColorSync` framework.
 // However, that framework was only introduced "publicly" in macOS 10.13.
 //
@@ -22,14 +39,12 @@ pub const kIO64BitDirectPixels: &str = "-16R16G16B16";
 // `ApplicationServices`, see:
 // https://developer.apple.com/library/archive/documentation/MacOSX/Conceptual/OSX_Technology_Overview/SystemFrameworks/SystemFrameworks.html#//apple_ref/doc/uid/TP40001067-CH210-BBCFFIEG
 #[link(name = "ApplicationServices", kind = "framework")]
-unsafe extern "C" {
+extern "C" {
    pub fn CGDisplayCreateUUIDFromDisplayID(display: CGDirectDisplayID) -> *mut CFUUID;
-
-    pub fn CGDisplayGetDisplayIDFromUUID(uuid: &CFUUID) -> CGDirectDisplayID;
 }

 #[link(name = "CoreGraphics", kind = "framework")]
-unsafe extern "C" {
+extern "C" {
    // Wildly used private APIs; Apple uses them for their Terminal.app.
    pub fn CGSMainConnectionID() -> *mut AnyObject;
    pub fn CGSSetWindowBackgroundBlurRadius(
@@ -43,6 +58,7 @@ unsafe extern "C" {
 pub struct TISInputSource(std::ffi::c_void);

 cf_type!(
+    #[encoding_name = "__TISInputSource"]
    unsafe impl TISInputSource {}
 );

@@ -60,7 +76,7 @@ pub const kUCKeyActionDisplay: u16 = 3;
 pub const kUCKeyTranslateNoDeadKeysMask: OptionBits = 1;

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

    #[allow(non_snake_case)]
@@ -87,3 +103,45 @@ unsafe extern "C" {
        unicodeString: *mut UniChar,
    ) -> OSStatus;
 }
+
+// CGWindowLevel.h
+//
+// Note: There are two different things at play in this header:
+// `CGWindowLevel` and `CGWindowLevelKey`.
+//
+// It seems like there was a push towards using "key" values instead of the
+// raw window level values, and then you were supposed to use
+// `CGWindowLevelForKey` to get the actual level.
+//
+// But the values that `NSWindowLevel` has are compiled in, and as such has
+// to remain ABI compatible, so they're safe for us to hardcode as well.
+#[allow(dead_code, non_upper_case_globals)]
+mod window_level {
+    const kCGNumReservedWindowLevels: i32 = 16;
+    const kCGNumReservedBaseWindowLevels: i32 = 5;
+
+    pub const kCGBaseWindowLevel: i32 = i32::MIN;
+    pub const kCGMinimumWindowLevel: i32 = kCGBaseWindowLevel + kCGNumReservedBaseWindowLevels;
+    pub const kCGMaximumWindowLevel: i32 = i32::MAX - kCGNumReservedWindowLevels;
+
+    pub const kCGDesktopWindowLevel: i32 = kCGMinimumWindowLevel + 20;
+    pub const kCGDesktopIconWindowLevel: i32 = kCGDesktopWindowLevel + 20;
+    pub const kCGBackstopMenuLevel: i32 = -20;
+    pub const kCGNormalWindowLevel: i32 = 0;
+    pub const kCGFloatingWindowLevel: i32 = 3;
+    pub const kCGTornOffMenuWindowLevel: i32 = 3;
+    pub const kCGModalPanelWindowLevel: i32 = 8;
+    pub const kCGUtilityWindowLevel: i32 = 19;
+    pub const kCGDockWindowLevel: i32 = 20;
+    pub const kCGMainMenuWindowLevel: i32 = 24;
+    pub const kCGStatusWindowLevel: i32 = 25;
+    pub const kCGPopUpMenuWindowLevel: i32 = 101;
+    pub const kCGOverlayWindowLevel: i32 = 102;
+    pub const kCGHelpWindowLevel: i32 = 200;
+    pub const kCGDraggingWindowLevel: i32 = 500;
+    pub const kCGScreenSaverWindowLevel: i32 = 1000;
+    pub const kCGAssistiveTechHighWindowLevel: i32 = 1500;
+    pub const kCGCursorWindowLevel: i32 = kCGMaximumWindowLevel - 1;
+}
+
+pub use window_level::*;
--- 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::{MainThreadMarker, sel};
+use objc2::{sel, MainThreadMarker};
 use objc2_app_kit::{NSApplication, NSEventModifierFlags, NSMenu, NSMenuItem};
-use objc2_foundation::{NSBundle, NSProcessInfo, NSString, ns_string};
+use objc2_foundation::{ns_string, NSProcessInfo, NSString};

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

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

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

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

--- a/src/platform_impl/apple/appkit/mod.rs
+++ b/src/platform_impl/apple/appkit/mod.rs
@@ -0,0 +1,27 @@
+#[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::cursor::CustomCursor as PlatformCustomCursor;
+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;
+pub(crate) use crate::cursor::OnlyCursorImageSource as PlatformCustomCursorSource;
+pub(crate) use crate::icon::NoIcon as PlatformIcon;
+pub(crate) use crate::platform_impl::Fullscreen;
--- a/src/platform_impl/apple/appkit/monitor.rs
+++ b/src/platform_impl/apple/appkit/monitor.rs
@@ -0,0 +1,355 @@
+#![allow(clippy::unnecessary_cast)]
+
+use std::collections::VecDeque;
+use std::num::{NonZeroU16, NonZeroU32};
+use std::ptr::NonNull;
+use std::{fmt, ptr};
+
+use dispatch2::run_on_main;
+use objc2::rc::Retained;
+use objc2::MainThreadMarker;
+use objc2_app_kit::NSScreen;
+use objc2_core_foundation::{
+    CFArrayGetCount, CFArrayGetValueAtIndex, CFRetained, CFUUIDGetUUIDBytes,
+};
+#[allow(deprecated)]
+use objc2_core_graphics::{
+    CGDirectDisplayID, CGDisplayBounds, CGDisplayCopyAllDisplayModes, CGDisplayCopyDisplayMode,
+    CGDisplayMode, CGDisplayModeCopyPixelEncoding, CGDisplayModeGetPixelHeight,
+    CGDisplayModeGetPixelWidth, CGDisplayModeGetRefreshRate, CGDisplayModelNumber,
+    CGGetActiveDisplayList, CGMainDisplayID,
+};
+#[allow(deprecated)]
+use objc2_core_video::{
+    kCVReturnSuccess, CVDisplayLinkCreateWithCGDisplay,
+    CVDisplayLinkGetNominalOutputVideoRefreshPeriod, CVTimeFlags,
+};
+use objc2_foundation::{ns_string, NSNumber, NSPoint, NSRect};
+
+use super::ffi;
+use super::util::cgerr;
+use crate::dpi::{LogicalPosition, PhysicalPosition, PhysicalSize};
+use crate::monitor::VideoMode;
+
+#[derive(Clone)]
+pub struct VideoModeHandle {
+    pub(crate) mode: VideoMode,
+    pub(crate) monitor: MonitorHandle,
+    pub(crate) native_mode: NativeDisplayMode,
+}
+
+impl PartialEq for VideoModeHandle {
+    fn eq(&self, other: &Self) -> bool {
+        self.monitor == other.monitor && self.mode == other.mode
+    }
+}
+
+impl Eq for VideoModeHandle {}
+
+impl std::hash::Hash for VideoModeHandle {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.monitor.hash(state);
+    }
+}
+
+impl std::fmt::Debug for VideoModeHandle {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("VideoMode")
+            .field("mode", &self.mode)
+            .field("monitor", &self.monitor)
+            .finish()
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct NativeDisplayMode(pub CFRetained<CGDisplayMode>);
+
+unsafe impl Send for NativeDisplayMode {}
+unsafe impl Sync for NativeDisplayMode {}
+
+impl VideoModeHandle {
+    fn new(
+        monitor: MonitorHandle,
+        native_mode: NativeDisplayMode,
+        refresh_rate_millihertz: Option<NonZeroU32>,
+    ) -> Self {
+        unsafe {
+            #[allow(deprecated)]
+            let pixel_encoding =
+                CGDisplayModeCopyPixelEncoding(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!()
+            };
+
+            let mode = VideoMode {
+                size: PhysicalSize::new(
+                    CGDisplayModeGetPixelWidth(Some(&native_mode.0)) as u32,
+                    CGDisplayModeGetPixelHeight(Some(&native_mode.0)) as u32,
+                ),
+                refresh_rate_millihertz,
+                bit_depth: NonZeroU16::new(bit_depth),
+            };
+
+            VideoModeHandle { mode, monitor: monitor.clone(), native_mode }
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct MonitorHandle(CGDirectDisplayID);
+
+impl MonitorHandle {
+    /// Internal comparisons of [`MonitorHandle`]s are done first requesting a UUID for the handle.
+    fn uuid(&self) -> [u8; 16] {
+        let ptr = unsafe { ffi::CGDisplayCreateUUIDFromDisplayID(self.0) };
+        let cf_uuid = unsafe { CFRetained::from_raw(NonNull::new(ptr).unwrap()) };
+        unsafe { CFUUIDGetUUIDBytes(&cf_uuid) }.into()
+    }
+}
+
+// `CGDirectDisplayID` changes on video mode change, so we cannot rely on that
+// for comparisons, but we can use `CGDisplayCreateUUIDFromDisplayID` to get an
+// unique identifier that persists even across system reboots
+impl PartialEq for MonitorHandle {
+    fn eq(&self, other: &Self) -> bool {
+        self.uuid() == other.uuid()
+    }
+}
+
+impl Eq for MonitorHandle {}
+
+impl PartialOrd for MonitorHandle {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for MonitorHandle {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.uuid().cmp(&other.uuid())
+    }
+}
+
+impl std::hash::Hash for MonitorHandle {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.uuid().hash(state);
+    }
+}
+
+pub fn available_monitors() -> VecDeque<MonitorHandle> {
+    let mut expected_count = 0;
+    let res = cgerr(unsafe { CGGetActiveDisplayList(0, ptr::null_mut(), &mut expected_count) });
+    if res.is_err() {
+        return VecDeque::with_capacity(0);
+    }
+
+    let mut displays: Vec<CGDirectDisplayID> = vec![0; expected_count as usize];
+    let mut actual_count = 0;
+    let res = cgerr(unsafe {
+        CGGetActiveDisplayList(expected_count, displays.as_mut_ptr(), &mut actual_count)
+    });
+    displays.truncate(actual_count as usize);
+
+    if res.is_err() {
+        return VecDeque::with_capacity(0);
+    }
+
+    let mut monitors = VecDeque::with_capacity(displays.len());
+    for display in displays {
+        monitors.push_back(MonitorHandle(display));
+    }
+    monitors
+}
+
+pub fn primary_monitor() -> MonitorHandle {
+    MonitorHandle(unsafe { CGMainDisplayID() })
+}
+
+impl fmt::Debug for MonitorHandle {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("MonitorHandle")
+            .field("name", &self.name())
+            .field("native_identifier", &self.native_identifier())
+            .field("position", &self.position())
+            .field("scale_factor", &self.scale_factor())
+            .finish_non_exhaustive()
+    }
+}
+
+impl MonitorHandle {
+    pub fn new(id: CGDirectDisplayID) -> Self {
+        MonitorHandle(id)
+    }
+
+    // TODO: Be smarter about this:
+    // <https://github.com/glfw/glfw/blob/57cbded0760a50b9039ee0cb3f3c14f60145567c/src/cocoa_monitor.m#L44-L126>
+    pub fn name(&self) -> Option<String> {
+        let screen_num = unsafe { CGDisplayModelNumber(self.0) };
+        Some(format!("Monitor #{screen_num}"))
+    }
+
+    #[inline]
+    pub fn native_identifier(&self) -> u32 {
+        self.0
+    }
+
+    #[inline]
+    pub fn position(&self) -> Option<PhysicalPosition<i32>> {
+        // 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.0) };
+        let position = LogicalPosition::new(bounds.origin.x, bounds.origin.y);
+        Some(position.to_physical(self.scale_factor()))
+    }
+
+    pub fn scale_factor(&self) -> f64 {
+        run_on_main(|mtm| {
+            match self.ns_screen(mtm) {
+                Some(screen) => screen.backingScaleFactor() as f64,
+                None => 1.0, // default to 1.0 when we can't find the screen
+            }
+        })
+    }
+
+    fn refresh_rate_millihertz(&self) -> Option<NonZeroU32> {
+        let current_display_mode =
+            NativeDisplayMode(unsafe { CGDisplayCopyDisplayMode(self.0) }.unwrap());
+        refresh_rate_millihertz(self.0, &current_display_mode)
+    }
+
+    pub fn current_video_mode(&self) -> Option<VideoMode> {
+        let mode = NativeDisplayMode(unsafe { CGDisplayCopyDisplayMode(self.0) }.unwrap());
+        let refresh_rate_millihertz = refresh_rate_millihertz(self.0, &mode);
+        Some(VideoModeHandle::new(self.clone(), mode, refresh_rate_millihertz).mode)
+    }
+
+    pub fn video_modes(&self) -> impl Iterator<Item = VideoMode> {
+        self.video_modes_handles().map(|handle| handle.mode)
+    }
+
+    pub(crate) fn video_modes_handles(&self) -> impl Iterator<Item = VideoModeHandle> {
+        let refresh_rate_millihertz = self.refresh_rate_millihertz();
+        let monitor = self.clone();
+
+        unsafe {
+            let modes = {
+                let array = CGDisplayCopyAllDisplayModes(self.0, None)
+                    .expect("failed to get list of display modes");
+                let array_count = CFArrayGetCount(&array);
+                let modes: Vec<_> = (0..array_count)
+                    .map(move |i| {
+                        let mode = CFArrayGetValueAtIndex(&array, i) as *mut CGDisplayMode;
+                        CFRetained::retain(NonNull::new(mode).unwrap())
+                    })
+                    .collect();
+                modes
+            };
+
+            modes.into_iter().map(move |mode| {
+                let cg_refresh_rate_hertz = CGDisplayModeGetRefreshRate(Some(&mode)).round() as i64;
+
+                // CGDisplayModeGetRefreshRate returns 0.0 for any display that
+                // isn't a CRT
+                let refresh_rate_millihertz = if cg_refresh_rate_hertz > 0 {
+                    NonZeroU32::new((cg_refresh_rate_hertz * 1000) as u32)
+                } else {
+                    refresh_rate_millihertz
+                };
+
+                VideoModeHandle::new(
+                    monitor.clone(),
+                    NativeDisplayMode(mode),
+                    refresh_rate_millihertz,
+                )
+            })
+        }
+    }
+
+    pub(crate) fn ns_screen(&self, mtm: MainThreadMarker) -> Option<Retained<NSScreen>> {
+        let uuid = self.uuid();
+        NSScreen::screens(mtm).into_iter().find(|screen| {
+            let other_native_id = get_display_id(screen);
+            let other = MonitorHandle::new(other_native_id);
+            uuid == other.uuid()
+        })
+    }
+}
+
+pub(crate) fn get_display_id(screen: &NSScreen) -> u32 {
+    let key = ns_string!("NSScreenNumber");
+
+    objc2::rc::autoreleasepool(|_| {
+        let device_description = screen.deviceDescription();
+
+        // Retrieve the CGDirectDisplayID associated with this screen
+        //
+        // The value from @"NSScreenNumber" in deviceDescription is guaranteed
+        // to be an NSNumber. See documentation for details:
+        // <https://developer.apple.com/documentation/appkit/nsscreen/1388360-devicedescription?language=objc>
+        let obj = device_description
+            .objectForKey(key)
+            .expect("failed getting screen display id from device description")
+            .downcast::<NSNumber>()
+            .expect("NSScreenNumber must be NSNumber");
+
+        obj.as_u32()
+    })
+}
+
+/// Core graphics screen coordinates are relative to the top-left corner of
+/// the so-called "main" display, with y increasing downwards - which is
+/// exactly what we want in Winit.
+///
+/// However, `NSWindow` and `NSScreen` changes these coordinates to:
+/// 1. Be relative to the bottom-left corner of the "main" screen.
+/// 2. Be relative to the bottom-left corner of the window/screen itself.
+/// 3. Have y increasing upwards.
+///
+/// This conversion happens to be symmetric, so we only need this one function
+/// to convert between the two coordinate systems.
+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 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 = CGDisplayModeGetRefreshRate(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 CVDisplayLinkCreateWithCGDisplay(id, NonNull::from(&mut display_link))
+            != kCVReturnSuccess
+        {
+            return None;
+        }
+        let display_link = CFRetained::from_raw(NonNull::new(display_link).unwrap());
+        #[allow(deprecated)]
+        let time = CVDisplayLinkGetNominalOutputVideoRefreshPeriod(&display_link);
+
+        // 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)
+    }
+}
--- a/Show More
+++ b/Show More