diff --git a/glutin/src/api/egl/config.rs b/glutin/src/api/egl/config.rs
index 0c9c2da5e0..d136d93547 100644
--- a/glutin/src/api/egl/config.rs
+++ b/glutin/src/api/egl/config.rs
@@ -5,9 +5,7 @@ use std::ops::Deref;
 use std::sync::Arc;
 use std::{fmt, mem};
 
-use raw_window_handle::{
-    HasDisplayHandle, HasRawDisplayHandle, HasRawWindowHandle, HasWindowHandle, RawWindowHandle,
-};
+use raw_window_handle::{HasDisplayHandle, HasRawWindowHandle, HasWindowHandle, RawWindowHandle};
 
 use glutin_egl_sys::egl;
 use glutin_egl_sys::egl::types::{EGLConfig, EGLint};
@@ -186,7 +184,7 @@ impl<D: HasDisplayHandle> Display<D> {
         }
 
         let raw_handle =
-            template.native_window.map(|w| w.window_handle()?.raw_window_handle()).transpose()?;
+            template._native_window.map(|w| w.window_handle()?.raw_window_handle()).transpose()?;
         let configs = found_configs
             .into_iter()
             .map(move |raw| {
@@ -352,7 +350,7 @@ impl<D: HasDisplayHandle> GlConfig for Config<D> {
 
     #[cfg(any(wayland_platform, x11_platform))]
     fn supports_transparency(&self) -> Option<bool> {
-        use raw_window_handle::RawDisplayHandle;
+        use raw_window_handle::{HasRawDisplayHandle, RawDisplayHandle};
         match self
             .inner
             .display
@@ -411,6 +409,7 @@ impl<D: HasDisplayHandle> AsRawConfig for Config<D> {
 #[cfg(x11_platform)]
 impl<D: HasDisplayHandle> X11GlConfigExt for Config<D> {
     fn x11_visual(&self) -> Option<X11VisualInfo> {
+        use raw_window_handle::HasRawDisplayHandle;
         match self
             .inner
             .display
diff --git a/glutin/src/api/egl/display.rs b/glutin/src/api/egl/display.rs
index b044fc5a60..69835561ee 100644
--- a/glutin/src/api/egl/display.rs
+++ b/glutin/src/api/egl/display.rs
@@ -16,7 +16,9 @@ use raw_window_handle::{HasDisplayHandle, HasRawDisplayHandle, HasWindowHandle,
 
 use crate::config::ConfigTemplate;
 use crate::context::Version;
-use crate::display::{AsRawDisplay, DisplayFeatures, GetDisplayExtensions, RawDisplay};
+use crate::display::{
+    AsRawDisplay, DisplayFeatures, DisplayResult, GetDisplayExtensions, RawDisplay,
+};
 use crate::error::{ErrorKind, Result};
 use crate::prelude::*;
 use crate::private::Sealed;
@@ -55,32 +57,39 @@ impl<D: HasDisplayHandle> Display<D> {
     /// `EGL_DEFAULT_DISPLAY`, which is not recommended or will
     /// work on a platform with a concept of native display, like Wayland.
     pub fn new(raw_display: D) -> Result<Self> {
+        Self::new_with_display(raw_display).map_err(Into::into)
+    }
+
+    pub(crate) fn new_with_display(raw_display: D) -> DisplayResult<Self, D> {
         let egl = match EGL.as_ref() {
             Some(egl) => egl,
-            None => return Err(ErrorKind::NotFound.into()),
+            None => return Err((ErrorKind::NotFound, raw_display).into()),
         };
 
         NO_DISPLAY_EXTENSIONS.get_or_init(|| get_extensions(egl, egl::NO_DISPLAY));
 
         // Create a EGL display by chaining all display creation functions aborting on
         // `EGL_BAD_ATTRIBUTE`.
-        let display = Self::get_platform_display(egl, raw_display)
+        let display = match Self::get_platform_display(egl, &raw_display)
             .or_else(|err| {
                 if err.error_kind() == ErrorKind::BadAttribute {
                     Err(err)
                 } else {
-                    Self::get_platform_display_ext(egl, raw_display)
+                    Self::get_platform_display_ext(egl, &raw_display)
                 }
             })
             .or_else(|err| {
                 if err.error_kind() == ErrorKind::BadAttribute {
                     Err(err)
                 } else {
-                    Self::get_display(egl, raw_display)
+                    Self::get_display(egl, &raw_display)
                 }
-            })?;
+            }) {
+            Ok(display) => display,
+            Err(err) => return Err((err, raw_display).into()),
+        };
 
-        Self::initialize_display(egl, display, Some(raw_display))
+        Self::initialize_display(egl, display, Some(raw_display)).map_err(|e| e.unwrap())
     }
 
     /// Create an EGL display using the specified device.
@@ -145,7 +154,7 @@ impl<D: HasDisplayHandle> Display<D> {
         })
         .map(EglDisplay::Ext)?;
 
-        Self::initialize_display(egl, display, None)
+        Self::initialize_display(egl, display, None).map_err(Into::into)
     }
 
     /// Get the [`Device`] the display is using.
@@ -188,7 +197,7 @@ impl<D: HasDisplayHandle> Display<D> {
         Device::from_ptr(self.inner.egl, device)
     }
 
-    fn get_platform_display(egl: &Egl, display: D) -> Result<EglDisplay> {
+    fn get_platform_display(egl: &Egl, display: &D) -> Result<EglDisplay> {
         if !egl.GetPlatformDisplay.is_loaded() {
             return Err(ErrorKind::NotSupported("eglGetPlatformDisplay is not supported").into());
         }
@@ -236,7 +245,7 @@ impl<D: HasDisplayHandle> Display<D> {
         Self::check_display_error(display).map(EglDisplay::Khr)
     }
 
-    fn get_platform_display_ext(egl: &Egl, display: D) -> Result<EglDisplay> {
+    fn get_platform_display_ext(egl: &Egl, display: &D) -> Result<EglDisplay> {
         if !egl.GetPlatformDisplayEXT.is_loaded() {
             return Err(ErrorKind::NotSupported("eglGetPlatformDisplayEXT is not supported").into());
         }
@@ -306,7 +315,7 @@ impl<D: HasDisplayHandle> Display<D> {
         })
     }
 
-    fn get_display(egl: &Egl, display: D) -> Result<EglDisplay> {
+    fn get_display(egl: &Egl, display: &D) -> Result<EglDisplay> {
         let mut display = match display.display_handle()?.raw_display_handle()? {
             RawDisplayHandle::Gbm(handle) => handle.gbm_device,
             #[cfg(x11_platform)]
@@ -374,11 +383,15 @@ impl<D: HasDisplayHandle> Display<D> {
         egl: &'static Egl,
         display: EglDisplay,
         handle: Option<D>,
-    ) -> Result<Self> {
+    ) -> DisplayResult<Self, Option<D>> {
         let version = unsafe {
             let (mut major, mut minor) = (0, 0);
             if egl.Initialize(*display, &mut major, &mut minor) == egl::FALSE {
-                return Err(super::check_error().expect_err("eglInit failed without a reason"));
+                return Err((
+                    super::check_error().expect_err("eglInit failed without a reason"),
+                    handle,
+                )
+                    .into());
             }
 
             Version::new(major as u8, minor as u8)
diff --git a/glutin/src/api/glx/config.rs b/glutin/src/api/glx/config.rs
index f682ce47d7..091ff7edfc 100644
--- a/glutin/src/api/glx/config.rs
+++ b/glutin/src/api/glx/config.rs
@@ -97,7 +97,7 @@ impl<D: HasDisplayHandle> Display<D> {
 
         // Add visual if was provided.
         if let Some(RawWindowHandle::Xlib(window)) =
-            template.native_window.map(|w| w.window_handle()?.raw_window_handle()).transpose()?
+            template._native_window.map(|w| w.window_handle()?.raw_window_handle()).transpose()?
         {
             if window.visual_id > 0 {
                 config_attributes.push(glx::VISUAL_ID as c_int);
diff --git a/glutin/src/api/glx/display.rs b/glutin/src/api/glx/display.rs
index 543716335d..6afb1a6900 100644
--- a/glutin/src/api/glx/display.rs
+++ b/glutin/src/api/glx/display.rs
@@ -13,7 +13,9 @@ use raw_window_handle::{HasDisplayHandle, HasRawDisplayHandle, HasWindowHandle,
 
 use crate::config::ConfigTemplate;
 use crate::context::Version;
-use crate::display::{AsRawDisplay, DisplayFeatures, GetDisplayExtensions, RawDisplay};
+use crate::display::{
+    AsRawDisplay, DisplayFeatures, DisplayResult, GetDisplayExtensions, RawDisplay,
+};
 use crate::error::{ErrorKind, Result};
 use crate::prelude::*;
 use crate::private::Sealed;
@@ -39,25 +41,36 @@ impl<D> Clone for Display<D> {
 impl<D: HasDisplayHandle> Display<D> {
     /// Create GLX display.
     pub fn new(display_handle: D, error_hook_registrar: XlibErrorHookRegistrar) -> Result<Self> {
+        Self::new_with_display(display_handle, error_hook_registrar).map_err(Into::into)
+    }
+
+    pub(crate) fn new_with_display(
+        display_handle: D,
+        error_hook_registrar: XlibErrorHookRegistrar,
+    ) -> DisplayResult<Self, D> {
         // Don't load GLX when unsupported platform was requested.
-        let (display, screen) = match display_handle.display_handle()?.raw_display_handle()? {
-            RawDisplayHandle::Xlib(handle) => {
-                if handle.display.is_null() {
-                    return Err(ErrorKind::BadDisplay.into());
-                }
-
-                (GlxDisplay(handle.display as *mut _), handle.screen as i32)
-            },
-            _ => {
-                return Err(
-                    ErrorKind::NotSupported("provided native display isn't supported").into()
-                )
-            },
-        };
+        let (display, screen) =
+            match display_handle.display_handle().and_then(|w| w.raw_display_handle()) {
+                Ok(RawDisplayHandle::Xlib(handle)) => {
+                    if handle.display.is_null() {
+                        return Err((ErrorKind::BadDisplay, display_handle).into());
+                    }
+
+                    (GlxDisplay(handle.display as *mut _), handle.screen as i32)
+                },
+                Ok(_) => {
+                    return Err((
+                        ErrorKind::NotSupported("provided native display isn't supported"),
+                        display_handle,
+                    )
+                        .into())
+                },
+                Err(e) => return Err((crate::error::Error::from(e), display_handle).into()),
+            };
 
         let glx = match GLX.as_ref() {
             Some(glx) => glx,
-            None => return Err(ErrorKind::NotFound.into()),
+            None => return Err((ErrorKind::NotFound, display_handle).into()),
         };
 
         // Set the base for errors coming from GLX.
@@ -66,7 +79,7 @@ impl<D: HasDisplayHandle> Display<D> {
             let mut event_base = 0;
             if glx.QueryExtension(display.0, &mut error_base, &mut event_base) == 0 {
                 // The glx extension isn't present.
-                return Err(ErrorKind::InitializationFailed.into());
+                return Err((ErrorKind::InitializationFailed, display_handle).into());
             }
             GLX_BASE_ERROR.store(error_base, Ordering::Relaxed);
         }
@@ -82,13 +95,17 @@ impl<D: HasDisplayHandle> Display<D> {
         let version = unsafe {
             let (mut major, mut minor) = (0, 0);
             if glx.QueryVersion(display.0, &mut major, &mut minor) == 0 {
-                return Err(ErrorKind::InitializationFailed.into());
+                return Err((ErrorKind::InitializationFailed, display_handle).into());
             }
             Version::new(major as u8, minor as u8)
         };
 
         if version < Version::new(1, 3) {
-            return Err(ErrorKind::NotSupported("the glx below 1.3 isn't supported").into());
+            return Err((
+                ErrorKind::NotSupported("the glx below 1.3 isn't supported"),
+                display_handle,
+            )
+                .into());
         }
 
         // Register the error handling hook.
diff --git a/glutin/src/api/wgl/config.rs b/glutin/src/api/wgl/config.rs
index ad5fabbe8d..e65e187a2d 100644
--- a/glutin/src/api/wgl/config.rs
+++ b/glutin/src/api/wgl/config.rs
@@ -7,7 +7,7 @@ use std::sync::Arc;
 use std::{fmt, iter};
 
 use glutin_wgl_sys::wgl_extra;
-use raw_window_handle::RawWindowHandle;
+use raw_window_handle::{HasDisplayHandle, HasRawWindowHandle, HasWindowHandle, RawWindowHandle};
 use windows_sys::Win32::Graphics::Gdi::{self as gdi, HDC};
 use windows_sys::Win32::Graphics::OpenGL::{self as gl, PIXELFORMATDESCRIPTOR};
 
@@ -27,12 +27,17 @@ const MAX_QUERY_CONFIGS: usize = 256;
 const SRGB_ARB: &str = "WGL_ARB_framebuffer_sRGB";
 const SRGB_EXT: &str = "WGL_EXT_framebuffer_sRGB";
 
-impl Display {
-    pub(crate) unsafe fn find_configs(
+impl<D: HasDisplayHandle> Display<D> {
+    pub(crate) fn find_configs<W: HasWindowHandle>(
         &self,
-        template: ConfigTemplate,
-    ) -> Result<Box<dyn Iterator<Item = Config> + '_>> {
-        let hwnd = match template.native_window {
+        template: ConfigTemplate<W>,
+    ) -> Result<Box<dyn Iterator<Item = Config<D>> + '_>> {
+        let hwnd = match template
+            ._native_window
+            .as_ref()
+            .map(|w| w.window_handle()?.raw_window_handle())
+            .transpose()?
+        {
             Some(RawWindowHandle::Win32(window_handle)) => window_handle.hwnd as _,
             _ => 0,
         };
@@ -47,11 +52,11 @@ impl Display {
         }
     }
 
-    fn find_normal_configs(
+    fn find_normal_configs<W: HasWindowHandle>(
         &self,
-        template: ConfigTemplate,
+        template: ConfigTemplate<W>,
         hdc: HDC,
-    ) -> Result<Box<dyn Iterator<Item = Config> + '_>> {
+    ) -> Result<Box<dyn Iterator<Item = Config<D>> + '_>> {
         let (r_size, g_size, b_size) = match template.color_buffer_type {
             ColorBufferType::Rgb { r_size, g_size, b_size } => (r_size, g_size, b_size),
             _ => {
@@ -152,11 +157,11 @@ impl Display {
         }
     }
 
-    fn find_configs_arb(
+    fn find_configs_arb<W: HasWindowHandle>(
         &self,
-        template: ConfigTemplate,
+        template: ConfigTemplate<W>,
         hdc: HDC,
-    ) -> Result<Box<dyn Iterator<Item = Config> + '_>> {
+    ) -> Result<Box<dyn Iterator<Item = Config<D>> + '_>> {
         let wgl_extra = self.inner.wgl_extra.unwrap();
         let mut attrs = Vec::<c_int>::with_capacity(32);
 
@@ -276,19 +281,33 @@ impl Display {
 }
 
 /// A wrapper around `PIXELFORMAT`.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct Config {
-    pub(crate) inner: Arc<ConfigInner>,
+#[derive(Debug)]
+pub struct Config<D> {
+    pub(crate) inner: Arc<ConfigInner<D>>,
 }
 
-impl Config {
+impl<D> Clone for Config<D> {
+    fn clone(&self) -> Self {
+        Self { inner: self.inner.clone() }
+    }
+}
+
+impl<D> PartialEq for Config<D> {
+    fn eq(&self, other: &Self) -> bool {
+        self.inner == other.inner
+    }
+}
+
+impl<D> Eq for Config<D> {}
+
+impl<D: HasDisplayHandle> Config<D> {
     /// Set the pixel format on the native window.
     ///
     /// # Safety
     ///
     /// 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 {
+    pub fn apply_on_native_window(&self, raw_window_handle: impl HasWindowHandle) -> Result<()> {
+        let hdc = match raw_window_handle.window_handle()?.raw_window_handle()? {
             RawWindowHandle::Win32(window) => unsafe { gdi::GetDC(window.hwnd as _) },
             _ => return Err(ErrorKind::BadNativeWindow.into()),
         };
@@ -332,7 +351,7 @@ impl Config {
     }
 }
 
-impl GlConfig for Config {
+impl<D: HasDisplayHandle> GlConfig for Config<D> {
     fn color_buffer_type(&self) -> Option<ColorBufferType> {
         let (r_size, g_size, b_size) = match self.inner.descriptor.as_ref() {
             Some(descriptor) => (descriptor.cRedBits, descriptor.cGreenBits, descriptor.cBlueBits),
@@ -452,38 +471,38 @@ impl GlConfig for Config {
     }
 }
 
-impl GetGlDisplay for Config {
-    type Target = Display;
+impl<D: HasDisplayHandle> GetGlDisplay for Config<D> {
+    type Target = Display<D>;
 
     fn display(&self) -> Self::Target {
         self.inner.display.clone()
     }
 }
 
-impl AsRawConfig for Config {
+impl<D: HasDisplayHandle> AsRawConfig for Config<D> {
     fn raw_config(&self) -> RawConfig {
         RawConfig::Wgl(self.inner.pixel_format_index)
     }
 }
 
-impl Sealed for Config {}
+impl<D: HasDisplayHandle> Sealed for Config<D> {}
 
-pub(crate) struct ConfigInner {
-    pub(crate) display: Display,
+pub(crate) struct ConfigInner<D> {
+    pub(crate) display: Display<D>,
     pub(crate) hdc: HDC,
     pub(crate) pixel_format_index: i32,
     pub(crate) descriptor: Option<PIXELFORMATDESCRIPTOR>,
 }
 
-impl PartialEq for ConfigInner {
+impl<D> PartialEq for ConfigInner<D> {
     fn eq(&self, other: &Self) -> bool {
         self.pixel_format_index == other.pixel_format_index
     }
 }
 
-impl Eq for ConfigInner {}
+impl<D> Eq for ConfigInner<D> {}
 
-impl fmt::Debug for ConfigInner {
+impl<D> fmt::Debug for ConfigInner<D> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("Config")
             .field("hdc", &self.hdc)
diff --git a/glutin/src/api/wgl/context.rs b/glutin/src/api/wgl/context.rs
index dca9294a0b..8e218e1960 100644
--- a/glutin/src/api/wgl/context.rs
+++ b/glutin/src/api/wgl/context.rs
@@ -8,7 +8,7 @@ use std::os::raw::c_int;
 
 use glutin_wgl_sys::wgl::types::HGLRC;
 use glutin_wgl_sys::{wgl, wgl_extra};
-use raw_window_handle::RawWindowHandle;
+use raw_window_handle::{HasDisplayHandle, HasRawWindowHandle, HasWindowHandle, RawWindowHandle};
 use windows_sys::Win32::Graphics::Gdi::{self as gdi, HDC};
 
 use crate::config::GetGlConfig;
@@ -26,21 +26,26 @@ use super::config::Config;
 use super::display::Display;
 use super::surface::Surface;
 
-impl Display {
-    pub(crate) unsafe fn create_context(
+impl<D: HasDisplayHandle> Display<D> {
+    pub(crate) fn create_context<W: HasWindowHandle>(
         &self,
-        config: &Config,
-        context_attributes: &ContextAttributes,
-    ) -> Result<NotCurrentContext> {
-        let hdc = match context_attributes.raw_window_handle.as_ref() {
-            handle @ Some(RawWindowHandle::Win32(window)) => unsafe {
-                let _ = config.apply_on_native_window(handle.unwrap());
+        config: &Config<D>,
+        context_attributes: &ContextAttributes<W>,
+    ) -> Result<NotCurrentContext<D>> {
+        let hdc = match context_attributes
+            ._window
+            .as_ref()
+            .map(|w| w.window_handle()?.raw_window_handle())
+            .transpose()?
+        {
+            Some(RawWindowHandle::Win32(window)) => unsafe {
+                let _ = config.apply_on_native_window(context_attributes._window.as_ref().unwrap());
                 gdi::GetDC(window.hwnd as _)
             },
             _ => config.inner.hdc,
         };
 
-        let share_ctx = match context_attributes.shared_context {
+        let share_ctx = match context_attributes.inner.shared_context {
             Some(RawContext::Wgl(share)) => share,
             _ => std::ptr::null(),
         };
@@ -64,16 +69,16 @@ impl Display {
         };
 
         let config = config.clone();
-        let is_gles = matches!(context_attributes.api, Some(ContextApi::Gles(_)));
+        let is_gles = matches!(context_attributes.inner.api, Some(ContextApi::Gles(_)));
         let inner = ContextInner { display: self.clone(), config, raw: context, is_gles };
         Ok(NotCurrentContext { inner })
     }
 
-    fn create_context_arb(
+    fn create_context_arb<W: HasWindowHandle>(
         &self,
         hdc: HDC,
         share_context: HGLRC,
-        context_attributes: &ContextAttributes,
+        context_attributes: &ContextAttributes<W>,
     ) -> Result<WglContext> {
         let extra = self.inner.wgl_extra.as_ref().unwrap();
         let mut attrs = Vec::<c_int>::with_capacity(16);
@@ -81,10 +86,11 @@ impl Display {
         // Check whether the ES context creation is supported.
         let supports_es = self.inner.features.contains(DisplayFeatures::CREATE_ES_CONTEXT);
 
-        let (profile, version) = match context_attributes.api {
+        let (profile, version) = match context_attributes.inner.api {
             api @ Some(ContextApi::OpenGl(_)) | api @ None => {
                 let version = api.and_then(|api| api.version());
-                let (profile, version) = context::pick_profile(context_attributes.profile, version);
+                let (profile, version) =
+                    context::pick_profile(context_attributes.inner.profile, version);
                 let profile = match profile {
                     GlProfile::Core => wgl_extra::CONTEXT_CORE_PROFILE_BIT_ARB,
                     GlProfile::Compatibility => wgl_extra::CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB,
@@ -118,7 +124,7 @@ impl Display {
             attrs.push(version.minor as c_int);
         }
 
-        if let Some(profile) = context_attributes.profile {
+        if let Some(profile) = context_attributes.inner.profile {
             let profile = match profile {
                 GlProfile::Core => wgl_extra::CONTEXT_CORE_PROFILE_BIT_ARB,
                 GlProfile::Compatibility => wgl_extra::CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB,
@@ -130,7 +136,7 @@ impl Display {
 
         let mut flags: c_int = 0;
         if self.inner.features.contains(DisplayFeatures::CONTEXT_ROBUSTNESS) {
-            match context_attributes.robustness {
+            match context_attributes.inner.robustness {
                 Robustness::NotRobust => (),
                 Robustness::RobustNoResetNotification => {
                     attrs.push(wgl_extra::CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB as c_int);
@@ -153,7 +159,7 @@ impl Display {
                     attrs.push(wgl_extra::CONTEXT_OPENGL_NO_ERROR_ARB as c_int);
                 },
             }
-        } else if context_attributes.robustness != Robustness::NotRobust {
+        } else if context_attributes.inner.robustness != Robustness::NotRobust {
             return Err(ErrorKind::NotSupported(
                 "WGL_ARB_create_context_robustness is not supported",
             )
@@ -161,7 +167,7 @@ impl Display {
         }
 
         // Debug flag.
-        if context_attributes.debug {
+        if context_attributes.inner.debug {
             flags |= wgl_extra::CONTEXT_DEBUG_BIT_ARB as c_int;
         }
 
@@ -172,7 +178,7 @@ impl Display {
 
         // Flush control.
         if self.inner.features.contains(DisplayFeatures::CONTEXT_RELEASE_BEHAVIOR) {
-            match context_attributes.release_behavior {
+            match context_attributes.inner.release_behavior {
                 // This is the default behavior in specification.
                 //
                 // XXX even though we check for extensions don't pass it because it could cause
@@ -183,7 +189,7 @@ impl Display {
                     attrs.push(wgl_extra::CONTEXT_RELEASE_BEHAVIOR_NONE_ARB as c_int);
                 },
             }
-        } else if context_attributes.release_behavior != ReleaseBehavior::Flush {
+        } else if context_attributes.inner.release_behavior != ReleaseBehavior::Flush {
             return Err(ErrorKind::NotSupported(
                 "flush control behavior WGL_ARB_context_flush_control",
             )
@@ -207,23 +213,23 @@ impl Display {
 /// A wrapper around the WGL context that is known to be not current to the
 /// calling thread.
 #[derive(Debug)]
-pub struct NotCurrentContext {
-    inner: ContextInner,
+pub struct NotCurrentContext<D> {
+    inner: ContextInner<D>,
 }
 
-impl Sealed for NotCurrentContext {}
+impl<D: HasDisplayHandle> Sealed for NotCurrentContext<D> {}
 
-impl NotCurrentContext {
-    fn new(inner: ContextInner) -> Self {
+impl<D> NotCurrentContext<D> {
+    fn new(inner: ContextInner<D>) -> Self {
         Self { inner }
     }
 }
 
-impl NotCurrentGlContext for NotCurrentContext {
-    type PossiblyCurrentContext = PossiblyCurrentContext;
-    type Surface<T: SurfaceTypeTrait> = Surface<T>;
+impl<D: HasDisplayHandle> NotCurrentGlContext for NotCurrentContext<D> {
+    type PossiblyCurrentContext = PossiblyCurrentContext<D>;
+    type Surface<T: SurfaceTypeTrait> = Surface<D, T>;
 
-    fn treat_as_possibly_current(self) -> PossiblyCurrentContext {
+    fn treat_as_possibly_current(self) -> PossiblyCurrentContext<D> {
         PossiblyCurrentContext { inner: self.inner, _nosendsync: PhantomData }
     }
 
@@ -244,29 +250,29 @@ impl NotCurrentGlContext for NotCurrentContext {
     }
 }
 
-impl GlContext for NotCurrentContext {
+impl<D: HasDisplayHandle> GlContext for NotCurrentContext<D> {
     fn context_api(&self) -> ContextApi {
         self.inner.context_api()
     }
 }
 
-impl GetGlDisplay for NotCurrentContext {
-    type Target = Display;
+impl<D: HasDisplayHandle> GetGlDisplay for NotCurrentContext<D> {
+    type Target = Display<D>;
 
     fn display(&self) -> Self::Target {
         self.inner.display.clone()
     }
 }
 
-impl GetGlConfig for NotCurrentContext {
-    type Target = Config;
+impl<D: HasDisplayHandle> GetGlConfig for NotCurrentContext<D> {
+    type Target = Config<D>;
 
     fn config(&self) -> Self::Target {
         self.inner.config.clone()
     }
 }
 
-impl AsRawContext for NotCurrentContext {
+impl<D: HasDisplayHandle> AsRawContext for NotCurrentContext<D> {
     fn raw_context(&self) -> RawContext {
         RawContext::Wgl(*self.inner.raw)
     }
@@ -274,15 +280,15 @@ impl AsRawContext for NotCurrentContext {
 
 /// A wrapper around WGL context that could be current to the calling thread.
 #[derive(Debug)]
-pub struct PossiblyCurrentContext {
-    inner: ContextInner,
+pub struct PossiblyCurrentContext<D> {
+    inner: ContextInner<D>,
     // The context could be current only on the one thread.
     _nosendsync: PhantomData<HGLRC>,
 }
 
-impl PossiblyCurrentGlContext for PossiblyCurrentContext {
-    type NotCurrentContext = NotCurrentContext;
-    type Surface<T: SurfaceTypeTrait> = Surface<T>;
+impl<D: HasDisplayHandle> PossiblyCurrentGlContext for PossiblyCurrentContext<D> {
+    type NotCurrentContext = NotCurrentContext<D>;
+    type Surface<T: SurfaceTypeTrait> = Surface<D, T>;
 
     fn make_not_current(self) -> Result<Self::NotCurrentContext> {
         unsafe {
@@ -314,44 +320,44 @@ impl PossiblyCurrentGlContext for PossiblyCurrentContext {
     }
 }
 
-impl Sealed for PossiblyCurrentContext {}
+impl<D: HasDisplayHandle> Sealed for PossiblyCurrentContext<D> {}
 
-impl GetGlDisplay for PossiblyCurrentContext {
-    type Target = Display;
+impl<D: HasDisplayHandle> GetGlDisplay for PossiblyCurrentContext<D> {
+    type Target = Display<D>;
 
     fn display(&self) -> Self::Target {
         self.inner.display.clone()
     }
 }
 
-impl GetGlConfig for PossiblyCurrentContext {
-    type Target = Config;
+impl<D: HasDisplayHandle> GetGlConfig for PossiblyCurrentContext<D> {
+    type Target = Config<D>;
 
     fn config(&self) -> Self::Target {
         self.inner.config.clone()
     }
 }
 
-impl GlContext for PossiblyCurrentContext {
+impl<D: HasDisplayHandle> GlContext for PossiblyCurrentContext<D> {
     fn context_api(&self) -> ContextApi {
         self.inner.context_api()
     }
 }
 
-impl AsRawContext for PossiblyCurrentContext {
+impl<D: HasDisplayHandle> AsRawContext for PossiblyCurrentContext<D> {
     fn raw_context(&self) -> RawContext {
         RawContext::Wgl(*self.inner.raw)
     }
 }
 
-struct ContextInner {
-    display: Display,
-    config: Config,
+struct ContextInner<D> {
+    display: Display<D>,
+    config: Config<D>,
     raw: WglContext,
     is_gles: bool,
 }
 
-impl fmt::Debug for ContextInner {
+impl<D> fmt::Debug for ContextInner<D> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("Context")
             .field("config", &self.config.inner.pixel_format_index)
@@ -373,16 +379,16 @@ impl Deref for WglContext {
 
 unsafe impl Send for WglContext {}
 
-impl ContextInner {
+impl<D: HasDisplayHandle> ContextInner<D> {
     fn make_current_draw_read<T: SurfaceTypeTrait>(
         &self,
-        _surface_draw: &Surface<T>,
-        _surface_read: &Surface<T>,
+        _surface_draw: &Surface<D, T>,
+        _surface_read: &Surface<D, T>,
     ) -> ErrorKind {
         ErrorKind::NotSupported("make_current_draw_read is not supported by WGL")
     }
 
-    fn make_current<T: SurfaceTypeTrait>(&self, surface: &Surface<T>) -> Result<()> {
+    fn make_current<T: SurfaceTypeTrait>(&self, surface: &Surface<D, T>) -> Result<()> {
         unsafe {
             if wgl::MakeCurrent(surface.hdc as _, self.raw.cast()) == 0 {
                 Err(IoError::last_os_error().into())
@@ -401,7 +407,7 @@ impl ContextInner {
     }
 }
 
-impl Drop for ContextInner {
+impl<D> Drop for ContextInner<D> {
     fn drop(&mut self) {
         unsafe {
             wgl::DeleteContext(*self.raw);
diff --git a/glutin/src/api/wgl/display.rs b/glutin/src/api/wgl/display.rs
index fb19098bb9..e392ccbb53 100644
--- a/glutin/src/api/wgl/display.rs
+++ b/glutin/src/api/wgl/display.rs
@@ -7,13 +7,18 @@ use std::os::windows::ffi::OsStrExt;
 use std::sync::Arc;
 
 use glutin_wgl_sys::wgl;
-use raw_window_handle::{RawDisplayHandle, RawWindowHandle};
+use raw_window_handle::{
+    HasDisplayHandle, HasRawDisplayHandle, HasRawWindowHandle, HasWindowHandle, RawDisplayHandle,
+    RawWindowHandle,
+};
 use windows_sys::Win32::Foundation::HINSTANCE;
 use windows_sys::Win32::Graphics::Gdi::HDC;
 use windows_sys::Win32::System::LibraryLoader as dll_loader;
 
 use crate::config::ConfigTemplate;
-use crate::display::{AsRawDisplay, DisplayFeatures, GetDisplayExtensions, RawDisplay};
+use crate::display::{
+    AsRawDisplay, DisplayFeatures, DisplayResult, GetDisplayExtensions, RawDisplay,
+};
 use crate::error::{ErrorKind, Result};
 use crate::prelude::*;
 use crate::private::Sealed;
@@ -25,52 +30,86 @@ use super::surface::Surface;
 use super::WglExtra;
 
 /// A WGL display.
-#[derive(Debug, Clone)]
-pub struct Display {
-    pub(crate) inner: Arc<DisplayInner>,
+#[derive(Debug)]
+pub struct Display<D> {
+    pub(crate) inner: Arc<DisplayInner<D>>,
 }
 
-impl Display {
+impl<D> Clone for Display<D> {
+    fn clone(&self) -> Self {
+        Self { inner: self.inner.clone() }
+    }
+}
+
+impl<D: HasDisplayHandle> Display<D> {
     /// Create WGL display.
     ///
     /// The `native_window` is used to perform extension loading. If it's not
     /// passed the OpenGL will be limited to what it can do, though, basic
     /// operations could still be performed.
-    ///
-    /// # Safety
-    ///
-    /// The `native_window` must point to the valid platform window and have
-    /// valid `hinstance`.
-    pub unsafe fn new(
-        display: RawDisplayHandle,
-        native_window: Option<RawWindowHandle>,
-    ) -> Result<Self> {
-        if !matches!(display, RawDisplayHandle::Windows(..)) {
-            return Err(ErrorKind::NotSupported("provided native display is not supported").into());
+    pub fn new<W: HasWindowHandle>(display: D, native_window: Option<W>) -> Result<Self> {
+        Self::new_with_display(display, native_window).map_err(Into::into)
+    }
+
+    pub(crate) fn new_with_display<W: HasWindowHandle>(
+        display: D,
+        native_window: Option<W>,
+    ) -> DisplayResult<Self, D> {
+        macro_rules! leap {
+            ($res:expr) => {{
+                match ($res) {
+                    Ok(x) => x,
+                    Err(e) => {
+                        let error = crate::error::Error::from(e);
+                        return Err((error, display).into());
+                    },
+                }
+            }};
         }
 
+        match leap!(display.display_handle().and_then(|r| r.raw_display_handle())) {
+            RawDisplayHandle::Windows(..) => {},
+            _ => {
+                return Err((
+                    ErrorKind::NotSupported("provided native display is not supported"),
+                    display,
+                )
+                    .into())
+            },
+        };
+
         let name =
             OsStr::new("opengl32.dll").encode_wide().chain(Some(0).into_iter()).collect::<Vec<_>>();
         let lib_opengl32 = unsafe { dll_loader::LoadLibraryW(name.as_ptr()) };
         if lib_opengl32 == 0 {
-            return Err(ErrorKind::NotFound.into());
+            return Err((ErrorKind::NotFound, display).into());
         }
 
         // In case native window was provided init extra functions.
-        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 _)?;
-                    (Some(wgl_extra), client_extensions)
-                }
-            } else {
-                (None, HashSet::new())
-            };
+        let (wgl_extra, client_extensions) = match leap!(native_window
+            .map(|w| w.window_handle()?.raw_window_handle())
+            .transpose())
+        {
+            Some(RawWindowHandle::Win32(window)) => unsafe {
+                let (wgl_extra, client_extensions) =
+                    match super::load_extra_functions(window.hinstance as _, window.hwnd as _) {
+                        Ok(x) => x,
+                        Err(e) => return Err((e, display).into()),
+                    };
+                (Some(wgl_extra), client_extensions)
+            },
+            _ => (None, HashSet::new()),
+        };
 
         let features = Self::extract_display_features(&client_extensions);
 
-        let inner = Arc::new(DisplayInner { lib_opengl32, wgl_extra, features, client_extensions });
+        let inner = Arc::new(DisplayInner {
+            lib_opengl32,
+            wgl_extra,
+            features,
+            client_extensions,
+            _display: display,
+        });
 
         Ok(Display { inner })
     }
@@ -122,48 +161,48 @@ impl Display {
     }
 }
 
-impl GlDisplay for Display {
-    type Config = Config;
-    type NotCurrentContext = NotCurrentContext;
-    type PbufferSurface = Surface<PbufferSurface>;
-    type PixmapSurface = Surface<PixmapSurface>;
-    type WindowSurface = Surface<WindowSurface>;
+impl<D: HasDisplayHandle> GlDisplay for Display<D> {
+    type Config = Config<D>;
+    type NotCurrentContext = NotCurrentContext<D>;
+    type PbufferSurface = Surface<D, PbufferSurface>;
+    type PixmapSurface = Surface<D, PixmapSurface>;
+    type WindowSurface<W: HasWindowHandle> = Surface<D, WindowSurface<W>>;
 
-    unsafe fn find_configs(
+    fn find_configs<W: HasWindowHandle>(
         &self,
-        template: ConfigTemplate,
+        template: ConfigTemplate<W>,
     ) -> Result<Box<dyn Iterator<Item = Self::Config> + '_>> {
-        unsafe { Self::find_configs(self, template) }
+        Self::find_configs(self, template)
     }
 
-    unsafe fn create_window_surface(
+    fn create_window_surface<W: HasWindowHandle>(
         &self,
         config: &Self::Config,
-        surface_attributes: &SurfaceAttributes<WindowSurface>,
-    ) -> Result<Self::WindowSurface> {
-        unsafe { Self::create_window_surface(self, config, surface_attributes) }
+        surface_attributes: SurfaceAttributes<WindowSurface<W>>,
+    ) -> Result<Self::WindowSurface<W>> {
+        Self::create_window_surface(self, config, surface_attributes)
     }
 
     unsafe fn create_pbuffer_surface(
         &self,
         config: &Self::Config,
-        surface_attributes: &SurfaceAttributes<PbufferSurface>,
+        surface_attributes: SurfaceAttributes<PbufferSurface>,
     ) -> Result<Self::PbufferSurface> {
         unsafe { Self::create_pbuffer_surface(self, config, surface_attributes) }
     }
 
-    unsafe fn create_context(
+    fn create_context<W: HasWindowHandle>(
         &self,
         config: &Self::Config,
-        context_attributes: &crate::context::ContextAttributes,
+        context_attributes: &crate::context::ContextAttributes<W>,
     ) -> Result<Self::NotCurrentContext> {
-        unsafe { Self::create_context(self, config, context_attributes) }
+        Self::create_context(self, config, context_attributes)
     }
 
     unsafe fn create_pixmap_surface(
         &self,
         config: &Self::Config,
-        surface_attributes: &SurfaceAttributes<PixmapSurface>,
+        surface_attributes: SurfaceAttributes<PixmapSurface>,
     ) -> Result<Self::PixmapSurface> {
         unsafe { Self::create_pixmap_surface(self, config, surface_attributes) }
     }
@@ -190,21 +229,21 @@ impl GlDisplay for Display {
     }
 }
 
-impl GetDisplayExtensions for Display {
+impl<D: HasDisplayHandle> GetDisplayExtensions for Display<D> {
     fn extensions(&self) -> &HashSet<&'static str> {
         &self.inner.client_extensions
     }
 }
 
-impl AsRawDisplay for Display {
+impl<D: HasDisplayHandle> AsRawDisplay for Display<D> {
     fn raw_display(&self) -> RawDisplay {
         RawDisplay::Wgl
     }
 }
 
-impl Sealed for Display {}
+impl<D: HasDisplayHandle> Sealed for Display<D> {}
 
-pub(crate) struct DisplayInner {
+pub(crate) struct DisplayInner<D> {
     /// Client WGL extensions.
     pub(crate) lib_opengl32: HINSTANCE,
 
@@ -214,9 +253,12 @@ pub(crate) struct DisplayInner {
     pub(crate) features: DisplayFeatures,
 
     pub(crate) client_extensions: HashSet<&'static str>,
+
+    /// Hold onto the display reference to keep it valid.
+    pub(crate) _display: D,
 }
 
-impl fmt::Debug for DisplayInner {
+impl<D> fmt::Debug for DisplayInner<D> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("Display")
             .field("features", &self.features)
diff --git a/glutin/src/api/wgl/surface.rs b/glutin/src/api/wgl/surface.rs
index fb3c204666..776d0c3536 100644
--- a/glutin/src/api/wgl/surface.rs
+++ b/glutin/src/api/wgl/surface.rs
@@ -1,11 +1,10 @@
 //! A wrapper around `HWND` used for GL operations.
 
 use std::io::Error as IoError;
-use std::marker::PhantomData;
 use std::num::NonZeroU32;
 use std::{fmt, mem};
 
-use raw_window_handle::RawWindowHandle;
+use raw_window_handle::{HasDisplayHandle, HasRawWindowHandle, HasWindowHandle, RawWindowHandle};
 use windows_sys::Win32::Foundation::{HWND, RECT};
 use windows_sys::Win32::Graphics::Gdi::HDC;
 use windows_sys::Win32::Graphics::{Gdi as gdi, OpenGL as gl};
@@ -25,35 +24,35 @@ use super::config::Config;
 use super::context::PossiblyCurrentContext;
 use super::display::Display;
 
-impl Display {
+impl<D: HasDisplayHandle> Display<D> {
     pub(crate) unsafe fn create_pixmap_surface(
         &self,
-        _config: &Config,
-        _surface_attributes: &SurfaceAttributes<PixmapSurface>,
-    ) -> Result<Surface<PixmapSurface>> {
+        _config: &Config<D>,
+        _surface_attributes: SurfaceAttributes<PixmapSurface>,
+    ) -> Result<Surface<D, PixmapSurface>> {
         Err(ErrorKind::NotSupported("pixmaps are not implemented with WGL").into())
     }
 
     pub(crate) unsafe fn create_pbuffer_surface(
         &self,
-        _config: &Config,
-        _surface_attributes: &SurfaceAttributes<PbufferSurface>,
-    ) -> Result<Surface<PbufferSurface>> {
+        _config: &Config<D>,
+        _surface_attributes: SurfaceAttributes<PbufferSurface>,
+    ) -> Result<Surface<D, PbufferSurface>> {
         Err(ErrorKind::NotSupported("pbuffers are not implemented with WGL").into())
     }
 
-    pub(crate) unsafe fn create_window_surface(
+    pub(crate) fn create_window_surface<W: HasWindowHandle>(
         &self,
-        config: &Config,
-        surface_attributes: &SurfaceAttributes<WindowSurface>,
-    ) -> Result<Surface<WindowSurface>> {
-        let hwnd = match surface_attributes.raw_window_handle.as_ref().unwrap() {
-            handle @ RawWindowHandle::Win32(window_handle) => {
+        config: &Config<D>,
+        surface_attributes: SurfaceAttributes<WindowSurface<W>>,
+    ) -> Result<Surface<D, WindowSurface<W>>> {
+        let hwnd = match surface_attributes.ty.0.window_handle()?.raw_window_handle()? {
+            RawWindowHandle::Win32(window_handle) => {
                 if window_handle.hwnd.is_null() {
                     return Err(ErrorKind::BadNativeWindow.into());
                 }
 
-                let _ = unsafe { config.apply_on_native_window(handle) };
+                let _ = config.apply_on_native_window(&surface_attributes.ty.0);
                 window_handle.hwnd as HWND
             },
             _ => {
@@ -65,23 +64,28 @@ impl Display {
 
         let hdc = unsafe { gdi::GetDC(hwnd) };
 
-        let surface =
-            Surface { display: self.clone(), config: config.clone(), hwnd, hdc, _ty: PhantomData };
+        let surface = Surface {
+            display: self.clone(),
+            config: config.clone(),
+            hwnd,
+            hdc,
+            _ty: surface_attributes.ty,
+        };
 
         Ok(surface)
     }
 }
 
 /// A Wrapper around `HWND`.
-pub struct Surface<T: SurfaceTypeTrait> {
-    display: Display,
-    config: Config,
+pub struct Surface<D, T: SurfaceTypeTrait> {
+    display: Display<D>,
+    config: Config<D>,
     pub(crate) hwnd: HWND,
     pub(crate) hdc: HDC,
-    _ty: PhantomData<T>,
+    _ty: T,
 }
 
-impl<T: SurfaceTypeTrait> Drop for Surface<T> {
+impl<D, T: SurfaceTypeTrait> Drop for Surface<D, T> {
     fn drop(&mut self) {
         unsafe {
             gdi::ReleaseDC(self.hwnd, self.hdc);
@@ -89,8 +93,8 @@ impl<T: SurfaceTypeTrait> Drop for Surface<T> {
     }
 }
 
-impl<T: SurfaceTypeTrait> GlSurface<T> for Surface<T> {
-    type Context = PossiblyCurrentContext;
+impl<D: HasDisplayHandle, T: SurfaceTypeTrait> GlSurface<T> for Surface<D, T> {
+    type Context = PossiblyCurrentContext<D>;
     type SurfaceType = T;
 
     fn buffer_age(&self) -> u32 {
@@ -170,7 +174,7 @@ impl<T: SurfaceTypeTrait> GlSurface<T> for Surface<T> {
     }
 }
 
-impl<T: SurfaceTypeTrait> fmt::Debug for Surface<T> {
+impl<D, T: SurfaceTypeTrait> fmt::Debug for Surface<D, T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("Surface")
             .field("config", &self.config.inner.pixel_format_index)
@@ -180,26 +184,26 @@ impl<T: SurfaceTypeTrait> fmt::Debug for Surface<T> {
     }
 }
 
-impl<T: SurfaceTypeTrait> AsRawSurface for Surface<T> {
+impl<D: HasDisplayHandle, T: SurfaceTypeTrait> AsRawSurface for Surface<D, T> {
     fn raw_surface(&self) -> RawSurface {
         RawSurface::Wgl(self.hwnd as _)
     }
 }
 
-impl<T: SurfaceTypeTrait> GetGlConfig for Surface<T> {
-    type Target = Config;
+impl<D: HasDisplayHandle, T: SurfaceTypeTrait> GetGlConfig for Surface<D, T> {
+    type Target = Config<D>;
 
     fn config(&self) -> Self::Target {
         self.config.clone()
     }
 }
 
-impl<T: SurfaceTypeTrait> GetGlDisplay for Surface<T> {
-    type Target = Display;
+impl<D: HasDisplayHandle, T: SurfaceTypeTrait> GetGlDisplay for Surface<D, T> {
+    type Target = Display<D>;
 
     fn display(&self) -> Self::Target {
         self.display.clone()
     }
 }
 
-impl<T: SurfaceTypeTrait> Sealed for Surface<T> {}
+impl<D: HasDisplayHandle, T: SurfaceTypeTrait> Sealed for Surface<D, T> {}
diff --git a/glutin/src/display.rs b/glutin/src/display.rs
index a4a2aefdd7..efc41d1974 100644
--- a/glutin/src/display.rs
+++ b/glutin/src/display.rs
@@ -203,39 +203,39 @@ impl<D: HasDisplayHandle> Display<D> {
                 Ok(Self::Glx(GlxDisplay::new(display, registrar)?))
             },
             #[cfg(all(egl_backend, glx_backend))]
-            DisplayApiPreference::GlxThenEgl(registrar) => unsafe {
-                if let Ok(display) = GlxDisplay::new(display, registrar) {
-                    Ok(Self::Glx(display))
-                } else {
-                    Ok(Self::Egl(EglDisplay::new(display)?))
+            DisplayApiPreference::GlxThenEgl(registrar) => {
+                match GlxDisplay::new_with_display(display, registrar) {
+                    Ok(display) => Ok(Self::Glx(display)),
+                    Err(err) => Ok(Self::Egl(EglDisplay::new_with_display(err.display)?)),
                 }
             },
             #[cfg(all(egl_backend, glx_backend))]
-            DisplayApiPreference::EglThenGlx(registrar) => unsafe {
-                if let Ok(display) = EglDisplay::new(display) {
-                    Ok(Self::Egl(display))
-                } else {
-                    Ok(Self::Glx(GlxDisplay::new(display, registrar)?))
+            DisplayApiPreference::EglThenGlx(registrar) => {
+                match EglDisplay::new_with_display(display) {
+                    Ok(display) => Ok(Self::Egl(display)),
+                    Err(err) => {
+                        Ok(Self::Glx(GlxDisplay::new_with_display(err.display, registrar)?))
+                    },
                 }
             },
             #[cfg(wgl_backend)]
-            DisplayApiPreference::Wgl(window_handle) => unsafe {
+            DisplayApiPreference::Wgl(window_handle) => {
                 Ok(Self::Wgl(WglDisplay::new(display, window_handle)?))
             },
             #[cfg(all(egl_backend, wgl_backend))]
-            DisplayApiPreference::EglThenWgl(window_handle) => unsafe {
-                if let Ok(display) = EglDisplay::new(display) {
-                    Ok(Self::Egl(display))
-                } else {
-                    Ok(Self::Wgl(WglDisplay::new(display, window_handle)?))
+            DisplayApiPreference::EglThenWgl(window_handle) => {
+                match EglDisplay::new_with_display(display) {
+                    Ok(display) => Ok(Self::Egl(display)),
+                    Err(err) => {
+                        Ok(Self::Wgl(WglDisplay::new_with_display(err.display, window_handle)?))
+                    },
                 }
             },
             #[cfg(all(egl_backend, wgl_backend))]
-            DisplayApiPreference::WglThenEgl(window_handle) => unsafe {
-                if let Ok(display) = WglDisplay::new(display, window_handle) {
-                    Ok(Self::Wgl(display))
-                } else {
-                    Ok(Self::Egl(EglDisplay::new(display)?))
+            DisplayApiPreference::WglThenEgl(window_handle) => {
+                match WglDisplay::new_with_display(display, window_handle) {
+                    Ok(display) => Ok(Self::Wgl(display)),
+                    Err(err) => Ok(Self::Egl(EglDisplay::new_with_display(err.display)?)),
                 }
             },
             #[cfg(cgl_backend)]
@@ -262,9 +262,7 @@ impl<D: HasDisplayHandle> GlDisplay for Display<D> {
             #[cfg(glx_backend)]
             Self::Glx(display) => Ok(Box::new(display.find_configs(template)?.map(Config::Glx))),
             #[cfg(wgl_backend)]
-            Self::Wgl(display) => unsafe {
-                Ok(Box::new(display.find_configs(template)?.map(Config::Wgl)))
-            },
+            Self::Wgl(display) => Ok(Box::new(display.find_configs(template)?.map(Config::Wgl))),
             #[cfg(cgl_backend)]
             Self::Cgl(display) => Ok(Box::new(display.find_configs(template)?.map(Config::Cgl))),
         }
@@ -285,7 +283,7 @@ impl<D: HasDisplayHandle> GlDisplay for Display<D> {
                 Ok(NotCurrentContext::Glx(display.create_context(config, context_attributes)?))
             },
             #[cfg(wgl_backend)]
-            (Self::Wgl(display), Config::Wgl(config)) => unsafe {
+            (Self::Wgl(display), Config::Wgl(config)) => {
                 Ok(NotCurrentContext::Wgl(display.create_context(config, context_attributes)?))
             },
             #[cfg(cgl_backend)]
@@ -311,7 +309,7 @@ impl<D: HasDisplayHandle> GlDisplay for Display<D> {
                 Ok(Surface::Glx(display.create_window_surface(config, surface_attributes)?))
             },
             #[cfg(wgl_backend)]
-            (Self::Wgl(display), Config::Wgl(config)) => unsafe {
+            (Self::Wgl(display), Config::Wgl(config)) => {
                 Ok(Surface::Wgl(display.create_window_surface(config, surface_attributes)?))
             },
             #[cfg(cgl_backend)]
@@ -577,3 +575,40 @@ pub enum RawDisplay {
     #[cfg(cgl_backend)]
     Cgl,
 }
+
+#[cfg_attr(cgl_backend, allow(dead_code))]
+pub(crate) struct DisplayError<D> {
+    /// The error that occurred.
+    pub(crate) error: crate::error::Error,
+
+    /// The display that caused the error.
+    pub(crate) display: D,
+}
+
+impl<D> DisplayError<Option<D>> {
+    #[allow(unused)]
+    pub(crate) fn unwrap(self) -> DisplayError<D> {
+        DisplayError { error: self.error, display: self.display.unwrap() }
+    }
+}
+
+impl<D> From<DisplayError<D>> for crate::error::Error {
+    fn from(value: DisplayError<D>) -> Self {
+        value.error
+    }
+}
+
+impl<D> From<(crate::error::Error, D)> for DisplayError<D> {
+    fn from(value: (crate::error::Error, D)) -> Self {
+        Self { error: value.0, display: value.1 }
+    }
+}
+
+impl<D> From<(crate::error::ErrorKind, D)> for DisplayError<D> {
+    fn from(value: (crate::error::ErrorKind, D)) -> Self {
+        Self { error: value.0.into(), display: value.1 }
+    }
+}
+
+#[cfg_attr(cgl_backend, allow(dead_code))]
+pub(crate) type DisplayResult<T, D> = std::result::Result<T, DisplayError<D>>;
diff --git a/glutin/src/surface.rs b/glutin/src/surface.rs
index df7ee1bc04..80630a0c5d 100644
--- a/glutin/src/surface.rs
+++ b/glutin/src/surface.rs
@@ -215,7 +215,7 @@ impl SurfaceAttributesBuilder<PixmapSurface> {
 /// Attributes which are used for creating a particular surface.
 #[derive(Default, Debug, Clone)]
 pub struct SurfaceAttributes<T: SurfaceTypeTrait> {
-    #[cfg_attr(cgl_backend, allow(dead_code))]
+    #[cfg_attr(any(cgl_backend, all(wgl_backend, not(egl_backend))), allow(dead_code))]
     pub(crate) inner: AttributesInner,
     pub(crate) ty: T,
 }