diff --git a/CHANGELOG.md b/CHANGELOG.md
index 97e883e730..ce040a769c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,6 @@
 # Unreleased
 
+- **Breaking:** updated `raw-window-handle` dependency to `0.6`.
 - Bump MSRV from `1.65` to `1.70`.
 
 # Version 0.31.3
diff --git a/glutin-winit/Cargo.toml b/glutin-winit/Cargo.toml
index bc78d635d9..954b3f91ce 100644
--- a/glutin-winit/Cargo.toml
+++ b/glutin-winit/Cargo.toml
@@ -20,8 +20,8 @@ wayland = ["glutin/wayland", "winit/wayland"]
 
 [dependencies]
 glutin = { version = "0.31.0", path = "../glutin", default-features = false }
-raw-window-handle = "0.5.2"
-winit = { version = "0.29.2", default-features = false, features = ["rwh_05"] }
+raw-window-handle = "0.6"
+winit = { version = "0.29.2", default-features = false, features = ["rwh_06"] }
 
 [build-dependencies]
 cfg_aliases = "0.1.1"
diff --git a/glutin-winit/src/lib.rs b/glutin-winit/src/lib.rs
index cb3b2cd8f9..4dc9129f6d 100644
--- a/glutin-winit/src/lib.rs
+++ b/glutin-winit/src/lib.rs
@@ -21,9 +21,9 @@ use glutin::platform::x11::X11GlConfigExt;
 use glutin::prelude::*;
 
 #[cfg(wgl_backend)]
-use raw_window_handle::HasRawWindowHandle;
+use raw_window_handle::HasWindowHandle;
 
-use raw_window_handle::{HasRawDisplayHandle, RawWindowHandle};
+use raw_window_handle::{HasDisplayHandle, RawWindowHandle};
 use winit::error::OsError;
 use winit::event_loop::EventLoopWindowTarget;
 use winit::window::{Window, WindowBuilder};
@@ -104,7 +104,10 @@ impl DisplayBuilder {
         };
 
         #[cfg(wgl_backend)]
-        let raw_window_handle = window.as_ref().map(|window| window.raw_window_handle());
+        let raw_window_handle = window
+            .as_ref()
+            .and_then(|window| window.window_handle().ok())
+            .map(|handle| handle.as_raw());
         #[cfg(not(wgl_backend))]
         let raw_window_handle = None;
 
@@ -170,7 +173,8 @@ fn create_display<T>(
         ApiPreference::FallbackEgl => DisplayApiPreference::WglThenEgl(_raw_window_handle),
     };
 
-    unsafe { Ok(Display::new(window_target.raw_display_handle(), _preference)?) }
+    let handle = window_target.display_handle()?.as_raw();
+    unsafe { Ok(Display::new(handle, _preference)?) }
 }
 
 /// Finalize [`Window`] creation by applying the options from the [`Config`], be
diff --git a/glutin-winit/src/window.rs b/glutin-winit/src/window.rs
index 09d1717f01..24fe34b8ea 100644
--- a/glutin-winit/src/window.rs
+++ b/glutin-winit/src/window.rs
@@ -5,7 +5,7 @@ use glutin::surface::{
     GlSurface, ResizeableSurface, Surface, SurfaceAttributes, SurfaceAttributesBuilder,
     SurfaceTypeTrait, WindowSurface,
 };
-use raw_window_handle::HasRawWindowHandle;
+use raw_window_handle::{HandleError, HasWindowHandle};
 use winit::window::Window;
 
 /// [`Window`] extensions for working with [`glutin`] surfaces.
@@ -25,7 +25,7 @@ pub trait GlWindow {
     fn build_surface_attributes(
         &self,
         builder: SurfaceAttributesBuilder<WindowSurface>,
-    ) -> SurfaceAttributes<WindowSurface>;
+    ) -> Result<SurfaceAttributes<WindowSurface>, HandleError>;
 
     /// Resize the surface to the window inner size.
     ///
@@ -51,9 +51,10 @@ impl GlWindow for Window {
     fn build_surface_attributes(
         &self,
         builder: SurfaceAttributesBuilder<WindowSurface>,
-    ) -> SurfaceAttributes<WindowSurface> {
+    ) -> Result<SurfaceAttributes<WindowSurface>, HandleError> {
         let (w, h) = self.inner_size().non_zero().expect("invalid zero inner size");
-        builder.build(self.raw_window_handle(), w, h)
+        let handle = self.window_handle()?.as_raw();
+        Ok(builder.build(handle, w, h))
     }
 
     fn resize_surface(
diff --git a/glutin/Cargo.toml b/glutin/Cargo.toml
index 747a4afbbd..a1fdc660ab 100644
--- a/glutin/Cargo.toml
+++ b/glutin/Cargo.toml
@@ -23,7 +23,7 @@ wayland = ["wayland-sys", "egl"]
 bitflags = "2.2.1"
 libloading = { version = "0.8.0", optional = true }
 once_cell = "1.13"
-raw-window-handle = "0.5.2"
+raw-window-handle = "0.6"
 
 [target.'cfg(windows)'.dependencies]
 glutin_egl_sys = { version = "0.6.0", path = "../glutin_egl_sys", optional = true }
diff --git a/glutin/src/api/cgl/surface.rs b/glutin/src/api/cgl/surface.rs
index 39e90e8fe0..26044ea77c 100644
--- a/glutin/src/api/cgl/surface.rs
+++ b/glutin/src/api/cgl/surface.rs
@@ -5,7 +5,7 @@ use std::marker::PhantomData;
 use std::num::NonZeroU32;
 
 use objc2::rc::Id;
-use objc2_app_kit::{NSView, NSWindow};
+use objc2_app_kit::NSView;
 use objc2_foundation::{run_on_main, MainThreadBound, MainThreadMarker};
 use raw_window_handle::RawWindowHandle;
 
@@ -59,28 +59,19 @@ impl Display {
 
         // SAFETY: Validity of the view and window is ensured by caller
         // This function makes sure the window is non null.
-        let ns_view = if let Some(ns_view) = unsafe { Id::retain(native_window.ns_view.cast()) } {
+        let ns_view = if let Some(ns_view) =
+            unsafe { Id::retain(native_window.ns_view.as_ptr().cast()) }
+        {
             ns_view
         } else {
             return Err(ErrorKind::NotSupported("ns_view of provided native window is nil").into());
         };
         let ns_view = MainThreadBound::new(ns_view, mtm);
 
-        let ns_window =
-            if let Some(ns_window) = unsafe { Id::retain(native_window.ns_window.cast()) } {
-                ns_window
-            } else {
-                return Err(
-                    ErrorKind::NotSupported("ns_window of provided native window is nil").into()
-                );
-            };
-        let ns_window = MainThreadBound::new(ns_window, mtm);
-
         let surface = Surface {
             display: self.clone(),
             config: config.clone(),
             ns_view,
-            ns_window,
             _nosync: PhantomData,
             _ty: PhantomData,
         };
@@ -93,7 +84,6 @@ pub struct Surface<T: SurfaceTypeTrait> {
     display: Display,
     config: Config,
     pub(crate) ns_view: MainThreadBound<Id<NSView>>,
-    ns_window: MainThreadBound<Id<NSWindow>>,
     _nosync: PhantomData<*const std::ffi::c_void>,
     _ty: PhantomData<T>,
 }
@@ -110,21 +100,27 @@ impl<T: SurfaceTypeTrait> GlSurface<T> for Surface<T> {
     }
 
     fn width(&self) -> Option<u32> {
-        let window = &self.ns_window;
         let view = &self.ns_view;
         run_on_main(|mtm| {
-            let scale_factor = window.get(mtm).backingScaleFactor();
-            let frame = view.get(mtm).frame();
+            let view = view.get(mtm);
+            let scale_factor = match view.window() {
+                Some(window) => window.backingScaleFactor(),
+                None => 1.0,
+            };
+            let frame = view.frame();
             Some((frame.size.width * scale_factor) as u32)
         })
     }
 
     fn height(&self) -> Option<u32> {
-        let window = &self.ns_window;
         let view = &self.ns_view;
         run_on_main(|mtm| {
-            let scale_factor = window.get(mtm).backingScaleFactor();
-            let frame = view.get(mtm).frame();
+            let view = view.get(mtm);
+            let scale_factor = match view.window() {
+                Some(window) => window.backingScaleFactor(),
+                None => 1.0,
+            };
+            let frame = view.frame();
             Some((frame.size.height * scale_factor) as u32)
         })
     }
diff --git a/glutin/src/api/egl/config.rs b/glutin/src/api/egl/config.rs
index e400736cc8..ecbdea9d4e 100644
--- a/glutin/src/api/egl/config.rs
+++ b/glutin/src/api/egl/config.rs
@@ -196,8 +196,8 @@ impl Display {
                 // XXX This can't be done by passing visual in the EGL attributes
                 // when calling `eglChooseConfig` since the visual is ignored.
                 match template.native_window {
-                    Some(RawWindowHandle::Xcb(xcb)) if xcb.visual_id > 0 => {
-                        xcb.visual_id as u32 == config.native_visual()
+                    Some(RawWindowHandle::Xcb(xcb)) => {
+                        xcb.visual_id.map_or(false, |id| id.get() == config.native_visual())
                     },
                     Some(RawWindowHandle::Xlib(xlib)) if xlib.visual_id > 0 => {
                         xlib.visual_id as u32 == config.native_visual()
@@ -386,7 +386,7 @@ impl X11GlConfigExt for Config {
         match *self.inner.display.inner._native_display? {
             raw_window_handle::RawDisplayHandle::Xlib(display_handle) => unsafe {
                 let xid = self.native_visual();
-                X11VisualInfo::from_xid(display_handle.display as *mut _, xid as _)
+                X11VisualInfo::from_xid(display_handle.display?.as_ptr() as *mut _, xid as _)
             },
             _ => None,
         }
diff --git a/glutin/src/api/egl/display.rs b/glutin/src/api/egl/display.rs
index ea64ba66b2..cdc1f8afdf 100644
--- a/glutin/src/api/egl/display.rs
+++ b/glutin/src/api/egl/display.rs
@@ -14,6 +14,8 @@ use glutin_egl_sys::egl::types::{EGLAttrib, EGLDisplay, EGLint};
 use once_cell::sync::OnceCell;
 
 use raw_window_handle::RawDisplayHandle;
+#[cfg(x11_platform)]
+use raw_window_handle::XlibDisplayHandle;
 
 use crate::config::ConfigTemplate;
 use crate::context::Version;
@@ -244,16 +246,16 @@ impl Display {
             RawDisplayHandle::Wayland(handle)
                 if extensions.contains("EGL_KHR_platform_wayland") =>
             {
-                (egl::PLATFORM_WAYLAND_KHR, handle.display)
+                (egl::PLATFORM_WAYLAND_KHR, handle.display.as_ptr())
             },
             #[cfg(x11_platform)]
             RawDisplayHandle::Xlib(handle) if extensions.contains("EGL_KHR_platform_x11") => {
                 attrs.push(egl::PLATFORM_X11_SCREEN_KHR as EGLAttrib);
                 attrs.push(handle.screen as EGLAttrib);
-                (egl::PLATFORM_X11_KHR, handle.display)
+                (egl::PLATFORM_X11_KHR, handle.display.map_or(ptr::null_mut(), |d| d.as_ptr()))
             },
             RawDisplayHandle::Gbm(handle) if extensions.contains("EGL_KHR_platform_gbm") => {
-                (egl::PLATFORM_GBM_KHR, handle.gbm_device)
+                (egl::PLATFORM_GBM_KHR, handle.gbm_device.as_ptr())
             },
             RawDisplayHandle::Android(_) if extensions.contains("EGL_KHR_platform_android") => {
                 (egl::PLATFORM_ANDROID_KHR, egl::DEFAULT_DISPLAY as *mut _)
@@ -265,11 +267,6 @@ impl Display {
             },
         };
 
-        // Be explicit here.
-        if display.is_null() {
-            display = egl::DEFAULT_DISPLAY as *mut _;
-        }
-
         // Push at the end so we can pop it on failure
         let mut has_display_reference = extensions.contains("EGL_KHR_display_reference");
         if has_display_reference {
@@ -320,13 +317,13 @@ impl Display {
             RawDisplayHandle::Wayland(handle)
                 if extensions.contains("EGL_EXT_platform_wayland") =>
             {
-                (egl::PLATFORM_WAYLAND_EXT, handle.display)
+                (egl::PLATFORM_WAYLAND_EXT, handle.display.as_ptr())
             },
             #[cfg(x11_platform)]
             RawDisplayHandle::Xlib(handle) if extensions.contains("EGL_EXT_platform_x11") => {
                 attrs.push(egl::PLATFORM_X11_SCREEN_EXT as EGLint);
                 attrs.push(handle.screen as EGLint);
-                (egl::PLATFORM_X11_EXT, handle.display)
+                (egl::PLATFORM_X11_EXT, handle.display.map_or(ptr::null_mut(), |d| d.as_ptr()))
             },
             #[cfg(x11_platform)]
             RawDisplayHandle::Xcb(handle)
@@ -335,10 +332,10 @@ impl Display {
             {
                 attrs.push(egl::PLATFORM_XCB_SCREEN_EXT as EGLint);
                 attrs.push(handle.screen as EGLint);
-                (egl::PLATFORM_XCB_EXT, handle.connection)
+                (egl::PLATFORM_XCB_EXT, handle.connection.map_or(ptr::null_mut(), |c| c.as_ptr()))
             },
             RawDisplayHandle::Gbm(handle) if extensions.contains("EGL_MESA_platform_gbm") => {
-                (egl::PLATFORM_GBM_MESA, handle.gbm_device)
+                (egl::PLATFORM_GBM_MESA, handle.gbm_device.as_ptr())
             },
             RawDisplayHandle::Windows(..) if extensions.contains("EGL_ANGLE_platform_angle") => {
                 // Only CreateWindowSurface appears to work with Angle.
@@ -352,11 +349,6 @@ impl Display {
             },
         };
 
-        // Be explicit here.
-        if display.is_null() {
-            display = egl::DEFAULT_DISPLAY as *mut _;
-        }
-
         // Push at the end so we can pop it on failure
         let mut has_display_reference = extensions.contains("EGL_KHR_display_reference");
         if has_display_reference {
@@ -405,9 +397,11 @@ impl Display {
 
     fn get_display(egl: &Egl, display: RawDisplayHandle) -> Result<EglDisplay> {
         let mut display = match display {
-            RawDisplayHandle::Gbm(handle) => handle.gbm_device,
+            RawDisplayHandle::Gbm(handle) => handle.gbm_device.as_ptr(),
             #[cfg(x11_platform)]
-            RawDisplayHandle::Xlib(handle) => handle.display,
+            RawDisplayHandle::Xlib(XlibDisplayHandle { display, .. }) => {
+                display.map_or(egl::DEFAULT_DISPLAY as *mut _, |d| d.as_ptr())
+            },
             RawDisplayHandle::Android(_) => egl::DEFAULT_DISPLAY as *mut _,
             _ => {
                 return Err(
@@ -416,10 +410,6 @@ impl Display {
             },
         };
 
-        if display.is_null() {
-            display = egl::DEFAULT_DISPLAY as *mut _;
-        }
-
         let display = unsafe { egl.GetDisplay(display) };
         Self::check_display_error(display).map(EglDisplay::Legacy)
     }
diff --git a/glutin/src/api/egl/surface.rs b/glutin/src/api/egl/surface.rs
index 7a13d69c4c..800d911c01 100644
--- a/glutin/src/api/egl/surface.rs
+++ b/glutin/src/api/egl/surface.rs
@@ -472,14 +472,10 @@ impl NativeWindow {
         let native_window = match raw_window_handle {
             #[cfg(wayland_platform)]
             RawWindowHandle::Wayland(window_handle) => unsafe {
-                if window_handle.surface.is_null() {
-                    return Err(ErrorKind::BadNativeWindow.into());
-                }
-
                 let ptr = ffi_dispatch!(
                     wayland_egl_handle(),
                     wl_egl_window_create,
-                    window_handle.surface.cast(),
+                    window_handle.surface.as_ptr().cast(),
                     _width.get() as _,
                     _height.get() as _
                 );
@@ -497,37 +493,15 @@ impl NativeWindow {
                 Self::Xlib(window_handle.window as _)
             },
             #[cfg(x11_platform)]
-            RawWindowHandle::Xcb(window_handle) => {
-                if window_handle.window == 0 {
-                    return Err(ErrorKind::BadNativeWindow.into());
-                }
-
-                Self::Xcb(window_handle.window as _)
-            },
+            RawWindowHandle::Xcb(window_handle) => Self::Xcb(window_handle.window.get() as _),
             #[cfg(android_platform)]
             RawWindowHandle::AndroidNdk(window_handle) => {
-                if window_handle.a_native_window.is_null() {
-                    return Err(ErrorKind::BadNativeWindow.into());
-                }
-
-                Self::Android(window_handle.a_native_window)
+                Self::Android(window_handle.a_native_window.as_ptr())
             },
             #[cfg(windows)]
-            RawWindowHandle::Win32(window_handle) => {
-                if window_handle.hwnd.is_null() {
-                    return Err(ErrorKind::BadNativeWindow.into());
-                }
-
-                Self::Win32(window_handle.hwnd as _)
-            },
+            RawWindowHandle::Win32(window_handle) => Self::Win32(window_handle.hwnd.get() as _),
             #[cfg(free_unix)]
-            RawWindowHandle::Gbm(window_handle) => {
-                if window_handle.gbm_surface.is_null() {
-                    return Err(ErrorKind::BadNativeWindow.into());
-                }
-
-                Self::Gbm(window_handle.gbm_surface)
-            },
+            RawWindowHandle::Gbm(window_handle) => Self::Gbm(window_handle.gbm_surface.as_ptr()),
             _ => {
                 return Err(
                     ErrorKind::NotSupported("provided native window is not supported").into()
diff --git a/glutin/src/api/glx/display.rs b/glutin/src/api/glx/display.rs
index 1cdf96d191..8b52dfba80 100644
--- a/glutin/src/api/glx/display.rs
+++ b/glutin/src/api/glx/display.rs
@@ -44,12 +44,9 @@ impl Display {
     ) -> Result<Self> {
         // Don't load GLX when unsupported platform was requested.
         let (display, screen) = match display {
-            RawDisplayHandle::Xlib(handle) => {
-                if handle.display.is_null() {
-                    return Err(ErrorKind::BadDisplay.into());
-                }
-
-                (GlxDisplay(handle.display as *mut _), handle.screen as i32)
+            RawDisplayHandle::Xlib(handle) => match handle.display {
+                Some(display) => (GlxDisplay(display.as_ptr() as *mut _), handle.screen as i32),
+                None => return Err(ErrorKind::BadDisplay.into()),
             },
             _ => {
                 return Err(
diff --git a/glutin/src/api/wgl/config.rs b/glutin/src/api/wgl/config.rs
index ad5fabbe8d..4f6a368b29 100644
--- a/glutin/src/api/wgl/config.rs
+++ b/glutin/src/api/wgl/config.rs
@@ -33,7 +33,7 @@ impl Display {
         template: ConfigTemplate,
     ) -> Result<Box<dyn Iterator<Item = Config> + '_>> {
         let hwnd = match template.native_window {
-            Some(RawWindowHandle::Win32(window_handle)) => window_handle.hwnd as _,
+            Some(RawWindowHandle::Win32(window_handle)) => window_handle.hwnd.get() as _,
             _ => 0,
         };
         let hdc = unsafe { gdi::GetDC(hwnd) };
@@ -289,7 +289,7 @@ impl Config {
     /// The `raw_window_handle` should point to a valid value.
     pub unsafe fn apply_on_native_window(&self, raw_window_handle: &RawWindowHandle) -> Result<()> {
         let hdc = match raw_window_handle {
-            RawWindowHandle::Win32(window) => unsafe { gdi::GetDC(window.hwnd as _) },
+            RawWindowHandle::Win32(window) => unsafe { gdi::GetDC(window.hwnd.get() as _) },
             _ => return Err(ErrorKind::BadNativeWindow.into()),
         };
 
diff --git a/glutin/src/api/wgl/context.rs b/glutin/src/api/wgl/context.rs
index 4ba8fd42eb..fe5278456e 100644
--- a/glutin/src/api/wgl/context.rs
+++ b/glutin/src/api/wgl/context.rs
@@ -35,7 +35,7 @@ impl Display {
         let hdc = match context_attributes.raw_window_handle.as_ref() {
             handle @ Some(RawWindowHandle::Win32(window)) => unsafe {
                 let _ = config.apply_on_native_window(handle.unwrap());
-                gdi::GetDC(window.hwnd as _)
+                gdi::GetDC(window.hwnd.get() as _)
             },
             _ => config.inner.hdc,
         };
diff --git a/glutin/src/api/wgl/display.rs b/glutin/src/api/wgl/display.rs
index 62c1309bf5..ee54579c65 100644
--- a/glutin/src/api/wgl/display.rs
+++ b/glutin/src/api/wgl/display.rs
@@ -60,8 +60,10 @@ impl Display {
         let (wgl_extra, client_extensions) =
             if let Some(RawWindowHandle::Win32(window)) = native_window {
                 unsafe {
-                    let (wgl_extra, client_extensions) =
-                        super::load_extra_functions(window.hinstance as _, window.hwnd as _)?;
+                    let (wgl_extra, client_extensions) = super::load_extra_functions(
+                        window.hinstance.map_or(0, |i| i.get()) as _,
+                        window.hwnd.get() as _,
+                    )?;
                     (Some(wgl_extra), client_extensions)
                 }
             } else {
diff --git a/glutin/src/api/wgl/surface.rs b/glutin/src/api/wgl/surface.rs
index 41fe159efc..15f45089e4 100644
--- a/glutin/src/api/wgl/surface.rs
+++ b/glutin/src/api/wgl/surface.rs
@@ -49,12 +49,8 @@ impl Display {
     ) -> Result<Surface<WindowSurface>> {
         let hwnd = match surface_attributes.raw_window_handle.as_ref().unwrap() {
             handle @ RawWindowHandle::Win32(window_handle) => {
-                if window_handle.hwnd.is_null() {
-                    return Err(ErrorKind::BadNativeWindow.into());
-                }
-
                 let _ = unsafe { config.apply_on_native_window(handle) };
-                window_handle.hwnd as HWND
+                window_handle.hwnd.get() as HWND
             },
             _ => {
                 return Err(
diff --git a/glutin_examples/Cargo.toml b/glutin_examples/Cargo.toml
index 40b3c7de1d..503df41d2b 100644
--- a/glutin_examples/Cargo.toml
+++ b/glutin_examples/Cargo.toml
@@ -22,11 +22,11 @@ wayland = ["glutin-winit/wayland", "winit/wayland-dlopen", "winit/wayland-csd-ad
 glutin = { path = "../glutin", default-features = false }
 glutin-winit = { path = "../glutin-winit", default-features = false }
 png = { version = "0.17.6", optional = true }
-raw-window-handle = "0.5"
+raw-window-handle = "0.6"
 winit = { version = "0.29.2", default-features = false, features = ["rwh_05"] }
 
 [target.'cfg(target_os = "android")'.dependencies]
-winit = { version = "0.29.2", default-features = false, features = ["android-native-activity", "rwh_05"] }
+winit = { version = "0.29.2", default-features = false, features = ["android-native-activity", "rwh_06"] }
 
 [build-dependencies]
 gl_generator = "0.14"
diff --git a/glutin_examples/examples/switch_render_thread.rs b/glutin_examples/examples/switch_render_thread.rs
index 672f04f369..1f6584637a 100644
--- a/glutin_examples/examples/switch_render_thread.rs
+++ b/glutin_examples/examples/switch_render_thread.rs
@@ -13,7 +13,7 @@ use glutin::surface::{GlSurface, Surface, WindowSurface};
 use glutin_examples::gl::types::GLfloat;
 use glutin_examples::{gl_config_picker, Renderer};
 use glutin_winit::{self, DisplayBuilder, GlWindow};
-use raw_window_handle::HasRawWindowHandle;
+use raw_window_handle::HasWindowHandle;
 use winit::dpi::PhysicalSize;
 use winit::event::{ElementState, Event, WindowEvent};
 use winit::event_loop::{EventLoopBuilder, EventLoopProxy};
@@ -177,7 +177,9 @@ fn create_window_with_render_context(
 
     println!("Picked a config with {} samples", gl_config.num_samples());
 
-    let raw_window_handle = window.as_ref().map(|window| window.raw_window_handle());
+    let raw_window_handle = window
+        .as_ref()
+        .and_then(|window| window.window_handle().map(|handle| handle.as_raw()).ok());
 
     let window = window.take().unwrap();
 
@@ -191,7 +193,9 @@ fn create_window_with_render_context(
             .expect("failed to create context")
     };
 
-    let attrs = window.build_surface_attributes(<_>::default());
+    let attrs = window
+        .build_surface_attributes(<_>::default())
+        .expect("Failed to build surface attributes");
     let gl_surface =
         unsafe { gl_config.display().create_window_surface(&gl_config, &attrs).unwrap() };
 
diff --git a/glutin_examples/src/lib.rs b/glutin_examples/src/lib.rs
index 1c1c0bd7e0..62360fc45c 100644
--- a/glutin_examples/src/lib.rs
+++ b/glutin_examples/src/lib.rs
@@ -4,7 +4,7 @@ use std::num::NonZeroU32;
 use std::ops::Deref;
 
 use gl::types::GLfloat;
-use raw_window_handle::HasRawWindowHandle;
+use raw_window_handle::HasWindowHandle;
 use winit::event::{Event, KeyEvent, WindowEvent};
 use winit::keyboard::{Key, NamedKey};
 use winit::window::WindowBuilder;
@@ -53,7 +53,10 @@ pub fn main(event_loop: winit::event_loop::EventLoop<()>) -> Result<(), Box<dyn
 
     println!("Picked a config with {} samples", gl_config.num_samples());
 
-    let raw_window_handle = window.as_ref().map(|window| window.raw_window_handle());
+    let raw_window_handle = window
+        .as_ref()
+        .and_then(|window| window.window_handle().ok())
+        .map(|handle| handle.as_raw());
 
     // XXX The display could be obtained from any object created by it, so we can
     // query it from the config.
@@ -102,7 +105,9 @@ pub fn main(event_loop: winit::event_loop::EventLoop<()>) -> Result<(), Box<dyn
                         .unwrap()
                 });
 
-                let attrs = window.build_surface_attributes(Default::default());
+                let attrs = window
+                    .build_surface_attributes(Default::default())
+                    .expect("Failed to build surface attributes");
                 let gl_surface = unsafe {
                     gl_config.display().create_window_surface(&gl_config, &attrs).unwrap()
                 };