chore: bump the github-actions group across 1 directory with 3 updates

Bumps the github-actions group with 3 updates in the / directory: [actions/cache](https://github.com/actions/cache), [actions/checkout](https://github.com/actions/checkout) and [actions/upload-pages-artifact](https://github.com/actions/upload-pages-artifact). Updates `actions/cache` from 5 to 6 - [Release notes](https://github.com/actions/cache/releases) - [Changelog](https://github.com/actions/cache/blob/main/RELEASES.md) - [Commits](https://github.com/actions/cache/compare/v5...v6) Updates `actions/checkout` from 6 to 7 - [Release notes](https://github.com/actions/checkout/releases) - [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md) - [Commits](https://github.com/actions/checkout/compare/v6...v7) Updates `actions/upload-pages-artifact` from 4 to 5 - [Release notes](https://github.com/actions/upload-pages-artifact/releases) - [Commits](https://github.com/actions/upload-pages-artifact/compare/v4...v5) --- updated-dependencies: - dependency-name: actions/cache dependency-version: '6' dependency-type: direct:production update-type: version-update:semver-major dependency-group: github-actions - dependency-name: actions/checkout dependency-version: '7' dependency-type: direct:production update-type: version-update:semver-major dependency-group: github-actions - dependency-name: actions/upload-pages-artifact dependency-version: '5' dependency-type: direct:production update-type: version-update:semver-major dependency-group: github-actions ... Signed-off-by: dependabot[bot] <support@github.com>
Fix AppKit live resize redraw timing
2026-06-26 22:53:15 -04:00 · 2026-06-24 18:53:04 +00:00 · 2026-06-24 17:03:24 +02:00 · 2026-06-24 16:58:57 +02:00 · 2026-06-20 01:34:43 +09:00 · 2026-06-15 03:36:22 +09:00
31 changed files with 848 additions and 545 deletions
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -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@v5
+      uses: actions/cache/restore@v6
      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
+      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

    - 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@v5
+      uses: actions/cache@v6
      with:
        path: ~/.cargo/bin/cargo-apk
        # Change this key if we update the required cargo-apk version
@@ -281,7 +281,7 @@ jobs:

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

  cargo-deny:
-    name: Run cargo-deny on ${{ matrix.platform.name }}
+    name: Run cargo-deny
    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
-        manifest-path: winit/Cargo.toml
-        arguments: --all-features --target ${{ matrix.platform.target }}

  eslint:
    name: ESLint
--- a/.github/workflows/docs.yml
+++ b/.github/workflows/docs.yml
@@ -19,7 +19,7 @@ jobs:
      id-token: write

    steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v7

      - 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@v5
+        uses: actions/configure-pages@v6

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

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

      - name: Deploy to GitHub Pages
        id: deployment
-        uses: actions/deploy-pages@v4
+        uses: actions/deploy-pages@v5
--- a/deny.toml
+++ b/deny.toml
@@ -1,27 +1,25 @@
 # https://embarkstudios.github.io/cargo-deny
 # cargo install cargo-deny
-# 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
+# cargo update && cargo deny check
 [graph]
 all-features = true
 exclude-dev = true
 targets = [
-    { 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" },
+    "aarch64-apple-darwin",
+    "aarch64-apple-ios",
+    "aarch64-linux-android",
+    "i686-pc-windows-gnu",
+    "i686-pc-windows-msvc",
+    "i686-unknown-linux-gnu",
    { triple = "wasm32-unknown-unknown", features = [
        "atomics",
    ] },
-    { 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" },
+    "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",
 ]

 [licenses]
@@ -33,6 +31,7 @@ allow = [
    "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 }
@@ -40,47 +39,23 @@ private = { ignore = true }
 [bans]
 multiple-versions = "deny"
 skip = [
-    { crate = "bitflags@1", reason = "the ecosystem is in the process of migrating" },
-    { crate = "rustix@0.38", reason = "the ecosystem is in the process of migrating" },
-    { crate = "linux-raw-sys@0.4", reason = "the ecosystem is in the process of migrating" },
    { 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" },
 ]
-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-globs = ["android-games-sdk/import-games-sdk.sh"]
-crate = "android-activity"
-
-[[bans.build.bypass]]
-allow-globs = ["ci/*", "githooks/*"]
-crate = "zerocopy"
-
-[[bans.build.bypass]]
-allow-globs = ["cherry-pick-stable.sh"]
-crate = "libc"
-
-[[bans.build.bypass]]
-allow-globs = ["freetype2/*"]
-crate = "freetype-sys"
-
-[[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/winit-appkit/src/view.rs
+++ b/winit-appkit/src/view.rs
@@ -3,13 +3,13 @@ use std::cell::{Cell, RefCell};
 use std::collections::{HashMap, VecDeque};
 use std::rc::Rc;

-use dpi::{LogicalPosition, LogicalSize};
+use dpi::{LogicalPosition, PhysicalSize};
 use objc2::rc::Retained;
 use objc2::runtime::{AnyObject, Sel};
 use objc2::{AnyThread, DefinedClass, MainThreadMarker, define_class, msg_send};
 use objc2_app_kit::{
    NSApplication, NSCursor, NSEvent, NSEventPhase, NSResponder, NSTextInputClient, NSTrackingArea,
-    NSTrackingAreaOptions, NSView, NSWindow,
+    NSTrackingAreaOptions, NSView, NSViewLayerContentsRedrawPolicy, NSWindow,
 };
 use objc2_core_foundation::CGRect;
 use objc2_foundation::{
@@ -161,10 +161,20 @@ define_class!(
            //    resize occurring.
            // 2. Even when a window resize does occur on a new tabbed window, it contains the wrong
            //    size (includes tab height).
-            let rect = self.frame();
-            let logical_size = LogicalSize::new(rect.size.width as f64, rect.size.height as f64);
-            let size = logical_size.to_physical::<u32>(self.scale_factor());
-            self.queue_event(WindowEvent::SurfaceResized(size));
+            self.surface_resized();
+            // During live resize, AppKit may not let the normal event loop reach its next redraw
+            // point before stretching the current layer contents. Redraw immediately after the
+            // app has observed the new surface size.
+            self.redraw_during_live_resize();
+        }
+
+        #[unsafe(method(viewDidChangeBackingProperties))]
+        fn view_did_change_backing_properties(&self) {
+            let _entered = debug_span!("viewDidChangeBackingProperties").entered();
+            // Moving between displays or changing scale can alter the drawable backing size
+            // without a matching frame-size change.
+            self.surface_resized();
+            self.redraw_during_live_resize();
        }

        #[unsafe(method(drawRect:))]
@@ -273,27 +283,26 @@ define_class!(
                self.ivars().ime_state.set(ImeState::Ground);
            }

+            let string = string.to_string();
            let cursor_range = if string.is_empty() {
                // An empty string basically means that there's no preedit, so indicate that by
                // sending a `None` cursor range.
                None
            } else {
-                // Clamp to string length to avoid NSRangeException from out-of-bounds
-                // indices sent by macOS IME (e.g. native Pinyin, see
-                // https://github.com/alacritty/alacritty/issues/8791).
-                let len = string.length();
-                let location = selected_range.location.min(len);
-                let end = selected_range.end().min(len);
-                // Convert the selected range from UTF-16 indices to UTF-8 indices.
-                let sub_string_a = string.substringToIndex(location);
-                let sub_string_b = string.substringToIndex(end);
-                let lowerbound_utf8 = sub_string_a.len();
-                let upperbound_utf8 = sub_string_b.len();
+                // Convert the selected range from UTF-16 code unit indices to UTF-8 byte
+                // offsets. `utf16_to_utf8_offset` is defensive: it snaps an offset that would
+                // split a surrogate pair down to the character boundary and clamps an
+                // out-of-bounds offset to the string length, so no `NSRangeException` is
+                // possible and the resulting range can never be inverted (`lower <= upper`).
+                // IMEs are known to send both mid-surrogate and out-of-bounds offsets (e.g.
+                // native Pinyin, see https://github.com/alacritty/alacritty/issues/8791).
+                let lowerbound_utf8 = utf16_to_utf8_offset(&string, selected_range.location);
+                let upperbound_utf8 = utf16_to_utf8_offset(&string, selected_range.end());
                Some((lowerbound_utf8, upperbound_utf8))
            };

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

        #[unsafe(method(unmarkText))]
@@ -796,6 +805,10 @@ impl WinitView {
        let this: Retained<Self> = unsafe { msg_send![super(this), init] };
        *this.ivars().input_source.borrow_mut() = this.current_input_source();

+        // Ask AppKit to redisplay the layer while the view is being resized so layer-backed
+        // surfaces keep painting.
+        this.setLayerContentsRedrawPolicy(NSViewLayerContentsRedrawPolicy::DuringViewResize);
+
        // `MouseEnteredAndExited` enables receiving events through `mouseEntered:` and
        // `mouseExited:`.
        //
@@ -854,6 +867,37 @@ impl WinitView {
        });
    }

+    fn surface_resized(&self) {
+        let Some(window) = (**self).window() else {
+            return;
+        };
+        let size = self.surface_size();
+        let window_id = window_id(&window);
+        self.ivars().app_state.maybe_queue_with_handler(move |app, event_loop| {
+            app.window_event(event_loop, window_id, WindowEvent::SurfaceResized(size));
+        });
+    }
+
+    /// Returns the drawable size from the view's backing-coordinate bounds.
+    pub(super) fn surface_size(&self) -> PhysicalSize<u32> {
+        // The view bounds are authoritative for full-size content views and during live resize.
+        // Deriving this from the window frame can exclude custom titlebar content or be stale.
+        let backing_bounds = self.convertRectToBacking(self.bounds());
+        PhysicalSize::new(
+            backing_bounds.size.width.round().max(0.0) as u32,
+            backing_bounds.size.height.round().max(0.0) as u32,
+        )
+    }
+
+    fn redraw_during_live_resize(&self) {
+        let Some(window) = (**self).window() else {
+            return;
+        };
+        if window.inLiveResize() {
+            self.ivars().app_state.handle_redraw(window_id(&window));
+        }
+    }
+
    fn scale_factor(&self) -> f64 {
        self.window().backingScaleFactor() as f64
    }
@@ -1170,3 +1214,92 @@ fn replace_event(event: &NSEvent, option_as_alt: OptionAsAlt) -> Retained<NSEven
        event.copy()
    }
 }
+
+/// Convert a UTF-16 code unit offset into the corresponding UTF-8 byte offset within `s`.
+///
+/// IMEs are not required to send well-formed offsets, so this is defensive: an offset that
+/// would split a surrogate pair is snapped down to the start of that character, and an
+/// out-of-bounds offset is clamped to the end of the string (e.g. native Pinyin sends
+/// out-of-bounds indices, see <https://github.com/alacritty/alacritty/issues/8791>).
+///
+/// The mapping is monotone non-decreasing, so applying it to the location and end of an
+/// `NSRange` (where `location <= end`) can never produce an inverted byte range.
+fn utf16_to_utf8_offset(s: &str, utf16_offset: usize) -> usize {
+    let mut utf16_pos = 0;
+    for (utf8_pos, ch) in s.char_indices() {
+        if utf16_pos >= utf16_offset {
+            return utf8_pos;
+        }
+        utf16_pos += ch.len_utf16();
+        // The target offset lands strictly inside this character's UTF-16 representation,
+        // i.e. it splits a surrogate pair: snap down to the character boundary.
+        if utf16_pos > utf16_offset {
+            return utf8_pos;
+        }
+    }
+    s.len()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// Apply the UTF-16 -> UTF-8 conversion to both ends of a `selectedRange {loc, len}`,
+    /// mirroring what `set_marked_text` does for the emitted `Ime::Preedit` cursor range.
+    fn convert(s: &str, loc: usize, len: usize) -> (usize, usize) {
+        (utf16_to_utf8_offset(s, loc), utf16_to_utf8_offset(s, loc + len))
+    }
+
+    #[test]
+    fn mid_surrogate_offset_snaps_down() {
+        // "😀a": 😀 is one char = 2 UTF-16 units = 4 UTF-8 bytes; offset 1 is mid-pair.
+        assert_eq!(utf16_to_utf8_offset("\u{1F600}a", 1), 0);
+        // Offset 2 is the boundary just after the pair.
+        assert_eq!(utf16_to_utf8_offset("\u{1F600}a", 2), 4);
+    }
+
+    #[test]
+    fn no_longer_inverted() {
+        // "a😀b" with selectedRange {1,1}: previously emitted (1, 0) -- lower > upper, a
+        // slice-panic vector. The boundary-snapping conversion keeps lower <= upper.
+        assert_eq!(convert("a\u{1F600}b", 1, 1), (1, 1));
+    }
+
+    #[test]
+    fn prefix_preserved_on_mid_pair_collapse() {
+        // "a😀b" with selectedRange {2,0}: previously collapsed to (0, 0), discarding the
+        // valid "a" prefix; now snaps to the char boundary after "a".
+        assert_eq!(convert("a\u{1F600}b", 2, 0), (1, 1));
+    }
+
+    #[test]
+    fn out_of_bounds_clamps_to_len() {
+        // Subsumes the #4494 `.min(len)` clamp: an out-of-bounds offset maps to the string
+        // length instead of triggering an NSRangeException.
+        assert_eq!(convert("\u{1F600}a", 99, 0), (5, 5));
+    }
+
+    #[test]
+    fn well_formed_inputs_are_identity() {
+        // The common case (well-formed boundary indices) must be byte-for-byte unchanged.
+        assert_eq!(convert("a\u{1F600}b", 3, 0), (5, 5));
+        assert_eq!(convert("a\u{1F600}b", 4, 0), (6, 6));
+        // BMP multi-byte (Japanese): each char is 1 UTF-16 unit and 3 UTF-8 bytes.
+        assert_eq!(convert("\u{3053}\u{3093}", 1, 1), (3, 6));
+    }
+
+    #[test]
+    fn monotone_non_decreasing() {
+        // Sweep every UTF-16 offset (including out-of-bounds) over a string mixing BMP and
+        // non-BMP characters and assert the conversion never goes backwards, which is what
+        // guarantees `lower <= upper` for any `NSRange`.
+        let s = "a\u{1F600}b\u{3053}\u{1F4A9}c";
+        let mut prev = 0;
+        for off in 0..=20 {
+            let cur = utf16_to_utf8_offset(s, off);
+            assert!(cur >= prev, "non-monotone at offset {off}: {cur} < {prev}");
+            assert!(cur <= s.len(), "offset {off} mapped past end: {cur} > {}", s.len());
+            prev = cur;
+        }
+    }
+}
--- a/winit-appkit/src/window_delegate.rs
+++ b/winit-appkit/src/window_delegate.rs
@@ -912,10 +912,7 @@ impl WindowDelegate {
    fn handle_scale_factor_changed(&self, scale_factor: CGFloat) {
        let window = self.window();

-        let content_size = window.contentRectForFrameRect(window.frame()).size;
-        let content_size = LogicalSize::new(content_size.width, content_size.height);
-
-        let suggested_size = content_size.to_physical(scale_factor);
+        let suggested_size = self.view().surface_size();
        let new_surface_size = Arc::new(Mutex::new(suggested_size));
        self.queue_event(WindowEvent::ScaleFactorChanged {
            scale_factor,
@@ -1040,9 +1037,7 @@ impl WindowDelegate {

    #[inline]
    pub fn surface_size(&self) -> PhysicalSize<u32> {
-        let content_rect = self.window().contentRectForFrameRect(self.window().frame());
-        let logical = LogicalSize::new(content_rect.size.width, content_rect.size.height);
-        logical.to_physical(self.scale_factor())
+        self.view().surface_size()
    }

    #[inline]
--- a/winit-core/src/event.rs
+++ b/winit-core/src/event.rs
@@ -269,6 +269,20 @@ pub enum WindowEvent {
        button: ButtonSource,
    },

+    /// Multi-finger hold gesture on the touchpad or touchscreen without movement.
+    ///
+    /// The `phase` field indicates the lifecycle of the hold gesture:
+    /// - `Started`: One or more fingers are in contact with the touchpad/touchscreen.
+    /// - `Ended`: All fingers have been lifted from the touchpad/touchscreen.
+    /// - `Cancelled`: The hold gesture was interrupted, for example when another finger touches the
+    ///   touchpad (causing a new `Started` event with more fingers), or when movement begins and
+    ///   transitions to other gestures like pinch, pan, or rotation.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - Only available on **Wayland**.
+    HoldGesture { device_id: Option<DeviceId>, phase: TouchPhase },
+
    /// Two-finger pinch gesture, often used for magnification.
    ///
    /// ## Platform-specific
@@ -1006,9 +1020,17 @@ pub enum Ime {
 #[derive(Debug, Hash, PartialEq, Eq, Clone, Copy)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub enum TouchPhase {
+    /// Initial touch contact or gesture start, for example when one or more fingers touch the
+    /// screen or touchpad.
    Started,
+    /// The touch contact point changed, for example without lifting the finger.
    Moved,
+    /// All touch contact points have been lifted from the touchscreen or touchpad.
+    ///
+    /// This event is important as it should clear any state or event in flight that was
+    /// generated by the preceding `Started` and `Moved` events.
    Ended,
+    /// The event was cancelled and should cancel any event in flight and clear state.
    Cancelled,
 }

--- a/winit-core/src/window.rs
+++ b/winit-core/src/window.rs
@@ -880,7 +880,8 @@ pub trait Window: AsAny + Send + Sync + fmt::Debug {
    /// ## Platform-specific
    ///
    /// - **Android / iOS / X11 / Web / Windows:** Unsupported.
-    /// - **Wayland:** Only works with org_kde_kwin_blur_manager protocol.
+    /// - **Wayland:** Only works with `org_kde_kwin_blur_manager` or
+    ///   `ext_background_effect_manager_v1` protocol.
    fn set_blur(&self, blur: bool);

    /// Modifies the window's visibility.
--- a/winit-wayland/Cargo.toml
+++ b/winit-wayland/Cargo.toml
@@ -40,7 +40,7 @@ sctk = { package = "smithay-client-toolkit", version = "0.20.0", default-feature
 sctk-adwaita = { version = "0.11.0", default-features = false, optional = true }
 wayland-backend = { version = "0.3.10", default-features = false, features = ["client_system"] }
 wayland-client = "0.31.10"
-wayland-protocols = { version = "0.32.8", features = ["staging"] }
+wayland-protocols = { version = "0.32.11", features = ["staging", "unstable"] }
 wayland-protocols-plasma = { version = "0.3.8", features = ["client"] }
 winit-common = { workspace = true, features = ["xkb", "wayland"] }

--- a/winit-wayland/src/seat/mod.rs
+++ b/winit-wayland/src/seat/mod.rs
@@ -12,6 +12,7 @@ use sctk::reexports::protocols::wp::text_input::zv3::client::zwp_text_input_v3::
 use sctk::seat::pointer::{ThemeSpec, ThemedPointer};
 use sctk::seat::{Capability as SeatCapability, SeatHandler, SeatState};
 use tracing::warn;
+use wayland_protocols::wp::pointer_gestures::zv1::client::zwp_pointer_gesture_hold_v1::ZwpPointerGestureHoldV1;
 use wayland_protocols::wp::pointer_gestures::zv1::client::zwp_pointer_gesture_pinch_v1::ZwpPointerGesturePinchV1;
 use wayland_protocols::wp::tablet::zv2::client::zwp_tablet_seat_v2::ZwpTabletSeatV2;
 use winit_core::event::WindowEvent;
@@ -60,6 +61,9 @@ pub struct WinitSeatState {
    /// The pinch pointer gesture bound on the seat.
    pointer_gesture_pinch: Option<ZwpPointerGesturePinchV1>,

+    /// The hold pointer gesture bound on the seat.
+    pointer_gesture_hold: Option<ZwpPointerGestureHoldV1>,
+
    /// The keyboard bound on the seat.
    keyboard_state: Option<KeyboardState>,

@@ -141,6 +145,14 @@ impl SeatHandler for WinitState {
                    )
                });

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

                // Register cursor surface.
@@ -209,6 +221,10 @@ impl SeatHandler for WinitState {
                    pointer_gesture_pinch.destroy();
                }

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

--- a/winit-wayland/src/seat/pointer/pointer_gesture.rs
+++ b/winit-wayland/src/seat/pointer/pointer_gesture.rs
@@ -7,9 +7,12 @@ use sctk::globals::GlobalData;
 use sctk::reexports::client::globals::{BindError, GlobalList};
 use sctk::reexports::client::{Connection, Dispatch, Proxy, QueueHandle, delegate_dispatch};
 use sctk::reexports::protocols::wp::pointer_gestures::zv1::client::zwp_pointer_gesture_pinch_v1::{
-    Event, ZwpPointerGesturePinchV1,
+    Event as PinchEvent, ZwpPointerGesturePinchV1,
 };
 use sctk::reexports::protocols::wp::pointer_gestures::zv1::client::zwp_pointer_gestures_v1::ZwpPointerGesturesV1;
+use wayland_protocols::wp::pointer_gestures::zv1::client::zwp_pointer_gesture_hold_v1::{
+    Event as HoldEvent, ZwpPointerGestureHoldV1,
+};
 use winit_core::event::{TouchPhase, WindowEvent};
 use winit_core::window::WindowId;

@@ -27,7 +30,7 @@ impl PointerGesturesState {
        globals: &GlobalList,
        queue_handle: &QueueHandle<WinitState>,
    ) -> Result<Self, BindError> {
-        let pointer_gestures = globals.bind(queue_handle, 1..=1, GlobalData)?;
+        let pointer_gestures = globals.bind(queue_handle, 3..=3, GlobalData)?;
        Ok(Self { pointer_gestures })
    }
 }
@@ -70,6 +73,49 @@ impl Dispatch<ZwpPointerGesturesV1, GlobalData, WinitState> for PointerGesturesS
    }
 }

+impl Dispatch<ZwpPointerGestureHoldV1, PointerGestureData, WinitState> for PointerGesturesState {
+    fn event(
+        state: &mut WinitState,
+        _proxy: &ZwpPointerGestureHoldV1,
+        event: <ZwpPointerGestureHoldV1 as wayland_client::Proxy>::Event,
+        data: &PointerGestureData,
+        _conn: &Connection,
+        _qhandle: &QueueHandle<WinitState>,
+    ) {
+        let mut pointer_gesture_data = data.inner.lock().unwrap();
+        let (window_id, phase) = match event {
+            HoldEvent::Begin { surface, fingers, .. } => {
+                if fingers < 2 {
+                    return;
+                }
+
+                let window_id = crate::make_wid(&surface);
+                pointer_gesture_data.window_id = Some(window_id);
+
+                (window_id, TouchPhase::Started)
+            },
+            HoldEvent::End { cancelled, .. } => {
+                let window_id = match pointer_gesture_data.window_id {
+                    Some(window_id) => window_id,
+                    _ => return,
+                };
+
+                // Reset the state.
+                *pointer_gesture_data = Default::default();
+
+                let phase = if cancelled == 0 { TouchPhase::Ended } else { TouchPhase::Cancelled };
+
+                (window_id, phase)
+            },
+            _ => return,
+        };
+
+        state
+            .events_sink
+            .push_window_event(WindowEvent::HoldGesture { device_id: None, phase }, window_id);
+    }
+}
+
 impl Dispatch<ZwpPointerGesturePinchV1, PointerGestureData, WinitState> for PointerGesturesState {
    fn event(
        state: &mut WinitState,
@@ -81,7 +127,7 @@ impl Dispatch<ZwpPointerGesturePinchV1, PointerGestureData, WinitState> for Poin
    ) {
        let mut pointer_gesture_data = data.inner.lock().unwrap();
        let (window_id, phase, pan_delta, pinch_delta, rotation_delta) = match event {
-            Event::Begin { surface, fingers, .. } => {
+            PinchEvent::Begin { surface, fingers, .. } => {
                // We only support two fingers for now.
                if fingers != 2 {
                    return;
@@ -100,7 +146,7 @@ impl Dispatch<ZwpPointerGesturePinchV1, PointerGestureData, WinitState> for Poin

                (window_id, TouchPhase::Started, PhysicalPosition::new(0., 0.), 0., 0.)
            },
-            Event::Update { dx, dy, scale: pinch, rotation, .. } => {
+            PinchEvent::Update { dx, dy, scale: pinch, rotation, .. } => {
                let window_id = match pointer_gesture_data.window_id {
                    Some(window_id) => window_id,
                    _ => return,
@@ -121,7 +167,7 @@ impl Dispatch<ZwpPointerGesturePinchV1, PointerGestureData, WinitState> for Poin
                let rotation_delta = -rotation as f32;
                (window_id, TouchPhase::Moved, pan_delta, pinch_delta, rotation_delta)
            },
-            Event::End { cancelled, .. } => {
+            PinchEvent::End { cancelled, .. } => {
                let window_id = match pointer_gesture_data.window_id {
                    Some(window_id) => window_id,
                    _ => return,
@@ -155,3 +201,4 @@ impl Dispatch<ZwpPointerGesturePinchV1, PointerGestureData, WinitState> for Poin

 delegate_dispatch!(WinitState: [ZwpPointerGesturesV1: GlobalData] => PointerGesturesState);
 delegate_dispatch!(WinitState: [ZwpPointerGesturePinchV1: PointerGestureData] => PointerGesturesState);
+delegate_dispatch!(WinitState: [ZwpPointerGestureHoldV1: PointerGestureData] => PointerGesturesState);
--- a/winit-wayland/src/state.rs
+++ b/winit-wayland/src/state.rs
@@ -29,7 +29,7 @@ use crate::seat::{
    PointerConstraintsState, PointerGesturesState, RelativePointerState, TextInputState,
    WinitPointerData, WinitPointerDataExt, WinitSeatState,
 };
-use crate::types::kwin_blur::KWinBlurManager;
+use crate::types::bgr_effects::BgrEffectManager;
 use crate::types::wp_fractional_scaling::FractionalScalingManager;
 use crate::types::wp_tablet_input_v2::TabletManager;
 use crate::types::wp_viewporter::ViewporterState;
@@ -116,8 +116,8 @@ pub struct WinitState {
    /// Fractional scaling manager.
    pub fractional_scaling_manager: Option<FractionalScalingManager>,

-    /// KWin blur manager.
-    pub kwin_blur_manager: Option<KWinBlurManager>,
+    /// Blur manager.
+    pub blur_manager: Option<BgrEffectManager>,

    /// Loop handle to re-register event sources, such as keyboard repeat.
    pub loop_handle: LoopHandle<'static, Self>,
@@ -192,7 +192,7 @@ impl WinitState {
            window_events_sink: Default::default(),
            viewporter_state,
            fractional_scaling_manager,
-            kwin_blur_manager: KWinBlurManager::new(globals, queue_handle).ok(),
+            blur_manager: BgrEffectManager::new(globals, queue_handle).ok(),

            seats,
            text_input_state: TextInputState::new(globals, queue_handle).ok(),
--- a/winit-wayland/src/types/bgr_effects.rs
+++ b/winit-wayland/src/types/bgr_effects.rs
@@ -0,0 +1,85 @@
+use sctk::compositor::Region;
+use sctk::reexports::client::QueueHandle;
+use sctk::reexports::client::globals::{BindError, GlobalList};
+use sctk::reexports::client::protocol::wl_surface::WlSurface;
+use sctk::reexports::protocols::ext::background_effect::v1::client::ext_background_effect_surface_v1::ExtBackgroundEffectSurfaceV1;
+use wayland_protocols_plasma::blur::client::org_kde_kwin_blur::OrgKdeKwinBlur;
+
+use crate::state::WinitState;
+use crate::types::ext_background_effect::ExtBackgroundEffectManager;
+use crate::types::kwin_blur::KWinBlurManager;
+
+/// Wrapper around various background effects for [`WlSurface`].
+#[derive(Debug, Clone)]
+pub enum BgrEffectManager {
+    Ext(ExtBackgroundEffectManager),
+    KWin(KWinBlurManager),
+}
+
+impl BgrEffectManager {
+    pub fn new(
+        globals: &GlobalList,
+        queue_handle: &QueueHandle<WinitState>,
+    ) -> Result<Self, BindError> {
+        ExtBackgroundEffectManager::new(globals, queue_handle)
+            .map(Self::Ext)
+            .or_else(|_| KWinBlurManager::new(globals, queue_handle).map(Self::KWin))
+    }
+
+    /// Creates a new blur effect for the surface.
+    pub fn new_blur_effect(
+        &mut self,
+        surface: &WlSurface,
+        queue_handle: &QueueHandle<WinitState>,
+    ) -> SurfaceBlurEffect {
+        match self {
+            BgrEffectManager::Ext(mgr) => SurfaceBlurEffect::Ext(mgr.blur(surface, queue_handle)),
+            BgrEffectManager::KWin(mgr) => SurfaceBlurEffect::Kwin(
+                mgr.blur(surface, queue_handle),
+                mgr.clone(),
+                surface.clone(),
+            ),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub enum SurfaceBlurEffect {
+    Ext(ExtBackgroundEffectSurfaceV1),
+    Kwin(OrgKdeKwinBlur, KWinBlurManager, WlSurface),
+}
+
+impl SurfaceBlurEffect {
+    /// Returns `true` if the main surface commit is required.
+    ///
+    /// `None` clears the blur.
+    #[must_use]
+    pub fn set_blur(&self, region: Option<&Region>) -> bool {
+        let region = region.map(|region| region.wl_region());
+        match self {
+            SurfaceBlurEffect::Ext(surface) => {
+                surface.set_blur_region(region);
+                true
+            },
+            SurfaceBlurEffect::Kwin(blur, ..) => {
+                blur.set_region(region);
+                blur.commit();
+                true
+            },
+        }
+    }
+}
+
+impl Drop for SurfaceBlurEffect {
+    fn drop(&mut self) {
+        match self {
+            SurfaceBlurEffect::Ext(surface) => surface.destroy(),
+            SurfaceBlurEffect::Kwin(blur, mgr, wl_surface) => {
+                blur.set_region(None);
+                blur.commit();
+                blur.release();
+                mgr.unset(wl_surface);
+            },
+        }
+    }
+}
--- a/winit-wayland/src/types/ext_background_effect.rs
+++ b/winit-wayland/src/types/ext_background_effect.rs
@@ -0,0 +1,59 @@
+use sctk::globals::GlobalData;
+use sctk::reexports::client::globals::{BindError, GlobalList};
+use sctk::reexports::client::protocol::wl_surface::WlSurface;
+use sctk::reexports::client::{Connection, Dispatch, Proxy, QueueHandle, delegate_dispatch};
+use wayland_protocols::ext::background_effect::v1::client::ext_background_effect_manager_v1::ExtBackgroundEffectManagerV1;
+use wayland_protocols::ext::background_effect::v1::client::ext_background_effect_surface_v1::ExtBackgroundEffectSurfaceV1;
+
+use crate::state::WinitState;
+
+#[derive(Debug, Clone)]
+pub struct ExtBackgroundEffectManager {
+    manager: ExtBackgroundEffectManagerV1,
+}
+
+impl ExtBackgroundEffectManager {
+    pub fn new(
+        globals: &GlobalList,
+        queue_handle: &QueueHandle<WinitState>,
+    ) -> Result<Self, BindError> {
+        let manager = globals.bind(queue_handle, 1..=1, GlobalData)?;
+        Ok(Self { manager })
+    }
+
+    pub fn blur(
+        &mut self,
+        surface: &WlSurface,
+        queue_handle: &QueueHandle<WinitState>,
+    ) -> ExtBackgroundEffectSurfaceV1 {
+        self.manager.get_background_effect(surface, queue_handle, ())
+    }
+}
+
+impl Dispatch<ExtBackgroundEffectManagerV1, GlobalData, WinitState> for ExtBackgroundEffectManager {
+    fn event(
+        _: &mut WinitState,
+        _: &ExtBackgroundEffectManagerV1,
+        _: <ExtBackgroundEffectManagerV1 as Proxy>::Event,
+        _: &GlobalData,
+        _: &Connection,
+        _: &QueueHandle<WinitState>,
+    ) {
+    }
+}
+
+impl Dispatch<ExtBackgroundEffectSurfaceV1, (), WinitState> for ExtBackgroundEffectManager {
+    fn event(
+        _: &mut WinitState,
+        _: &ExtBackgroundEffectSurfaceV1,
+        _: <ExtBackgroundEffectSurfaceV1 as Proxy>::Event,
+        _: &(),
+        _: &Connection,
+        _: &QueueHandle<WinitState>,
+    ) {
+        // There is no event
+    }
+}
+
+delegate_dispatch!(WinitState: [ExtBackgroundEffectManagerV1: GlobalData] => ExtBackgroundEffectManager);
+delegate_dispatch!(WinitState: [ExtBackgroundEffectSurfaceV1: ()] => ExtBackgroundEffectManager);
--- a/winit-wayland/src/types/mod.rs
+++ b/winit-wayland/src/types/mod.rs
@@ -1,6 +1,8 @@
 //! Wayland protocol implementation boilerplate.

+pub mod bgr_effects;
 pub mod cursor;
+pub mod ext_background_effect;
 pub mod kwin_blur;
 pub mod wp_fractional_scaling;
 pub mod wp_tablet_input_v2;
--- a/winit-wayland/src/window/mod.rs
+++ b/winit-wayland/src/window/mod.rs
@@ -127,7 +127,8 @@ impl Window {
        // Set transparency hint.
        window_state.set_transparent(attributes.transparent);

-        window_state.set_blur(attributes.blur);
+        // Set blur.
+        let _ = window_state.set_blur(attributes.blur);

        // Set the decorations hint.
        window_state.set_decorate(attributes.decorations);
@@ -498,7 +499,9 @@ impl CoreWindow for Window {

    #[inline]
    fn set_blur(&self, blur: bool) {
-        self.window_state.lock().unwrap().set_blur(blur);
+        if self.window_state.lock().unwrap().set_blur(blur) {
+            self.request_redraw();
+        }
    }

    #[inline]
--- a/winit-wayland/src/window/state.rs
+++ b/winit-wayland/src/window/state.rs
@@ -29,7 +29,6 @@ use sctk::shm::slot::SlotPool;
 use sctk::subcompositor::SubcompositorState;
 use tracing::{info, warn};
 use wayland_protocols::xdg::toplevel_icon::v1::client::xdg_toplevel_icon_manager_v1::XdgToplevelIconManagerV1;
-use wayland_protocols_plasma::blur::client::org_kde_kwin_blur::OrgKdeKwinBlur;
 use winit_core::cursor::{CursorIcon, CustomCursor as CoreCustomCursor};
 use winit_core::error::{NotSupportedError, RequestError};
 use winit_core::window::{
@@ -43,8 +42,8 @@ use crate::seat::{
    ZwpTextInputV3Ext,
 };
 use crate::state::{WindowCompositorUpdate, WinitState};
+use crate::types::bgr_effects::{BgrEffectManager, SurfaceBlurEffect};
 use crate::types::cursor::{CustomCursor, SelectedCursor, WaylandCustomCursor};
-use crate::types::kwin_blur::KWinBlurManager;
 use crate::types::xdg_toplevel_icon_manager::ToplevelIcon;

 #[cfg(feature = "sctk-adwaita")]
@@ -156,8 +155,8 @@ pub struct WindowState {

    viewport: Option<WpViewport>,
    fractional_scale: Option<WpFractionalScaleV1>,
-    blur: Option<OrgKdeKwinBlur>,
-    blur_manager: Option<KWinBlurManager>,
+    blur: Option<SurfaceBlurEffect>,
+    blur_manager: Option<BgrEffectManager>,

    /// Whether the client side decorations have pending move operations.
    ///
@@ -206,7 +205,7 @@ impl WindowState {
            toplevel_icon: None,
            xdg_toplevel_icon_manager,
            blur: None,
-            blur_manager: winit_state.kwin_blur_manager.clone(),
+            blur_manager: winit_state.blur_manager.clone(),
            compositor,
            handle,
            csd_fails: false,
@@ -742,6 +741,13 @@ impl WindowState {
            // Set surface size without the borders.
            viewport.set_destination(self.size.width as _, self.size.height as _);
        }
+
+        // Update blur region with new size.
+        if self.blur.is_some() {
+            // NOTE: either user resized or configure, in both cases
+            // the redraw scheduling is done on the caller side.
+            let _ = self.set_blur(true);
+        }
    }

    /// Get the scale factor of the window.
@@ -1113,20 +1119,37 @@ impl WindowState {
        }
    }

-    /// Make window background blurred
-    #[inline]
-    pub fn set_blur(&mut self, blurred: bool) {
-        if blurred && self.blur.is_none() {
-            if let Some(blur_manager) = self.blur_manager.as_ref() {
-                let blur = blur_manager.blur(self.window.wl_surface(), &self.queue_handle);
-                blur.commit();
-                self.blur = Some(blur);
-            } else {
-                info!("Blur manager unavailable, unable to change blur")
-            }
-        } else if !blurred && self.blur.is_some() {
-            self.blur_manager.as_ref().unwrap().unset(self.window.wl_surface());
-            self.blur.take().unwrap().release();
+    /// Make window background blurred.
+    ///
+    /// Returns `true` if redraw is required.
+    #[must_use]
+    pub fn set_blur(&mut self, blurred: bool) -> bool {
+        if !blurred {
+            self.blur = None;
+            return true;
+        }
+
+        let mgr = match self.blur_manager.as_mut() {
+            Some(mgr) => mgr,
+            None => {
+                info!("Blur manager unavailable, unable to change blur");
+                return false;
+            },
+        };
+
+        let blur = match self.blur.as_ref() {
+            Some(blur) => blur,
+            None => {
+                self.blur = Some(mgr.new_blur_effect(self.window.wl_surface(), &self.queue_handle));
+                self.blur.as_ref().unwrap()
+            },
+        };
+
+        if let Ok(region) = Region::new(&*self.compositor) {
+            region.add(0, 0, i32::MAX, i32::MAX);
+            blur.set_blur(Some(&region))
+        } else {
+            false
        }
    }

@@ -1224,10 +1247,6 @@ impl WindowState {

 impl Drop for WindowState {
    fn drop(&mut self) {
-        if let Some(blur) = self.blur.take() {
-            blur.release();
-        }
-
        if let Some(fs) = self.fractional_scale.take() {
            fs.destroy();
        }
--- a/winit-win32/src/event_loop.rs
+++ b/winit-win32/src/event_loop.rs
@@ -51,12 +51,12 @@ use windows_sys::Win32::UI::WindowsAndMessaging::{
    SystemParametersInfoW, TranslateMessage, WHEEL_DELTA, WINDOWPOS, WM_CAPTURECHANGED, WM_CLOSE,
    WM_CREATE, WM_DESTROY, WM_DPICHANGED, WM_ENTERSIZEMOVE, WM_EXITSIZEMOVE, WM_GETMINMAXINFO,
    WM_IME_COMPOSITION, WM_IME_ENDCOMPOSITION, WM_IME_SETCONTEXT, WM_IME_STARTCOMPOSITION,
-    WM_INPUT, WM_KEYDOWN, WM_KEYUP, WM_KILLFOCUS, WM_LBUTTONDOWN, WM_LBUTTONUP, WM_MBUTTONDOWN,
-    WM_MBUTTONUP, WM_MENUCHAR, WM_MOUSEHWHEEL, WM_MOUSEMOVE, WM_MOUSEWHEEL, WM_NCACTIVATE,
-    WM_NCCALCSIZE, WM_NCCREATE, WM_NCDESTROY, WM_NCLBUTTONDOWN, WM_PAINT, WM_POINTERDOWN,
-    WM_POINTERUP, WM_POINTERUPDATE, WM_RBUTTONDOWN, WM_RBUTTONUP, WM_SETCURSOR, WM_SETFOCUS,
-    WM_SETTINGCHANGE, WM_SIZE, WM_SIZING, WM_SYSCOMMAND, WM_SYSKEYDOWN, WM_SYSKEYUP, WM_TOUCH,
-    WM_WINDOWPOSCHANGED, WM_WINDOWPOSCHANGING, WM_XBUTTONDOWN, WM_XBUTTONUP, WMSZ_BOTTOM,
+    WM_INPUT, WM_INPUTLANGCHANGE, WM_KEYDOWN, WM_KEYUP, WM_KILLFOCUS, WM_LBUTTONDOWN, WM_LBUTTONUP,
+    WM_MBUTTONDOWN, WM_MBUTTONUP, WM_MENUCHAR, WM_MOUSEHWHEEL, WM_MOUSEMOVE, WM_MOUSEWHEEL,
+    WM_NCACTIVATE, WM_NCCALCSIZE, WM_NCCREATE, WM_NCDESTROY, WM_NCLBUTTONDOWN, WM_PAINT,
+    WM_POINTERDOWN, WM_POINTERUP, WM_POINTERUPDATE, WM_RBUTTONDOWN, WM_RBUTTONUP, WM_SETCURSOR,
+    WM_SETFOCUS, WM_SETTINGCHANGE, WM_SIZE, WM_SIZING, WM_SYSCOMMAND, WM_SYSKEYDOWN, WM_SYSKEYUP,
+    WM_TOUCH, WM_WINDOWPOSCHANGED, WM_WINDOWPOSCHANGING, WM_XBUTTONDOWN, WM_XBUTTONUP, WMSZ_BOTTOM,
    WMSZ_BOTTOMLEFT, WMSZ_BOTTOMRIGHT, WMSZ_LEFT, WMSZ_RIGHT, WMSZ_TOP, WMSZ_TOPLEFT,
    WMSZ_TOPRIGHT, WNDCLASSEXW, WS_EX_LAYERED, WS_EX_NOACTIVATE, WS_EX_TOOLWINDOW,
    WS_EX_TRANSPARENT, WS_OVERLAPPED, WS_POPUP, WS_VISIBLE,
@@ -1508,6 +1508,21 @@ unsafe fn public_window_callback_inner(
            result = ProcResult::Value(unsafe { DefWindowProcW(window, msg, wparam, lparam) });
        },

+        WM_INPUTLANGCHANGE => {
+            // Refresh the cached keyboard layout for the newly activated input
+            // language. This message is sent (by Windows or by layout switchers
+            // such as Punto Switcher) after the layout changes. Refreshing the
+            // cache here prevents a freeze that otherwise occurs when switching
+            // layout via such tools. We still defer to `DefWindowProc` so the
+            // message keeps propagating to first-level child windows, as the
+            // Win32 documentation requires.
+            {
+                let mut layouts = LAYOUT_CACHE.lock().unwrap();
+                layouts.get_current_layout();
+            }
+            result = ProcResult::DefWindowProc(wparam);
+        },
+
        // this is necessary for us to maintain minimize/restore state
        WM_SYSCOMMAND => {
            if wparam == SC_RESTORE as usize {
--- a/winit-x11/src/event_processor.rs
+++ b/winit-x11/src/event_processor.rs
@@ -1757,7 +1757,7 @@ impl EventProcessor {
                .find(|prev_monitor| prev_monitor.name == new_monitor.name)
                .map(|prev_monitor| prev_monitor.scale_factor);
            if Some(new_monitor.scale_factor) != maybe_prev_scale_factor {
-                for window in self.target.windows.borrow().iter().filter_map(|(_, w)| w.upgrade()) {
+                for window in self.target.windows.borrow().values().filter_map(|w| w.upgrade()) {
                    window.refresh_dpi_for_monitor(
                        &new_monitor,
                        maybe_prev_scale_factor,
--- a/winit/Cargo.toml
+++ b/winit/Cargo.toml
@@ -76,9 +76,13 @@ winit-core.workspace = true

 [dev-dependencies]
 image = { workspace = true, features = ["png"] }
-softbuffer.workspace = true
 tracing = { workspace = true, features = ["log"] }
 tracing-subscriber = { workspace = true, features = ["env-filter"] }
+# Launching a window without drawing to it has unpredictable results varying from platform to
+# platform. We use the `softbuffer` crate in our examples because of its ease of use to avoid
+# confusion around this. `glutin` or `wgpu` could also be used to fill the window buffer, but they
+# are more complicated to set up.
+softbuffer.workspace = true

 [target.'cfg(target_os = "android")'.dependencies]
 winit-android.workspace = true
--- a/winit/examples/application.rs
+++ b/winit/examples/application.rs
@@ -10,34 +10,31 @@ use std::fmt::Debug;
 use std::num::NonZeroU32;
 use std::sync::Arc;
 use std::sync::mpsc::{self, Receiver, Sender};
-#[cfg(not(target_family = "wasm"))]
+#[cfg(not(web_platform))]
 use std::time::Instant;
 use std::{fmt, mem};

 use cursor_icon::CursorIcon;
-use rwh_06::{DisplayHandle, HasDisplayHandle};
 use softbuffer::{Context, Surface};
 use tracing::{error, info};
-#[cfg(target_family = "wasm")]
+#[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};
+use winit::event_loop::{ActiveEventLoop, EventLoop, OwnedDisplayHandle};
 use winit::icon::{Icon, RgbaIcon};
 use winit::keyboard::{Key, ModifiersState};
 use winit::monitor::Fullscreen;
-#[cfg(all(target_vendor = "apple", not(target_os = "macos")))]
-use winit::platform::ios::WindowExtIOS;
-#[cfg(target_os = "macos")]
+#[cfg(macos_platform)]
 use winit::platform::macos::{OptionAsAlt, WindowAttributesMacOS, WindowExtMacOS};
 #[cfg(any(x11_platform, wayland_platform))]
 use winit::platform::startup_notify::{self, EventLoopExtStartupNotify, WindowExtStartupNotify};
 #[cfg(wayland_platform)]
 use winit::platform::wayland::{ActiveEventLoopExtWayland, WindowAttributesWayland};
-#[cfg(target_family = "wasm")]
+#[cfg(web_platform)]
 use winit::platform::web::{ActiveEventLoopExtWeb, WindowAttributesWeb};
 #[cfg(x11_platform)]
 use winit::platform::x11::{ActiveEventLoopExtX11, WindowAttributesX11};
@@ -47,14 +44,11 @@ use winit_core::application::macos::ApplicationHandlerExtMacOS;
 #[path = "util/tracing.rs"]
 mod tracing_init;

-#[path = "util/fill.rs"]
-mod fill;
-
 /// The amount of points to around the window for drag resize direction calculations.
 const BORDER_SIZE: f64 = 20.;

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

    tracing_init::init();
@@ -63,7 +57,7 @@ fn main() -> Result<(), Box<dyn Error>> {
    let (sender, receiver) = mpsc::channel();

    // Wire the user event from another thread.
-    #[cfg(not(target_family = "wasm"))]
+    #[cfg(not(web_platform))]
    {
        let event_loop_proxy = event_loop.create_proxy();
        let sender = sender.clone();
@@ -96,20 +90,12 @@ struct Application {
    /// Drawing context.
    ///
    /// With OpenGL it could be EGLDisplay.
-    context: Option<Context<DisplayHandle<'static>>>,
+    context: Context<OwnedDisplayHandle>,
 }

 impl Application {
    fn new(event_loop: &EventLoop, receiver: Receiver<Action>, sender: Sender<Action>) -> Self {
-        // SAFETY: we drop the context right before the event loop is stopped, thus making it safe.
-        let context = Some(
-            Context::new(unsafe {
-                std::mem::transmute::<DisplayHandle<'_>, DisplayHandle<'static>>(
-                    event_loop.display_handle().unwrap(),
-                )
-            })
-            .unwrap(),
-        );
+        let context = Context::new(event_loop.owned_display_handle()).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
@@ -145,68 +131,34 @@ impl Application {

        #[cfg(x11_platform)]
        if event_loop.is_x11() {
-            let mut attrs = WindowAttributesX11::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);
-                attrs = attrs.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().expect("invalid X11_VISUAL_ID");
-                    attrs = attrs.with_x11_visual(visual_id);
-                },
-                Err(_) => {
-                    info!("Set the X11_VISUAL_ID env var 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().expect("invalid X11_SCREEN_ID");
-                    attrs = attrs.with_x11_screen(screen_id);
-                },
-                Err(_) => {
-                    info!("Set the X11_SCREEN_ID env var to place the window on non-default screen")
-                },
-            }
-
-            window_attributes = window_attributes.with_platform_attributes(Box::new(attrs));
+            window_attributes = window_attributes
+                .with_platform_attributes(Box::new(window_attributes_x11(event_loop)?));
        }

        #[cfg(wayland_platform)]
        if event_loop.is_wayland() {
-            let mut attrs = 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);
-                attrs = attrs.with_activation_token(token);
-            }
-
-            window_attributes = window_attributes.with_platform_attributes(Box::new(attrs));
+            window_attributes = window_attributes
+                .with_platform_attributes(Box::new(window_attributes_wayland(event_loop)));
        }

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

-        #[cfg(target_family = "wasm")]
+        #[cfg(web_platform)]
        {
-            let attrs = WindowAttributesWeb::default().with_append(true);
-            window_attributes = window_attributes.with_platform_attributes(Box::new(attrs));
+            window_attributes =
+                window_attributes.with_platform_attributes(Box::new(window_attributes_web()));
        }

        let window = event_loop.create_window(window_attributes)?;

-        #[cfg(all(target_vendor = "apple", not(target_os = "macos")))]
+        #[cfg(ios_platform)]
        {
+            use winit::platform::ios::WindowExtIOS;
            window.recognize_doubletap_gesture(true);
            window.recognize_pinch_gesture(true);
            window.recognize_rotation_gesture(true);
@@ -222,7 +174,7 @@ impl Application {

    fn handle_action_from_proxy(&mut self, _event_loop: &dyn ActiveEventLoop, action: Action) {
        match action {
-            #[cfg(target_family = "wasm")]
+            #[cfg(web_platform)]
            Action::DumpMonitors => self.dump_monitors(_event_loop),
            Action::Message => {
                info!("User wake up");
@@ -270,11 +222,11 @@ impl Application {
            Action::ToggleResizable => window.toggle_resizable(),
            Action::ToggleDecorations => window.toggle_decorations(),
            Action::ToggleFullscreen => window.toggle_fullscreen(),
-            #[cfg(target_os = "macos")]
+            #[cfg(macos_platform)]
            Action::ToggleSimpleFullscreen => {
                window.window.set_simple_fullscreen(!window.window.simple_fullscreen());
            },
-            #[cfg(target_os = "macos")]
+            #[cfg(macos_platform)]
            Action::ToggleBorderlessGame => {
                let current = window.window.is_borderless_game();
                window.window.set_borderless_game(!current);
@@ -289,13 +241,13 @@ impl Application {
                    error!("Error creating custom cursor: {err}");
                }
            },
-            #[cfg(target_family = "wasm")]
+            #[cfg(web_platform)]
            Action::UrlCustomCursor => {
                if let Err(err) = window.url_custom_cursor(event_loop) {
                    error!("Error creating custom cursor from URL: {err}");
                }
            },
-            #[cfg(target_family = "wasm")]
+            #[cfg(web_platform)]
            Action::AnimationCustomCursor => {
                if let Err(err) = self
                    .custom_cursors
@@ -310,7 +262,7 @@ impl Application {
            Action::DragResizeWindow => window.drag_resize_window(),
            Action::ShowWindowMenu => window.show_menu(),
            Action::PrintHelp => self.print_help(),
-            #[cfg(target_os = "macos")]
+            #[cfg(macos_platform)]
            Action::CycleOptionAsAlt => window.cycle_option_as_alt(),
            Action::SetTheme(theme) => {
                window.window.set_theme(theme);
@@ -318,7 +270,7 @@ impl Application {
                let actual_theme = theme.or_else(|| window.window.theme()).unwrap_or(Theme::Dark);
                window.set_draw_theme(actual_theme);
            },
-            #[cfg(target_os = "macos")]
+            #[cfg(macos_platform)]
            Action::CreateNewTab => {
                let tab_id = window.window.tabbing_identifier();
                if let Err(err) = self.create_window(event_loop, Some(tab_id)) {
@@ -326,7 +278,7 @@ impl Application {
                }
            },
            Action::RequestResize => window.swap_dimensions(),
-            #[cfg(target_family = "wasm")]
+            #[cfg(web_platform)]
            Action::DumpMonitors => {
                let future = event_loop.request_detailed_monitor_permission();
                let proxy = event_loop.create_proxy();
@@ -340,7 +292,7 @@ impl Application {
                    proxy.wake_up();
                });
            },
-            #[cfg(not(target_family = "wasm"))]
+            #[cfg(not(web_platform))]
            Action::DumpMonitors => self.dump_monitors(event_loop),
            Action::Message => {
                self.sender.send(Action::Message).unwrap();
@@ -577,16 +529,7 @@ 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::Ime(_)
-            | WindowEvent::Moved(_) => (),
+            _ => (),
        }
    }

@@ -641,9 +584,7 @@ impl ApplicationHandlerExtMacOS for Application {
 /// State of the window.
 struct WindowState {
    /// Render surface.
-    ///
-    /// NOTE: This surface must be dropped before the `Window`.
-    surface: Surface<DisplayHandle<'static>, Arc<dyn Window>>,
+    surface: Surface<OwnedDisplayHandle, Arc<dyn Window>>,
    /// The actual winit Window.
    window: Arc<dyn Window>,
    /// The window theme we're drawing with.
@@ -671,7 +612,7 @@ struct WindowState {
    /// The amount of pan of the window.
    panned: PhysicalPosition<f32>,

-    #[cfg(target_os = "macos")]
+    #[cfg(macos_platform)]
    option_as_alt: OptionAsAlt,

    // Cursor states.
@@ -684,9 +625,7 @@ impl WindowState {
    fn new(app: &Application, window: Box<dyn Window>) -> Result<Self, Box<dyn Error>> {
        let window: Arc<dyn Window> = Arc::from(window);

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

        let theme = window.theme().unwrap_or(Theme::Dark);
        info!("Theme: {theme:?}");
@@ -695,7 +634,7 @@ impl WindowState {

        let size = window.surface_size();
        let mut state = Self {
-            #[cfg(target_os = "macos")]
+            #[cfg(macos_platform)]
            option_as_alt: window.option_as_alt(),
            custom_idx: app.custom_cursors.as_ref().map(Vec::len).unwrap_or(1) - 1,
            cursor_grab: CursorGrabMode::None,
@@ -794,7 +733,7 @@ impl WindowState {
        }
    }

-    #[cfg(target_os = "macos")]
+    #[cfg(macos_platform)]
    fn cycle_option_as_alt(&mut self) {
        self.option_as_alt = match self.option_as_alt {
            OptionAsAlt::None => OptionAsAlt::OnlyLeft,
@@ -840,7 +779,7 @@ impl WindowState {
    }

    /// Custom cursor from an URL.
-    #[cfg(target_family = "wasm")]
+    #[cfg(web_platform)]
    fn url_custom_cursor(
        &mut self,
        event_loop: &dyn ActiveEventLoop,
@@ -853,7 +792,7 @@ impl WindowState {
    }

    /// Custom cursor from a URL.
-    #[cfg(target_family = "wasm")]
+    #[cfg(web_platform)]
    fn animation_custom_cursor(
        &mut self,
        event_loop: &dyn ActiveEventLoop,
@@ -973,35 +912,40 @@ impl WindowState {
            return Ok(());
        }

-        if self.animated_fill_color {
-            fill::fill_window_with_animated_color(&*self.window, self.start_time);
-            return Ok(());
-        }
-
        let mut buffer = self.surface.buffer_mut()?;

-        // 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
-                    };
+        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
+                        };
+                    }
                }
            }
        }
@@ -1039,27 +983,27 @@ enum Action {
    ToggleDecorations,
    ToggleResizable,
    ToggleFullscreen,
-    #[cfg(target_os = "macos")]
+    #[cfg(macos_platform)]
    ToggleSimpleFullscreen,
-    #[cfg(target_os = "macos")]
+    #[cfg(macos_platform)]
    ToggleBorderlessGame,
    ToggleMaximize,
    Minimize,
    NextCursor,
    NextCustomCursor,
-    #[cfg(target_family = "wasm")]
+    #[cfg(web_platform)]
    UrlCustomCursor,
-    #[cfg(target_family = "wasm")]
+    #[cfg(web_platform)]
    AnimationCustomCursor,
    CycleCursorGrab,
    PrintHelp,
    DragWindow,
    DragResizeWindow,
    ShowWindowMenu,
-    #[cfg(target_os = "macos")]
+    #[cfg(macos_platform)]
    CycleOptionAsAlt,
    SetTheme(Option<Theme>),
-    #[cfg(target_os = "macos")]
+    #[cfg(macos_platform)]
    CreateNewTab,
    RequestResize,
    DumpMonitors,
@@ -1078,35 +1022,35 @@ impl Action {
            Action::ToggleDecorations => "Toggle decorations",
            Action::ToggleResizable => "Toggle window resizable state",
            Action::ToggleFullscreen => "Toggle fullscreen",
-            #[cfg(target_os = "macos")]
+            #[cfg(macos_platform)]
            Action::ToggleSimpleFullscreen => "Toggle simple fullscreen",
-            #[cfg(target_os = "macos")]
+            #[cfg(macos_platform)]
            Action::ToggleBorderlessGame => "Toggle borderless game mode",
            Action::ToggleMaximize => "Maximize",
            Action::Minimize => "Minimize",
            Action::ToggleResizeIncrements => "Use resize increments when resizing window",
            Action::NextCursor => "Advance the cursor to the next value",
            Action::NextCustomCursor => "Advance custom cursor to the next value",
-            #[cfg(target_family = "wasm")]
+            #[cfg(web_platform)]
            Action::UrlCustomCursor => "Custom cursor from an URL",
-            #[cfg(target_family = "wasm")]
+            #[cfg(web_platform)]
            Action::AnimationCustomCursor => "Custom cursor from an animation",
            Action::CycleCursorGrab => "Cycle through cursor grab mode",
            Action::PrintHelp => "Print help",
            Action::DragWindow => "Start window drag",
            Action::DragResizeWindow => "Start window drag-resize",
            Action::ShowWindowMenu => "Show window menu",
-            #[cfg(target_os = "macos")]
+            #[cfg(macos_platform)]
            Action::CycleOptionAsAlt => "Cycle option as alt mode",
            Action::SetTheme(None) => "Change to the system theme",
            Action::SetTheme(Some(Theme::Light)) => "Change to a light theme",
            Action::SetTheme(Some(Theme::Dark)) => "Change to a dark theme",
-            #[cfg(target_os = "macos")]
+            #[cfg(macos_platform)]
            Action::CreateNewTab => "Create new tab",
            Action::RequestResize => "Request a resize",
-            #[cfg(not(target_family = "wasm"))]
+            #[cfg(not(web_platform))]
            Action::DumpMonitors => "Dump monitor information",
-            #[cfg(target_family = "wasm")]
+            #[cfg(web_platform)]
            Action::DumpMonitors => {
                "Request permission to query detailed monitor information and dump monitor \
                 information"
@@ -1133,7 +1077,7 @@ fn decode_cursor(bytes: &[u8]) -> CustomCursorSource {
    CustomCursorSource::from_rgba(samples.samples, w, h, w / 2, h / 2).unwrap()
 }

-#[cfg(target_family = "wasm")]
+#[cfg(web_platform)]
 fn url_custom_cursor() -> CustomCursorSource {
    use std::sync::atomic::{AtomicU64, Ordering};

@@ -1198,6 +1142,60 @@ fn mouse_button_to_string(button: MouseButton) -> Cow<'static, str> {
    .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.
 const CURSORS: &[CursorIcon] = &[
    CursorIcon::Default,
@@ -1241,7 +1239,7 @@ const KEY_BINDINGS: &[Binding<&'static str>] = &[
    Binding::new("H", ModifiersState::CONTROL, Action::PrintHelp),
    Binding::new("F", ModifiersState::SHIFT, Action::ToggleAnimatedFillColor),
    Binding::new("F", ModifiersState::CONTROL, Action::ToggleFullscreen),
-    #[cfg(target_os = "macos")]
+    #[cfg(macos_platform)]
    Binding::new("F", ModifiersState::ALT, Action::ToggleSimpleFullscreen),
    Binding::new("D", ModifiersState::CONTROL, Action::ToggleDecorations),
    Binding::new("L", ModifiersState::CONTROL, Action::CycleCursorGrab),
@@ -1258,13 +1256,13 @@ const KEY_BINDINGS: &[Binding<&'static str>] = &[
    // C.
    Binding::new("C", ModifiersState::CONTROL, Action::NextCursor),
    Binding::new("C", ModifiersState::ALT, Action::NextCustomCursor),
-    #[cfg(target_family = "wasm")]
+    #[cfg(web_platform)]
    Binding::new(
        "C",
        ModifiersState::CONTROL.union(ModifiersState::SHIFT),
        Action::UrlCustomCursor,
    ),
-    #[cfg(target_family = "wasm")]
+    #[cfg(web_platform)]
    Binding::new(
        "C",
        ModifiersState::ALT.union(ModifiersState::SHIFT),
@@ -1275,11 +1273,11 @@ const KEY_BINDINGS: &[Binding<&'static str>] = &[
    Binding::new("K", ModifiersState::empty(), Action::SetTheme(None)),
    Binding::new("K", ModifiersState::META, Action::SetTheme(Some(Theme::Light))),
    Binding::new("K", ModifiersState::CONTROL, Action::SetTheme(Some(Theme::Dark))),
-    #[cfg(target_os = "macos")]
+    #[cfg(macos_platform)]
    Binding::new("T", ModifiersState::META, Action::CreateNewTab),
-    #[cfg(target_os = "macos")]
+    #[cfg(macos_platform)]
    Binding::new("O", ModifiersState::CONTROL, Action::CycleOptionAsAlt),
-    #[cfg(target_os = "macos")]
+    #[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
@@ -1,13 +1,14 @@
-#[cfg(any(x11_platform, target_os = "macos", target_os = "windows"))]
+#[cfg(any(x11_platform, macos_platform, windows_platform))]
 #[allow(deprecated)]
 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};
+    use winit::event_loop::{ActiveEventLoop, EventLoop, OwnedDisplayHandle};
    use winit::raw_window_handle::HasRawWindowHandle;
    use winit::window::{Window, WindowAttributes, WindowId};

@@ -16,18 +17,20 @@ fn main() -> Result<(), impl std::error::Error> {

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

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

-    #[derive(Default, Debug)]
+    #[derive(Debug)]
    struct Application {
+        context: Context<OwnedDisplayHandle>,
        parent_window_id: Option<WindowId>,
        windows: HashMap<WindowId, WindowData>,
    }
@@ -42,7 +45,7 @@ fn main() -> Result<(), impl std::error::Error> {
            info!("Parent window id: {:?})", window.id());
            self.parent_window_id = Some(window.id());

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

        fn window_event(
@@ -73,18 +76,24 @@ 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.window.as_ref(), event_loop, child_index);
+                    let child_window = spawn_child_window(
+                        parent_window.surface.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(child_window, child_color));
+                    self.windows.insert(
+                        child_id,
+                        WindowData::new(&self.context, child_window, child_color),
+                    );
                },
                WindowEvent::RedrawRequested => {
-                    if let Some(window) = self.windows.get(&window_id) {
+                    if let Some(window) = self.windows.get_mut(&window_id) {
                        if window_id == self.parent_window_id.unwrap() {
-                            fill::fill_window(window.window.as_ref());
+                            fill::fill(&mut window.surface);
                        } else {
-                            fill::fill_window_with_color(window.window.as_ref(), window.color);
+                            fill::fill_with_color(&mut window.surface, window.color);
                        }
                    }
                },
@@ -118,10 +127,11 @@ fn main() -> Result<(), impl std::error::Error> {
    }

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

-#[cfg(not(any(x11_platform, target_os = "macos", target_os = "windows")))]
+#[cfg(not(any(x11_platform, macos_platform, windows_platform)))]
 fn main() {
    panic!(
        "This example is supported only on x11, macOS, and Windows, with the `rwh_06` feature \
--- a/winit/examples/control_flow.rs
+++ b/winit/examples/control_flow.rs
@@ -1,16 +1,16 @@
 #![allow(clippy::single_match)]

 use std::thread;
-use std::time::Duration;
-#[cfg(not(target_family = "wasm"))]
-use std::time::Instant;
+#[cfg(not(web_platform))]
+use std::time;

+use softbuffer::{Context, Surface};
 use tracing::{info, warn};
-#[cfg(target_family = "wasm")]
-use web_time::Instant;
+#[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};
+use winit::event_loop::{ActiveEventLoop, ControlFlow, EventLoop, OwnedDisplayHandle};
 use winit::keyboard::{Key, NamedKey};
 use winit::window::{Window, WindowAttributes, WindowId};

@@ -19,8 +19,8 @@ mod fill;
 #[path = "util/tracing.rs"]
 mod tracing;

-const WAIT_TIME: Duration = Duration::from_millis(100);
-const POLL_SLEEP_TIME: Duration = Duration::from_millis(100);
+const WAIT_TIME: time::Duration = time::Duration::from_millis(100);
+const POLL_SLEEP_TIME: time::Duration = time::Duration::from_millis(100);

 #[derive(Default, Debug, Clone, Copy, PartialEq, Eq)]
 enum Mode {
@@ -31,7 +31,7 @@ enum Mode {
 }

 fn main() -> Result<(), impl std::error::Error> {
-    #[cfg(target_family = "wasm")]
+    #[cfg(web_platform)]
    console_error_panic_hook::set_once();

    tracing::init();
@@ -53,7 +53,7 @@ struct ControlFlowDemo {
    request_redraw: bool,
    wait_cancelled: bool,
    close_requested: bool,
-    window: Option<Box<dyn Window>>,
+    surface: Option<Surface<OwnedDisplayHandle, Box<dyn Window>>>,
 }

 impl ApplicationHandler for ControlFlowDemo {
@@ -70,7 +70,10 @@ 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.",
        );
-        self.window = Some(event_loop.create_window(window_attributes).unwrap());
+        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);
    }

    fn window_event(
@@ -113,9 +116,9 @@ impl ApplicationHandler for ControlFlowDemo {
                _ => (),
            },
            WindowEvent::RedrawRequested => {
-                let window = self.window.as_ref().unwrap();
-                window.pre_present_notify();
-                fill::fill_window(window.as_ref());
+                let surface = self.surface.as_mut().unwrap();
+                surface.window().pre_present_notify();
+                fill::fill(surface);
            },
            _ => (),
        }
@@ -123,14 +126,15 @@ 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.window.as_ref().unwrap().request_redraw();
+            self.surface.as_ref().unwrap().window().request_redraw();
        }

        match self.mode {
            Mode::Wait => event_loop.set_control_flow(ControlFlow::Wait),
            Mode::WaitUntil => {
                if !self.wait_cancelled {
-                    event_loop.set_control_flow(ControlFlow::WaitUntil(Instant::now() + WAIT_TIME));
+                    event_loop
+                        .set_control_flow(ControlFlow::WaitUntil(time::Instant::now() + WAIT_TIME));
                }
            },
            Mode::Poll => {
--- a/winit/examples/dnd.rs
+++ b/winit/examples/dnd.rs
@@ -1,9 +1,10 @@
 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};
+use winit::event_loop::{ActiveEventLoop, EventLoop, OwnedDisplayHandle};
 use winit::window::{Window, WindowAttributes, WindowId};

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

    let event_loop = EventLoop::new()?;

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

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

 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!");
-        self.window = Some(event_loop.create_window(window_attributes).unwrap());
+        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);
    }

    fn window_event(
@@ -53,9 +51,9 @@ impl ApplicationHandler for Application {
                info!("{event:?}");
            },
            WindowEvent::RedrawRequested => {
-                let window = self.window.as_ref().unwrap();
-                window.pre_present_notify();
-                fill::fill_window(window.as_ref());
+                let surface = self.surface.as_mut().unwrap();
+                surface.window().pre_present_notify();
+                fill::fill(surface);
            },
            WindowEvent::CloseRequested => {
                event_loop.exit();
--- a/winit/examples/ime.rs
+++ b/winit/examples/ime.rs
@@ -9,12 +9,13 @@ use std::cmp;
 use std::error::Error;

 use dpi::{LogicalPosition, PhysicalSize};
+use softbuffer::{Context, Surface};
 use tracing::{error, info};
 use winit::application::ApplicationHandler;
 use winit::event::{Ime, WindowEvent};
-use winit::event_loop::{ActiveEventLoop, EventLoop};
+use winit::event_loop::{ActiveEventLoop, EventLoop, OwnedDisplayHandle};
 use winit::keyboard::{Key, ModifiersState, NamedKey};
-#[cfg(target_family = "wasm")]
+#[cfg(web_platform)]
 use winit::platform::web::WindowAttributesWeb;
 use winit::window::{
    ImeCapabilities, ImeEnableRequest, ImeHint, ImePurpose, ImeRequest, ImeRequestData,
@@ -30,7 +31,7 @@ const IME_CURSOR_SIZE: PhysicalSize<u32> = PhysicalSize::new(20, 20);

 #[derive(Debug)]
 struct App {
-    window: Option<Box<dyn Window>>,
+    surface: Option<Surface<OwnedDisplayHandle, Box<dyn Window>>>,
    input_state: TextInputState,
    modifiers: ModifiersState,
 }
@@ -68,19 +69,17 @@ impl TextInputState {

 impl ApplicationHandler for App {
    fn can_create_surfaces(&mut self, event_loop: &dyn ActiveEventLoop) {
-        #[cfg(not(target_family = "wasm"))]
+        #[cfg(not(web_platform))]
        let window_attributes = WindowAttributes::default();
-        #[cfg(target_family = "wasm")]
+        #[cfg(web_platform)]
        let window_attributes = WindowAttributes::default()
            .with_platform_attributes(Box::new(WindowAttributesWeb::default().with_append(true)));
-        self.window = match event_loop.create_window(window_attributes) {
-            Ok(window) => Some(window),
-            Err(err) => {
-                error!("error creating window: {err}");
-                event_loop.exit();
-                return;
-            },
-        };
+        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);

        // Allow IME out of the box.
        let enable_request = ImeEnableRequest::new(
@@ -101,11 +100,13 @@ impl ApplicationHandler for App {
        match event {
            WindowEvent::CloseRequested => {
                info!("Close was requested; stopping");
-                self.window = None;
+                self.surface = None;
                event_loop.exit();
            },
-            WindowEvent::SurfaceResized(_) => {
-                self.window.as_ref().expect("resize event without a window").request_redraw();
+            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::RedrawRequested => {
                // Redraw the application.
@@ -114,13 +115,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 window = self.window.as_ref().expect("redraw request without a window");
+                let surface = self.surface.as_mut().expect("redraw event without a surface");

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

                // Draw.
-                fill::fill_window(window.as_ref());
+                fill::fill(surface);

                // For contiguous redraw loop you can request a redraw from here.
                // window.request_redraw();
@@ -214,14 +215,14 @@ impl App {
    }

    fn handle_ime_event(&mut self, event: Ime) {
-        let window = self.window.as_ref().expect("IME request without a window");
+        let surface = self.surface.as_ref().expect("IME request without a window");
        match event {
-            Ime::Enabled => info!("IME enabled for Window={:?}", window.id()),
+            Ime::Enabled => info!("IME enabled for Window={:?}", surface.window().id()),
            Ime::Preedit(text, caret_pos) => info!("Preedit: {text}, with caret at {caret_pos:?}"),
            Ime::Commit(text) => {
                self.input_state.append_text(&text);
                let request_data = self.get_ime_update();
-                window.request_ime_update(ImeRequest::Update(request_data)).unwrap();
+                surface.window().request_ime_update(ImeRequest::Update(request_data)).unwrap();
                self.print_input_state();
            },
            Ime::DeleteSurrounding { before_bytes, after_bytes } => {
@@ -246,7 +247,7 @@ impl App {
                    error!("Buggy IME tried to delete with indices not on char boundary.");
                }
            },
-            Ime::Disabled => info!("IME disabled for Window={:?}", window.id()),
+            Ime::Disabled => info!("IME disabled for Window={:?}", surface.window().id()),
        }
    }

@@ -312,7 +313,7 @@ impl App {
    }

    fn window(&self) -> &dyn Window {
-        self.window.as_ref().unwrap().as_ref()
+        self.surface.as_ref().unwrap().window().as_ref()
    }
 }

@@ -339,7 +340,7 @@ fn preedit_with_cursor_checked(text: &str, cursor: usize, anchor: usize) -> Resu
 }

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

    tracing_init::init();
@@ -355,7 +356,7 @@ Use CTRL+h to cycle content hint permutations.
    );

    let app = App {
-        window: None,
+        surface: None,
        input_state: TextInputState {
            ime_enabled: true,
            contents: String::new(),
--- a/winit/examples/pump_events.rs
+++ b/winit/examples/pump_events.rs
@@ -1,23 +1,18 @@
 #![allow(clippy::single_match)]

 // Limit this example to only compatible platforms.
-#[cfg(any(
-    target_os = "windows",
-    target_os = "macos",
-    x11_platform,
-    wayland_platform,
-    target_os = "android",
-))]
+#[cfg(any(windows_platform, macos_platform, x11_platform, wayland_platform, android_platform,))]
 fn main() -> std::process::ExitCode {
    use 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};
+    use winit::event_loop::{ActiveEventLoop, EventLoop, OwnedDisplayHandle};
    use winit::window::{Window, WindowAttributes, WindowId};

    #[path = "util/fill.rs"]
@@ -27,13 +22,16 @@ fn main() -> std::process::ExitCode {

    #[derive(Default, Debug)]
    struct PumpDemo {
-        window: Option<Box<dyn Window>>,
+        surface: Option<Surface<OwnedDisplayHandle, 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!");
-            self.window = Some(event_loop.create_window(window_attributes).unwrap());
+            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());
        }

        fn window_event(
@@ -44,16 +42,16 @@ fn main() -> std::process::ExitCode {
        ) {
            info!("{event:?}");

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

            match event {
                WindowEvent::CloseRequested => event_loop.exit(),
                WindowEvent::RedrawRequested => {
-                    fill::fill_window(window.as_ref());
-                    window.request_redraw();
+                    fill::fill(surface);
+                    surface.window().request_redraw();
                },
                _ => (),
            }
@@ -83,13 +81,7 @@ fn main() -> std::process::ExitCode {
    }
 }

-#[cfg(not(any(
-    target_os = "windows",
-    target_os = "macos",
-    x11_platform,
-    wayland_platform,
-    target_os = "android",
-)))]
+#[cfg(any(ios_platform, web_platform, orbital_platform))]
 fn main() {
    panic!("This platform doesn't support pump_events.")
 }
--- a/winit/examples/run_on_demand.rs
+++ b/winit/examples/run_on_demand.rs
@@ -1,21 +1,16 @@
 #![allow(clippy::single_match)]

 // Limit this example to only compatible platforms.
-#[cfg(any(
-    target_os = "windows",
-    target_os = "macos",
-    x11_platform,
-    wayland_platform,
-    target_os = "redox"
-))]
+#[cfg(any(windows_platform, macos_platform, x11_platform, wayland_platform, orbital_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};
+    use winit::event_loop::{ActiveEventLoop, EventLoop, OwnedDisplayHandle};
    use winit::window::{Window, WindowAttributes, WindowId};

    #[path = "util/fill.rs"]
@@ -23,27 +18,30 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
    #[path = "util/tracing.rs"]
    mod tracing;

-    #[derive(Default, Debug)]
+    #[derive(Debug)]
    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(window) = self.window.as_ref() {
-                window.request_redraw();
+            if let Some(surface) = self.surface.as_ref() {
+                surface.window().request_redraw();
            }
        }

        fn can_create_surfaces(&mut self, event_loop: &dyn ActiveEventLoop) {
            let window_attributes = WindowAttributes::default()
-                .with_title("Fantastic window number one!")
+                .with_title(format!("Fantastic window number {}!", self.idx))
                .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());
-            self.window = Some(window);
+
+            let surface = Surface::new(&self.context, window).unwrap();
+            self.surface = Some(surface);
        }

        fn window_event(
@@ -59,19 +57,17 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                return;
            }

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

            match event {
                WindowEvent::CloseRequested => {
                    info!("Window {} CloseRequested", self.idx);
-                    fill::cleanup_window(window.as_ref());
-                    self.window = None;
+                    self.surface = None;
                },
                WindowEvent::RedrawRequested => {
-                    fill::fill_window(window.as_ref());
+                    fill::fill(surface);
                },
                _ => (),
            }
@@ -82,7 +78,8 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {

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

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

    info!("Finished first loop");
@@ -96,11 +93,11 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 }

 #[cfg(not(any(
-    target_os = "windows",
-    target_os = "macos",
+    windows_platform,
+    macos_platform,
    x11_platform,
    wayland_platform,
-    target_os = "redox"
+    orbital_platform
 )))]
 fn main() {
    panic!("This example is not supported on this platform")
--- a/winit/examples/util/fill.rs
+++ b/winit/examples/util/fill.rs
@@ -1,115 +1,43 @@
-//! 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.
-
-use std::cell::RefCell;
-use std::collections::HashMap;
-use std::mem;
-use std::mem::ManuallyDrop;
 use std::num::NonZeroU32;
-#[cfg(not(target_family = "wasm"))]
-use std::time::Instant;

-use softbuffer::{Context, Surface};
-#[cfg(target_family = "wasm")]
-use web_time::Instant;
-use winit::window::{Window, WindowId};
+use rwh_06::{HasDisplayHandle, HasWindowHandle};
+use softbuffer::Surface;
+use winit::window::Window;

-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.
+/// Resize the surface.
+pub fn resize(
+    surface: &mut Surface<impl HasDisplayHandle, impl HasWindowHandle>,
+    surface_size: dpi::PhysicalSize<u32>,
+) {
+    // Handle zero-sized buffers.
    //
-    // A static, thread-local map of graphics contexts to open windows.
-    static GC: ManuallyDrop<RefCell<Option<GraphicsContext>>> = const { ManuallyDrop::new(RefCell::new(None)) };
+    // FIXME(madsmtm): This should be done by softbuffer internally in the future:
+    // https://github.com/rust-windowing/softbuffer/issues/238
+    let (Some(width), Some(height)) =
+        (NonZeroU32::new(surface_size.width), NonZeroU32::new(surface_size.height))
+    else {
+        return;
+    };
+
+    surface.resize(width, height).expect("Failed to resize the softbuffer surface");
 }

-/// The graphics context used to draw to a window.
-struct GraphicsContext {
-    /// The global softbuffer context.
-    context: RefCell<Context<&'static dyn Window>>,
+/// Fill the window buffer with a solid color.
+pub fn fill_with_color(
+    surface: &mut Surface<impl HasDisplayHandle, impl HasWindowHandle + AsRef<dyn Window>>,
+    color: u32,
+) {
+    let surface_size = surface.window().as_ref().surface_size();
+    resize(surface, surface_size);

-    /// 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");
-    })
+    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 fill_window_with_animated_color(window: &dyn Window, start: Instant) {
-    let time = start.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;
-    fill_window_with_color(window, color);
-}
-
-#[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);
-        }
-    });
+pub fn fill(
+    surface: &mut Surface<impl HasDisplayHandle, impl HasWindowHandle + AsRef<dyn Window>>,
+) {
+    fill_with_color(surface, 0xff181818);
 }
--- a/winit/examples/util/tracing.rs
+++ b/winit/examples/util/tracing.rs
@@ -1,4 +1,4 @@
-#[cfg(not(target_family = "wasm"))]
+#[cfg(not(web_platform))]
 pub fn init() {
    use tracing_subscriber::filter::{EnvFilter, LevelFilter};

@@ -9,7 +9,7 @@ pub fn init() {
        .init();
 }

-#[cfg(target_family = "wasm")]
+#[cfg(web_platform)]
 pub fn init() {
    use tracing_subscriber::layer::SubscriberExt;
    use tracing_subscriber::util::SubscriberInitExt;
--- a/winit/examples/window.rs
+++ b/winit/examples/window.rs
@@ -2,10 +2,13 @@

 use std::error::Error;

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

 #[path = "util/fill.rs"]
@@ -15,24 +18,22 @@ mod tracing;

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

 impl ApplicationHandler for App {
    fn can_create_surfaces(&mut self, event_loop: &dyn ActiveEventLoop) {
+        #[cfg(not(web_platform))]
        let window_attributes = WindowAttributes::default();
-        #[cfg(target_family = "wasm")]
-        let window_attributes = window_attributes.with_platform_attributes(Box::new(
-            winit::platform::web::WindowAttributesWeb::default().with_append(true),
-        ));
-        self.window = match event_loop.create_window(window_attributes) {
-            Ok(window) => Some(window),
-            Err(err) => {
-                error!("error creating window: {err}");
-                event_loop.exit();
-                return;
-            },
-        }
+        #[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);
    }

    fn window_event(&mut self, event_loop: &dyn ActiveEventLoop, _: WindowId, event: WindowEvent) {
@@ -42,8 +43,10 @@ impl ApplicationHandler for App {
                info!("Close was requested; stopping");
                event_loop.exit();
            },
-            WindowEvent::SurfaceResized(_) => {
-                self.window.as_ref().expect("resize event without a window").request_redraw();
+            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::RedrawRequested => {
                // Redraw the application.
@@ -52,13 +55,15 @@ 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 window = self.window.as_ref().expect("redraw request without a window");
+                let surface = self.surface.as_mut().expect("redraw event without a surface");

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

                // Draw.
-                fill::fill_window(window.as_ref());
+                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");

                // For contiguous redraw loop you can request a redraw from here.
                // window.request_redraw();
@@ -69,7 +74,7 @@ impl ApplicationHandler for App {
 }

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

    tracing::init();
--- a/winit/examples/x11_embed.rs
+++ b/winit/examples/x11_embed.rs
@@ -3,9 +3,10 @@ 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};
+    use winit::event_loop::{ActiveEventLoop, EventLoop, OwnedDisplayHandle};
    use winit::platform::x11::WindowAttributesX11;
    use winit::window::{Window, WindowAttributes, WindowId};

@@ -17,7 +18,7 @@ fn main() -> Result<(), Box<dyn Error>> {
    #[derive(Debug)]
    pub struct XEmbedDemo {
        parent_window_id: u32,
-        window: Option<Box<dyn Window>>,
+        surface: Option<Surface<OwnedDisplayHandle, Box<dyn Window>>>,
    }

    impl ApplicationHandler for XEmbedDemo {
@@ -29,7 +30,10 @@ fn main() -> Result<(), Box<dyn Error>> {
                WindowAttributesX11::default().with_embed_parent_window(self.parent_window_id);
            window_attributes = window_attributes.with_platform_attributes(Box::new(x11_attrs));

-            self.window = Some(event_loop.create_window(window_attributes).unwrap());
+            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);
        }

        fn window_event(
@@ -38,19 +42,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 => {
-                    window.pre_present_notify();
-                    fill::fill_window(window.as_ref());
+                    let surface = self.surface.as_mut().unwrap();
+                    surface.window().pre_present_notify();
+                    fill::fill(surface);
                },
                _ => (),
            }
        }

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

@@ -63,7 +67,7 @@ fn main() -> Result<(), Box<dyn Error>> {
    tracing::init();
    let event_loop = EventLoop::new()?;

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

 #[cfg(not(x11_platform))]
--- a/winit/src/changelog/unreleased.md
+++ b/winit/src/changelog/unreleased.md
@@ -48,6 +48,8 @@ changelog entry.
 - Implement `Send` and `Sync` for `OwnedDisplayHandle`.
 - Use new macOS 15 cursors for resize icons.
 - On Android, added scancode conversions for more obscure key codes.
+- On Wayland, added `HoldGesture` event for multi-finger hold gestures
+- On Wayland, added ext-background-effect-v1 support.

 ### Changed

@@ -56,7 +58,12 @@ changelog entry.

 ### Fixed

+- On Windows, fix a freeze that occurs when the keyboard layout is switched by
+  tools such as Punto Switcher. The `WM_INPUTLANGCHANGE` message is now handled
+  to refresh the cached keyboard layout, while still deferring to
+  `DefWindowProc` for normal propagation.
 - On Redox, handle `EINTR` when reading from `event_socket` instead of panicking.
 - On Wayland, switch from using the `ahash` hashing algorithm to `foldhash`.
 - On macOS, fix borderless game presentation options not sticking after switching spaces.
 - On macOS, fix IME being locked on (regardless of requests to disable) after being enabled once.
+- On macOS, fix a panic and incorrect cursor position in Ime::Preedit when the preedit string contains special characters (ie. emojis) caused by incorrect UTF-16 to UTF-8 offset conversion.
Author	SHA1	Message	Date
dependabot[bot]	ba6da05252	chore: bump the github-actions group across 1 directory with 3 updates Bumps the github-actions group with 3 updates in the / directory: [actions/cache](https://github.com/actions/cache), [actions/checkout](https://github.com/actions/checkout) and [actions/upload-pages-artifact](https://github.com/actions/upload-pages-artifact). Updates `actions/cache` from 5 to 6 - [Release notes](https://github.com/actions/cache/releases) - [Changelog](https://github.com/actions/cache/blob/main/RELEASES.md) - [Commits](https://github.com/actions/cache/compare/v5...v6) Updates `actions/checkout` from 6 to 7 - [Release notes](https://github.com/actions/checkout/releases) - [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md) - [Commits](https://github.com/actions/checkout/compare/v6...v7) Updates `actions/upload-pages-artifact` from 4 to 5 - [Release notes](https://github.com/actions/upload-pages-artifact/releases) - [Commits](https://github.com/actions/upload-pages-artifact/compare/v4...v5) --- updated-dependencies: - dependency-name: actions/cache dependency-version: '6' dependency-type: direct:production update-type: version-update:semver-major dependency-group: github-actions - dependency-name: actions/checkout dependency-version: '7' dependency-type: direct:production update-type: version-update:semver-major dependency-group: github-actions - dependency-name: actions/upload-pages-artifact dependency-version: '5' dependency-type: direct:production update-type: version-update:semver-major dependency-group: github-actions ... Signed-off-by: dependabot[bot] <support@github.com>	2026-06-24 18:53:04 +00:00
Vitaly Kravchenko	27e17e3f29	Fix AppKit live resize redraw timing	2026-06-24 17:03:24 +02:00
Simon Hausmann	56fde0791b	Fix CI Pin wayland-protocols to the previous version that still compiles with our MSRV.	2026-06-24 16:58:57 +02:00
William-Selna	4ef144b519	macOS: make Ime::Preedit cursor range surrogate-safe in setMarkedText `setMarkedText:selectedRange:replacementRange:` converted the IME's UTF-16 `selectedRange` into UTF-8 byte offsets by taking `substringToIndex:` prefixes and measuring them with `NSString::len()` (`lengthOfBytesUsingEncoding:NSUTF8StringEncoding`). When an index falls inside a surrogate pair, the prefix ends in a lone high surrogate, which UTF-8 cannot represent, so `lengthOfBytesUsingEncoding:` returns 0 for the entire prefix and the offset silently collapses to 0.	2026-06-20 01:34:43 +09:00
Mads Marquart	7fe8c206ae	chore: avoid `unsafe` in examples By using `OwnedDisplayHandle`, which uses reference-counting, instead of `DisplayHandle<'static>` (where the user has to guarantee that the Application doesn't outlive the event loop).	2026-06-15 03:36:22 +09:00
Sergey Kikevich	fb78ecbb03	windows: fix freeze on keyboard layout switch Any winit app on Windows freezes when the keyboard layout is switched by tools such as Punto Switcher. A minidump of the frozen process shows the main thread blocked in MsgWaitForMultipleObjectsEx (winit's event-loop wait), re-entered during message dispatch through the switcher's injected global hook (pshook64.dll, via CallNextHookEx) — a re-entrant Win32 message-loop wait, not a mutex deadlock (no LAYOUT_CACHE frames present). Handle WM_INPUTLANGCHANGE to refresh the cached keyboard layout, then defer to DefWindowProc so the message still propagates to first-level child windows as the Win32 docs require. The cache refresh is the minimal change that stops the freeze (verified on Windows 11 by isolation variants); update_modifiers and swallowing the message are not needed.	2026-06-15 03:29:35 +09:00
Martin Marmsoler	850d5f59a7	winit-wayland: add pointer gesture hold	2026-06-13 02:36:23 +09:00
Martin Marmsoler	81b2729765	winit-x11: fix clippy lint	2026-06-05 02:25:58 +09:00
Kirill Chibisov	c4afadbfab	winit-wayland: use `ext-background-effect` if available A more modern protocol compared to the KDE one.	2026-04-04 23:59:33 +09:00
dependabot[bot]	b5252f1366	chore: bump actions/configure-pages (#4550 )	2026-03-28 07:44:01 +01:00
Mads Marquart	f93a223da9	Clean up cargo-deny Remove the matrix in the CI action; EmbarkStudios/cargo-deny#324 hasn't been resolved yet, but since we've split Winit out into multiple crates, there's still value in minimizing dependency conflicts even if they won't be hit by users, since e.g. Rust-Analyzer will by default check the entire workspace (and thus download and compile duplicate dependencies).	2026-03-28 10:28:31 +09:00
dependabot[bot]	d75a0dada0	chore: bump actions/deploy-pages from 4 to 5 (#4545 )	2026-03-26 06:32:41 +01:00