diff --git a/examples/window.rs b/examples/window.rs
index b1862da43e..61bd51bd72 100644
--- a/examples/window.rs
+++ b/examples/window.rs
@@ -302,27 +302,32 @@ impl Application {
                 info!("{intro}: [no name]");
             }
 
-            let PhysicalSize { width, height } = monitor.size();
-            info!(
-                "  Current mode: {width}x{height}{}",
-                if let Some(m_hz) = monitor.refresh_rate_millihertz() {
-                    format!(" @ {}.{} Hz", m_hz / 1000, m_hz % 1000)
-                } else {
-                    String::new()
-                }
-            );
+            if let Some(current_mode) = monitor.current_video_mode() {
+                let PhysicalSize { width, height } = current_mode.size();
+                let bits =
+                    current_mode.bit_depth().map(|bits| format!("x{bits}")).unwrap_or_default();
+                let m_hz = current_mode
+                    .refresh_rate_millihertz()
+                    .map(|m_hz| format!(" @ {}.{} Hz", m_hz.get() / 1000, m_hz.get() % 1000))
+                    .unwrap_or_default();
+                info!("  {width}x{height}{bits}{m_hz}");
+            }
 
-            let PhysicalPosition { x, y } = monitor.position();
-            info!("  Position: {x},{y}");
+            if let Some(PhysicalPosition { x, y }) = monitor.position() {
+                info!("  Position: {x},{y}");
+            }
 
             info!("  Scale factor: {}", monitor.scale_factor());
 
             info!("  Available modes (width x height x bit-depth):");
             for mode in monitor.video_modes() {
                 let PhysicalSize { width, height } = mode.size();
-                let bits = mode.bit_depth();
-                let m_hz = mode.refresh_rate_millihertz();
-                info!("    {width}x{height}x{bits} @ {}.{} Hz", m_hz / 1000, m_hz % 1000);
+                let bits = mode.bit_depth().map(|bits| format!("x{bits}")).unwrap_or_default();
+                let m_hz = mode
+                    .refresh_rate_millihertz()
+                    .map(|m_hz| format!(" @ {}.{} Hz", m_hz.get() / 1000, m_hz.get() % 1000))
+                    .unwrap_or_default();
+                info!("    {width}x{height}{bits}{m_hz}");
             }
         }
     }
diff --git a/src/changelog/unreleased.md b/src/changelog/unreleased.md
index 0ffccfb9b7..6fce8a2f95 100644
--- a/src/changelog/unreleased.md
+++ b/src/changelog/unreleased.md
@@ -61,6 +61,7 @@ changelog entry.
   the primary finger in a multi-touch interaction.
 - Implement `Clone`, `Copy`, `Debug`, `Deserialize`, `Eq`, `Hash`, `Ord`, `PartialEq`, `PartialOrd`
   and `Serialize` on many types.
+- Add `MonitorHandle::current_video_mode()`.
 
 ### Changed
 
@@ -94,6 +95,8 @@ changelog entry.
   accelerated, if the browser supports it.
 - `(Active)EventLoop::create_custom_cursor()` now returns a `Result<CustomCursor, ExternalError>`.
 - Changed how `ModifiersState` is serialized by Serde.
+- `VideoModeHandle::refresh_rate_millihertz()` and `bit_depth()` now return a `Option<NonZero*>`.
+- `MonitorHandle::position()` now returns an `Option`.
 
 ### Removed
 
@@ -117,9 +120,13 @@ changelog entry.
 - Remove `DeviceEvent::Added` and `DeviceEvent::Removed`.
 - Remove `DeviceEvent::Motion` and `WindowEvent::AxisMotion`.
 - Remove `Touch::id` in favor of `Touch::finger_id`.
+- Remove `MonitorHandle::size()` and `refresh_rate_millihertz()` in favor of
+  `MonitorHandle::current_video_mode()`.
+- On Android, remove all `MonitorHandle` support instead of emitting false data.
 
 ### Fixed
 
 - On Web, pen events are now routed through to `WindowEvent::Cursor*`.
 - On macOS, fix panic when releasing not available monitor.
 - On MacOS, return the system theme in `Window::theme()` if no theme override is set.
+- On Orbital, `MonitorHandle::name()` now returns `None` instead of a dummy name.
diff --git a/src/monitor.rs b/src/monitor.rs
index f25eb79efd..b774314dda 100644
--- a/src/monitor.rs
+++ b/src/monitor.rs
@@ -5,6 +5,8 @@
 //! methods, which return an iterator of [`MonitorHandle`]:
 //! - [`ActiveEventLoop::available_monitors`][crate::event_loop::ActiveEventLoop::available_monitors].
 //! - [`Window::available_monitors`][crate::window::Window::available_monitors].
+use std::num::{NonZeroU16, NonZeroU32};
+
 use crate::dpi::{PhysicalPosition, PhysicalSize};
 use crate::platform_impl;
 
@@ -44,7 +46,10 @@ impl Ord for VideoModeHandle {
 }
 
 impl VideoModeHandle {
-    /// Returns the resolution of this video mode.
+    /// Returns the resolution of this video mode. This **must not** be used to create your
+    /// rendering surface. Use [`Window::inner_size()`] instead.
+    ///
+    /// [`Window::inner_size()`]: crate::window::Window::inner_size
     #[inline]
     pub fn size(&self) -> PhysicalSize<u32> {
         self.video_mode.size()
@@ -53,23 +58,14 @@ impl VideoModeHandle {
     /// Returns the bit depth of this video mode, as in how many bits you have
     /// available per color. This is generally 24 bits or 32 bits on modern
     /// systems, depending on whether the alpha channel is counted or not.
-    ///
-    /// ## Platform-specific
-    ///
-    /// - **Wayland / Orbital:** Always returns 32.
-    /// - **iOS:** Always returns 32.
     #[inline]
-    pub fn bit_depth(&self) -> u16 {
+    pub fn bit_depth(&self) -> Option<NonZeroU16> {
         self.video_mode.bit_depth()
     }
 
     /// Returns the refresh rate of this video mode in mHz.
-    ///
-    /// ## Platform-specific
-    ///
-    /// **Web:** Always returns `0`.
     #[inline]
-    pub fn refresh_rate_millihertz(&self) -> u32 {
+    pub fn refresh_rate_millihertz(&self) -> Option<NonZeroU32> {
         self.video_mode.refresh_rate_millihertz()
     }
 
@@ -85,11 +81,11 @@ impl std::fmt::Display for VideoModeHandle {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(
             f,
-            "{}x{} @ {} mHz ({} bpp)",
+            "{}x{} {}{}",
             self.size().width,
             self.size().height,
-            self.refresh_rate_millihertz(),
-            self.bit_depth()
+            self.refresh_rate_millihertz().map(|rate| format!("@ {rate} mHz ")).unwrap_or_default(),
+            self.bit_depth().map(|bit_depth| format!("({bit_depth} bpp)")).unwrap_or_default(),
         )
     }
 }
@@ -116,11 +112,17 @@ impl std::fmt::Display for VideoModeHandle {
 /// to check.
 ///
 /// [`Window`]: crate::window::Window
-#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
 pub struct MonitorHandle {
     pub(crate) inner: platform_impl::MonitorHandle,
 }
 
+impl std::fmt::Debug for MonitorHandle {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.inner.fmt(f)
+    }
+}
+
 impl MonitorHandle {
     /// Returns a human-readable name of the monitor.
     ///
@@ -139,44 +141,22 @@ impl MonitorHandle {
         self.inner.name()
     }
 
-    /// Returns the monitor's resolution.
-    #[inline]
-    pub fn size(&self) -> PhysicalSize<u32> {
-        self.inner.size()
-    }
-
     /// Returns the top-left corner position of the monitor relative to the larger full
     /// screen area.
     ///
     /// ## Platform-specific
     ///
-    /// **Web:** Always returns [`Default`] without
+    /// **Web:** Always returns [`None`] without
     #[cfg_attr(
         any(web_platform, docsrs),
         doc = "[detailed monitor permissions][crate::platform::web::ActiveEventLoopExtWeb::request_detailed_monitor_permission]."
     )]
     #[cfg_attr(not(any(web_platform, docsrs)), doc = "detailed monitor permissions.")]
     #[inline]
-    pub fn position(&self) -> PhysicalPosition<i32> {
+    pub fn position(&self) -> Option<PhysicalPosition<i32>> {
         self.inner.position()
     }
 
-    /// The monitor refresh rate used by the system.
-    ///
-    /// Return `Some` if succeed, or `None` if failed, which usually happens when the monitor
-    /// the window is on is removed.
-    ///
-    /// When using exclusive fullscreen, the refresh rate of the [`VideoModeHandle`] that was
-    /// used to enter fullscreen should be used instead.
-    ///
-    /// ## Platform-specific
-    ///
-    /// **Web:** Always returns [`None`].
-    #[inline]
-    pub fn refresh_rate_millihertz(&self) -> Option<u32> {
-        self.inner.refresh_rate_millihertz()
-    }
-
     /// Returns the scale factor of the underlying monitor. To map logical pixels to physical
     /// pixels and vice versa, use [`Window::scale_factor`].
     ///
@@ -201,6 +181,12 @@ impl MonitorHandle {
         self.inner.scale_factor()
     }
 
+    /// Returns the currently active video mode of this monitor.
+    #[inline]
+    pub fn current_video_mode(&self) -> Option<VideoModeHandle> {
+        self.inner.current_video_mode().map(|video_mode| VideoModeHandle { video_mode })
+    }
+
     /// Returns all fullscreen video modes supported by this monitor.
     #[inline]
     pub fn video_modes(&self) -> impl Iterator<Item = VideoModeHandle> {
diff --git a/src/platform_impl/android/mod.rs b/src/platform_impl/android/mod.rs
index 527f2f053f..6690f38a56 100644
--- a/src/platform_impl/android/mod.rs
+++ b/src/platform_impl/android/mod.rs
@@ -1,7 +1,7 @@
 use std::any::Any;
 use std::cell::Cell;
-use std::collections::VecDeque;
 use std::hash::Hash;
+use std::num::{NonZeroU16, NonZeroU32};
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Mutex};
 use std::time::{Duration, Instant};
@@ -200,13 +200,10 @@ impl EventLoop {
                     app.window_event(&self.window_target, window_id, event);
                 },
                 MainEvent::ConfigChanged { .. } => {
-                    let monitor = MonitorHandle::new(self.android_app.clone());
-                    let old_scale_factor = monitor.scale_factor();
-                    let scale_factor = monitor.scale_factor();
+                    let old_scale_factor = scale_factor(&self.android_app);
+                    let scale_factor = scale_factor(&self.android_app);
                     if (scale_factor - old_scale_factor).abs() < f64::EPSILON {
-                        let new_inner_size = Arc::new(Mutex::new(
-                            MonitorHandle::new(self.android_app.clone()).size(),
-                        ));
+                        let new_inner_size = Arc::new(Mutex::new(screen_size(&self.android_app)));
                         let window_id = window::WindowId(WindowId);
                         let event = event::WindowEvent::ScaleFactorChanged {
                             inner_size_writer: InnerSizeWriter::new(Arc::downgrade(
@@ -610,12 +607,11 @@ impl RootActiveEventLoop for ActiveEventLoop {
     }
 
     fn available_monitors(&self) -> Box<dyn Iterator<Item = RootMonitorHandle>> {
-        let handle = RootMonitorHandle { inner: MonitorHandle::new(self.app.clone()) };
-        Box::new(vec![handle].into_iter())
+        Box::new(std::iter::empty())
     }
 
     fn primary_monitor(&self) -> Option<RootMonitorHandle> {
-        Some(RootMonitorHandle { inner: MonitorHandle::new(self.app.clone()) })
+        None
     }
 
     fn system_theme(&self) -> Option<Theme> {
@@ -745,21 +741,19 @@ impl Window {
     }
 
     pub fn primary_monitor(&self) -> Option<MonitorHandle> {
-        Some(MonitorHandle::new(self.app.clone()))
+        None
     }
 
-    pub fn available_monitors(&self) -> VecDeque<MonitorHandle> {
-        let mut v = VecDeque::with_capacity(1);
-        v.push_back(MonitorHandle::new(self.app.clone()));
-        v
+    pub fn available_monitors(&self) -> Option<MonitorHandle> {
+        None
     }
 
     pub fn current_monitor(&self) -> Option<MonitorHandle> {
-        Some(MonitorHandle::new(self.app.clone()))
+        None
     }
 
     pub fn scale_factor(&self) -> f64 {
-        MonitorHandle::new(self.app.clone()).scale_factor()
+        scale_factor(&self.app)
     }
 
     pub fn request_redraw(&self) {
@@ -789,7 +783,7 @@ impl Window {
     }
 
     pub fn outer_size(&self) -> PhysicalSize<u32> {
-        MonitorHandle::new(self.app.clone()).size()
+        screen_size(&self.app)
     }
 
     pub fn set_min_inner_size(&self, _: Option<Size>) {}
@@ -958,86 +952,60 @@ impl Display for OsError {
     }
 }
 
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
-pub struct MonitorHandle {
-    app: AndroidApp,
-}
-impl PartialOrd for MonitorHandle {
-    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
-        Some(self.cmp(other))
-    }
-}
-impl Ord for MonitorHandle {
-    fn cmp(&self, _other: &Self) -> std::cmp::Ordering {
-        std::cmp::Ordering::Equal
-    }
-}
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct MonitorHandle;
 
 impl MonitorHandle {
-    pub(crate) fn new(app: AndroidApp) -> Self {
-        Self { app }
-    }
-
     pub fn name(&self) -> Option<String> {
-        Some("Android Device".to_owned())
+        unreachable!()
     }
 
-    pub fn size(&self) -> PhysicalSize<u32> {
-        if let Some(native_window) = self.app.native_window() {
-            PhysicalSize::new(native_window.width() as _, native_window.height() as _)
-        } else {
-            PhysicalSize::new(0, 0)
-        }
-    }
-
-    pub fn position(&self) -> PhysicalPosition<i32> {
-        (0, 0).into()
+    pub fn position(&self) -> Option<PhysicalPosition<i32>> {
+        unreachable!()
     }
 
     pub fn scale_factor(&self) -> f64 {
-        self.app.config().density().map(|dpi| dpi as f64 / 160.0).unwrap_or(1.0)
+        unreachable!()
     }
 
-    pub fn refresh_rate_millihertz(&self) -> Option<u32> {
-        // FIXME no way to get real refresh rate for now.
-        None
+    pub fn current_video_mode(&self) -> Option<VideoModeHandle> {
+        unreachable!()
     }
 
-    pub fn video_modes(&self) -> impl Iterator<Item = VideoModeHandle> {
-        let size = self.size().into();
-        // FIXME this is not the real refresh rate
-        // (it is guaranteed to support 32 bit color though)
-        std::iter::once(VideoModeHandle {
-            size,
-            bit_depth: 32,
-            refresh_rate_millihertz: 60000,
-            monitor: self.clone(),
-        })
+    pub fn video_modes(&self) -> std::iter::Empty<VideoModeHandle> {
+        unreachable!()
     }
 }
 
 #[derive(Clone, Debug, Eq, Hash, PartialEq)]
-pub struct VideoModeHandle {
-    size: (u32, u32),
-    bit_depth: u16,
-    refresh_rate_millihertz: u32,
-    monitor: MonitorHandle,
-}
+pub struct VideoModeHandle;
 
 impl VideoModeHandle {
     pub fn size(&self) -> PhysicalSize<u32> {
-        self.size.into()
+        unreachable!()
     }
 
-    pub fn bit_depth(&self) -> u16 {
-        self.bit_depth
+    pub fn bit_depth(&self) -> Option<NonZeroU16> {
+        unreachable!()
     }
 
-    pub fn refresh_rate_millihertz(&self) -> u32 {
-        self.refresh_rate_millihertz
+    pub fn refresh_rate_millihertz(&self) -> Option<NonZeroU32> {
+        unreachable!()
     }
 
     pub fn monitor(&self) -> MonitorHandle {
-        self.monitor.clone()
+        unreachable!()
+    }
+}
+
+fn screen_size(app: &AndroidApp) -> PhysicalSize<u32> {
+    if let Some(native_window) = app.native_window() {
+        PhysicalSize::new(native_window.width() as _, native_window.height() as _)
+    } else {
+        PhysicalSize::new(0, 0)
     }
 }
+
+fn scale_factor(app: &AndroidApp) -> f64 {
+    app.config().density().map(|dpi| dpi as f64 / 160.0).unwrap_or(1.0)
+}
diff --git a/src/platform_impl/apple/appkit/monitor.rs b/src/platform_impl/apple/appkit/monitor.rs
index e78d84f0be..8917c36a07 100644
--- a/src/platform_impl/apple/appkit/monitor.rs
+++ b/src/platform_impl/apple/appkit/monitor.rs
@@ -2,6 +2,7 @@
 
 use std::collections::VecDeque;
 use std::fmt;
+use std::num::{NonZeroU16, NonZeroU32};
 
 use core_foundation::array::{CFArrayGetCount, CFArrayGetValueAtIndex};
 use core_foundation::base::{CFRelease, TCFType};
@@ -20,8 +21,8 @@ use crate::dpi::{LogicalPosition, PhysicalPosition, PhysicalSize};
 #[derive(Clone)]
 pub struct VideoModeHandle {
     size: PhysicalSize<u32>,
-    bit_depth: u16,
-    refresh_rate_millihertz: u32,
+    bit_depth: Option<NonZeroU16>,
+    refresh_rate_millihertz: Option<NonZeroU32>,
     pub(crate) monitor: MonitorHandle,
     pub(crate) native_mode: NativeDisplayMode,
 }
@@ -80,15 +81,47 @@ impl Clone for NativeDisplayMode {
 }
 
 impl VideoModeHandle {
+    fn new(
+        monitor: MonitorHandle,
+        mode: NativeDisplayMode,
+        refresh_rate_millihertz: Option<NonZeroU32>,
+    ) -> Self {
+        unsafe {
+            let pixel_encoding =
+                CFString::wrap_under_create_rule(ffi::CGDisplayModeCopyPixelEncoding(mode.0))
+                    .to_string();
+            let bit_depth = if pixel_encoding.eq_ignore_ascii_case(ffi::IO32BitDirectPixels) {
+                32
+            } else if pixel_encoding.eq_ignore_ascii_case(ffi::IO16BitDirectPixels) {
+                16
+            } else if pixel_encoding.eq_ignore_ascii_case(ffi::kIO30BitDirectPixels) {
+                30
+            } else {
+                unimplemented!()
+            };
+
+            VideoModeHandle {
+                size: PhysicalSize::new(
+                    ffi::CGDisplayModeGetPixelWidth(mode.0) as u32,
+                    ffi::CGDisplayModeGetPixelHeight(mode.0) as u32,
+                ),
+                refresh_rate_millihertz,
+                bit_depth: NonZeroU16::new(bit_depth),
+                monitor: monitor.clone(),
+                native_mode: mode,
+            }
+        }
+    }
+
     pub fn size(&self) -> PhysicalSize<u32> {
         self.size
     }
 
-    pub fn bit_depth(&self) -> u16 {
+    pub fn bit_depth(&self) -> Option<NonZeroU16> {
         self.bit_depth
     }
 
-    pub fn refresh_rate_millihertz(&self) -> u32 {
+    pub fn refresh_rate_millihertz(&self) -> Option<NonZeroU32> {
         self.refresh_rate_millihertz
     }
 
@@ -158,10 +191,8 @@ impl fmt::Debug for MonitorHandle {
         f.debug_struct("MonitorHandle")
             .field("name", &self.name())
             .field("native_identifier", &self.native_identifier())
-            .field("size", &self.size())
             .field("position", &self.position())
             .field("scale_factor", &self.scale_factor())
-            .field("refresh_rate_millihertz", &self.refresh_rate_millihertz())
             .finish_non_exhaustive()
     }
 }
@@ -184,22 +215,14 @@ impl MonitorHandle {
         self.0
     }
 
-    pub fn size(&self) -> PhysicalSize<u32> {
-        let MonitorHandle(display_id) = *self;
-        let display = CGDisplay::new(display_id);
-        let height = display.pixels_high();
-        let width = display.pixels_wide();
-        PhysicalSize::from_logical::<_, f64>((width as f64, height as f64), self.scale_factor())
-    }
-
     #[inline]
-    pub fn position(&self) -> PhysicalPosition<i32> {
+    pub fn position(&self) -> Option<PhysicalPosition<i32>> {
         // This is already in screen coordinates. If we were using `NSScreen`,
         // then a conversion would've been needed:
         // flip_window_screen_coordinates(self.ns_screen(mtm)?.frame())
         let bounds = unsafe { CGDisplayBounds(self.native_identifier()) };
         let position = LogicalPosition::new(bounds.origin.x, bounds.origin.y);
-        position.to_physical(self.scale_factor())
+        Some(position.to_physical(self.scale_factor()))
     }
 
     pub fn scale_factor(&self) -> f64 {
@@ -211,34 +234,20 @@ impl MonitorHandle {
         })
     }
 
-    pub fn refresh_rate_millihertz(&self) -> Option<u32> {
-        unsafe {
-            let current_display_mode = NativeDisplayMode(CGDisplayCopyDisplayMode(self.0) as _);
-            let refresh_rate = ffi::CGDisplayModeGetRefreshRate(current_display_mode.0);
-            if refresh_rate > 0.0 {
-                return Some((refresh_rate * 1000.0).round() as u32);
-            }
-
-            let mut display_link = std::ptr::null_mut();
-            if ffi::CVDisplayLinkCreateWithCGDisplay(self.0, &mut display_link)
-                != ffi::kCVReturnSuccess
-            {
-                return None;
-            }
-            let time = ffi::CVDisplayLinkGetNominalOutputVideoRefreshPeriod(display_link);
-            ffi::CVDisplayLinkRelease(display_link);
-
-            // This value is indefinite if an invalid display link was specified
-            if time.flags & ffi::kCVTimeIsIndefinite != 0 {
-                return None;
-            }
+    fn refresh_rate_millihertz(&self) -> Option<NonZeroU32> {
+        let current_display_mode =
+            NativeDisplayMode(unsafe { CGDisplayCopyDisplayMode(self.0) } as _);
+        refresh_rate_millihertz(self.0, &current_display_mode)
+    }
 
-            (time.time_scale as i64).checked_div(time.time_value).map(|v| (v * 1000) as u32)
-        }
+    pub fn current_video_mode(&self) -> Option<VideoModeHandle> {
+        let mode = NativeDisplayMode(unsafe { CGDisplayCopyDisplayMode(self.0) } as _);
+        let refresh_rate_millihertz = refresh_rate_millihertz(self.0, &mode);
+        Some(VideoModeHandle::new(self.clone(), mode, refresh_rate_millihertz))
     }
 
     pub fn video_modes(&self) -> impl Iterator<Item = VideoModeHandle> {
-        let refresh_rate_millihertz = self.refresh_rate_millihertz().unwrap_or(0);
+        let refresh_rate_millihertz = self.refresh_rate_millihertz();
         let monitor = self.clone();
 
         unsafe {
@@ -263,34 +272,16 @@ impl MonitorHandle {
                 // CGDisplayModeGetRefreshRate returns 0.0 for any display that
                 // isn't a CRT
                 let refresh_rate_millihertz = if cg_refresh_rate_hertz > 0 {
-                    (cg_refresh_rate_hertz * 1000) as u32
+                    NonZeroU32::new((cg_refresh_rate_hertz * 1000) as u32)
                 } else {
                     refresh_rate_millihertz
                 };
 
-                let pixel_encoding =
-                    CFString::wrap_under_create_rule(ffi::CGDisplayModeCopyPixelEncoding(mode))
-                        .to_string();
-                let bit_depth = if pixel_encoding.eq_ignore_ascii_case(ffi::IO32BitDirectPixels) {
-                    32
-                } else if pixel_encoding.eq_ignore_ascii_case(ffi::IO16BitDirectPixels) {
-                    16
-                } else if pixel_encoding.eq_ignore_ascii_case(ffi::kIO30BitDirectPixels) {
-                    30
-                } else {
-                    unimplemented!()
-                };
-
-                VideoModeHandle {
-                    size: PhysicalSize::new(
-                        ffi::CGDisplayModeGetPixelWidth(mode) as u32,
-                        ffi::CGDisplayModeGetPixelHeight(mode) as u32,
-                    ),
+                VideoModeHandle::new(
+                    monitor.clone(),
+                    NativeDisplayMode(mode),
                     refresh_rate_millihertz,
-                    bit_depth,
-                    monitor: monitor.clone(),
-                    native_mode: NativeDisplayMode(mode),
-                }
+                )
             })
         }
     }
@@ -349,3 +340,29 @@ pub(crate) fn flip_window_screen_coordinates(frame: NSRect) -> NSPoint {
     let y = main_screen_height - frame.size.height - frame.origin.y;
     NSPoint::new(frame.origin.x, y)
 }
+
+fn refresh_rate_millihertz(id: CGDirectDisplayID, mode: &NativeDisplayMode) -> Option<NonZeroU32> {
+    unsafe {
+        let refresh_rate = ffi::CGDisplayModeGetRefreshRate(mode.0);
+        if refresh_rate > 0.0 {
+            return NonZeroU32::new((refresh_rate * 1000.0).round() as u32);
+        }
+
+        let mut display_link = std::ptr::null_mut();
+        if ffi::CVDisplayLinkCreateWithCGDisplay(id, &mut display_link) != ffi::kCVReturnSuccess {
+            return None;
+        }
+        let time = ffi::CVDisplayLinkGetNominalOutputVideoRefreshPeriod(display_link);
+        ffi::CVDisplayLinkRelease(display_link);
+
+        // This value is indefinite if an invalid display link was specified
+        if time.flags & ffi::kCVTimeIsIndefinite != 0 {
+            return None;
+        }
+
+        (time.time_scale as i64)
+            .checked_div(time.time_value)
+            .map(|v| (v * 1000) as u32)
+            .and_then(NonZeroU32::new)
+    }
+}
diff --git a/src/platform_impl/apple/uikit/monitor.rs b/src/platform_impl/apple/uikit/monitor.rs
index 1871ffb19a..b87d5a26ce 100644
--- a/src/platform_impl/apple/uikit/monitor.rs
+++ b/src/platform_impl/apple/uikit/monitor.rs
@@ -1,6 +1,7 @@
 #![allow(clippy::unnecessary_cast)]
 
 use std::collections::{BTreeSet, VecDeque};
+use std::num::{NonZeroU16, NonZeroU32};
 use std::{fmt, hash, ptr};
 
 use objc2::mutability::IsRetainable;
@@ -44,8 +45,7 @@ impl<T: IsRetainable + Message> Eq for MainThreadBoundDelegateImpls<T> {}
 #[derive(Debug, PartialEq, Eq, Hash, Clone)]
 pub struct VideoModeHandle {
     pub(crate) size: (u32, u32),
-    pub(crate) bit_depth: u16,
-    pub(crate) refresh_rate_millihertz: u32,
+    pub(crate) refresh_rate_millihertz: Option<NonZeroU32>,
     screen_mode: MainThreadBoundDelegateImpls<UIScreenMode>,
     pub(crate) monitor: MonitorHandle,
 }
@@ -60,7 +60,6 @@ impl VideoModeHandle {
         let size = screen_mode.size();
         VideoModeHandle {
             size: (size.width as u32, size.height as u32),
-            bit_depth: 32,
             refresh_rate_millihertz,
             screen_mode: MainThreadBoundDelegateImpls(MainThreadBound::new(screen_mode, mtm)),
             monitor: MonitorHandle::new(uiscreen),
@@ -71,11 +70,11 @@ impl VideoModeHandle {
         self.size.into()
     }
 
-    pub fn bit_depth(&self) -> u16 {
-        self.bit_depth
+    pub fn bit_depth(&self) -> Option<NonZeroU16> {
+        None
     }
 
-    pub fn refresh_rate_millihertz(&self) -> u32 {
+    pub fn refresh_rate_millihertz(&self) -> Option<NonZeroU32> {
         self.refresh_rate_millihertz
     }
 
@@ -131,10 +130,8 @@ impl fmt::Debug for MonitorHandle {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("MonitorHandle")
             .field("name", &self.name())
-            .field("size", &self.size())
             .field("position", &self.position())
             .field("scale_factor", &self.scale_factor())
-            .field("refresh_rate_millihertz", &self.refresh_rate_millihertz())
             .finish_non_exhaustive()
     }
 }
@@ -164,22 +161,23 @@ impl MonitorHandle {
         })
     }
 
-    pub fn size(&self) -> PhysicalSize<u32> {
-        let bounds = self.ui_screen.get_on_main(|ui_screen| ui_screen.nativeBounds());
-        PhysicalSize::new(bounds.size.width as u32, bounds.size.height as u32)
-    }
-
-    pub fn position(&self) -> PhysicalPosition<i32> {
+    pub fn position(&self) -> Option<PhysicalPosition<i32>> {
         let bounds = self.ui_screen.get_on_main(|ui_screen| ui_screen.nativeBounds());
-        (bounds.origin.x as f64, bounds.origin.y as f64).into()
+        Some((bounds.origin.x as f64, bounds.origin.y as f64).into())
     }
 
     pub fn scale_factor(&self) -> f64 {
         self.ui_screen.get_on_main(|ui_screen| ui_screen.nativeScale()) as f64
     }
 
-    pub fn refresh_rate_millihertz(&self) -> Option<u32> {
-        Some(self.ui_screen.get_on_main(|ui_screen| refresh_rate_millihertz(ui_screen)))
+    pub fn current_video_mode(&self) -> Option<VideoModeHandle> {
+        Some(run_on_main(|mtm| {
+            VideoModeHandle::new(
+                self.ui_screen(mtm).clone(),
+                self.ui_screen(mtm).currentMode().unwrap(),
+                mtm,
+            )
+        }))
     }
 
     pub fn video_modes(&self) -> impl Iterator<Item = VideoModeHandle> {
@@ -214,7 +212,7 @@ impl MonitorHandle {
     }
 }
 
-fn refresh_rate_millihertz(uiscreen: &UIScreen) -> u32 {
+fn refresh_rate_millihertz(uiscreen: &UIScreen) -> Option<NonZeroU32> {
     let refresh_rate_millihertz: NSInteger = {
         let os_capabilities = app_state::os_capabilities();
         if os_capabilities.maximum_frames_per_second {
@@ -235,7 +233,7 @@ fn refresh_rate_millihertz(uiscreen: &UIScreen) -> u32 {
         }
     };
 
-    refresh_rate_millihertz as u32 * 1000
+    NonZeroU32::new(refresh_rate_millihertz as u32 * 1000)
 }
 
 pub fn uiscreens(mtm: MainThreadMarker) -> VecDeque<MonitorHandle> {
diff --git a/src/platform_impl/linux/mod.rs b/src/platform_impl/linux/mod.rs
index 734b328995..9fbc3e8912 100644
--- a/src/platform_impl/linux/mod.rs
+++ b/src/platform_impl/linux/mod.rs
@@ -4,6 +4,7 @@
 compile_error!("Please select a feature to build for unix: `x11`, `wayland`");
 
 use std::collections::VecDeque;
+use std::num::{NonZeroU16, NonZeroU32};
 use std::os::unix::io::{AsFd, AsRawFd, BorrowedFd, RawFd};
 use std::sync::Arc;
 use std::time::Duration;
@@ -242,23 +243,18 @@ impl MonitorHandle {
     }
 
     #[inline]
-    pub fn size(&self) -> PhysicalSize<u32> {
-        x11_or_wayland!(match self; MonitorHandle(m) => m.size())
-    }
-
-    #[inline]
-    pub fn position(&self) -> PhysicalPosition<i32> {
+    pub fn position(&self) -> Option<PhysicalPosition<i32>> {
         x11_or_wayland!(match self; MonitorHandle(m) => m.position())
     }
 
     #[inline]
-    pub fn refresh_rate_millihertz(&self) -> Option<u32> {
-        x11_or_wayland!(match self; MonitorHandle(m) => m.refresh_rate_millihertz())
+    pub fn scale_factor(&self) -> f64 {
+        x11_or_wayland!(match self; MonitorHandle(m) => m.scale_factor() as _)
     }
 
     #[inline]
-    pub fn scale_factor(&self) -> f64 {
-        x11_or_wayland!(match self; MonitorHandle(m) => m.scale_factor() as _)
+    pub fn current_video_mode(&self) -> Option<VideoModeHandle> {
+        x11_or_wayland!(match self; MonitorHandle(m) => m.current_video_mode())
     }
 
     #[inline]
@@ -282,12 +278,12 @@ impl VideoModeHandle {
     }
 
     #[inline]
-    pub fn bit_depth(&self) -> u16 {
+    pub fn bit_depth(&self) -> Option<NonZeroU16> {
         x11_or_wayland!(match self; VideoModeHandle(m) => m.bit_depth())
     }
 
     #[inline]
-    pub fn refresh_rate_millihertz(&self) -> u32 {
+    pub fn refresh_rate_millihertz(&self) -> Option<NonZeroU32> {
         x11_or_wayland!(match self; VideoModeHandle(m) => m.refresh_rate_millihertz())
     }
 
diff --git a/src/platform_impl/linux/wayland/output.rs b/src/platform_impl/linux/wayland/output.rs
index 42537ced88..ea5ba083e5 100644
--- a/src/platform_impl/linux/wayland/output.rs
+++ b/src/platform_impl/linux/wayland/output.rs
@@ -1,4 +1,6 @@
-use sctk::output::OutputData;
+use std::num::{NonZeroU16, NonZeroU32};
+
+use sctk::output::{Mode, OutputData};
 use sctk::reexports::client::protocol::wl_output::WlOutput;
 use sctk::reexports::client::Proxy;
 
@@ -29,23 +31,9 @@ impl MonitorHandle {
     }
 
     #[inline]
-    pub fn size(&self) -> PhysicalSize<u32> {
-        let output_data = self.proxy.data::<OutputData>().unwrap();
-        let dimensions = output_data.with_output_info(|info| {
-            info.modes.iter().find_map(|mode| mode.current.then_some(mode.dimensions))
-        });
-
-        match dimensions {
-            Some((width, height)) => (width as u32, height as u32),
-            _ => (0, 0),
-        }
-        .into()
-    }
-
-    #[inline]
-    pub fn position(&self) -> PhysicalPosition<i32> {
+    pub fn position(&self) -> Option<PhysicalPosition<i32>> {
         let output_data = self.proxy.data::<OutputData>().unwrap();
-        output_data.with_output_info(|info| {
+        Some(output_data.with_output_info(|info| {
             info.logical_position.map_or_else(
                 || {
                     LogicalPosition::<i32>::from(info.location)
@@ -56,21 +44,25 @@ impl MonitorHandle {
                         .to_physical(info.scale_factor as f64)
                 },
             )
-        })
+        }))
     }
 
     #[inline]
-    pub fn refresh_rate_millihertz(&self) -> Option<u32> {
+    pub fn scale_factor(&self) -> i32 {
         let output_data = self.proxy.data::<OutputData>().unwrap();
-        output_data.with_output_info(|info| {
-            info.modes.iter().find_map(|mode| mode.current.then_some(mode.refresh_rate as u32))
-        })
+        output_data.scale_factor()
     }
 
     #[inline]
-    pub fn scale_factor(&self) -> i32 {
+    pub fn current_video_mode(&self) -> Option<PlatformVideoModeHandle> {
         let output_data = self.proxy.data::<OutputData>().unwrap();
-        output_data.scale_factor()
+        output_data.with_output_info(|info| {
+            let mode = info.modes.iter().find(|mode| mode.current).cloned();
+
+            mode.map(|mode| {
+                PlatformVideoModeHandle::Wayland(VideoModeHandle::new(self.clone(), mode))
+            })
+        })
     }
 
     #[inline]
@@ -81,12 +73,7 @@ impl MonitorHandle {
         let monitor = self.clone();
 
         modes.into_iter().map(move |mode| {
-            PlatformVideoModeHandle::Wayland(VideoModeHandle {
-                size: (mode.dimensions.0 as u32, mode.dimensions.1 as u32).into(),
-                refresh_rate_millihertz: mode.refresh_rate as u32,
-                bit_depth: 32,
-                monitor: monitor.clone(),
-            })
+            PlatformVideoModeHandle::Wayland(VideoModeHandle::new(monitor.clone(), mode))
         })
     }
 }
@@ -120,24 +107,31 @@ impl std::hash::Hash for MonitorHandle {
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct VideoModeHandle {
     pub(crate) size: PhysicalSize<u32>,
-    pub(crate) bit_depth: u16,
-    pub(crate) refresh_rate_millihertz: u32,
+    pub(crate) refresh_rate_millihertz: Option<NonZeroU32>,
     pub(crate) monitor: MonitorHandle,
 }
 
 impl VideoModeHandle {
+    fn new(monitor: MonitorHandle, mode: Mode) -> Self {
+        VideoModeHandle {
+            size: (mode.dimensions.0 as u32, mode.dimensions.1 as u32).into(),
+            refresh_rate_millihertz: NonZeroU32::new(mode.refresh_rate as u32),
+            monitor: monitor.clone(),
+        }
+    }
+
     #[inline]
     pub fn size(&self) -> PhysicalSize<u32> {
         self.size
     }
 
     #[inline]
-    pub fn bit_depth(&self) -> u16 {
-        self.bit_depth
+    pub fn bit_depth(&self) -> Option<NonZeroU16> {
+        None
     }
 
     #[inline]
-    pub fn refresh_rate_millihertz(&self) -> u32 {
+    pub fn refresh_rate_millihertz(&self) -> Option<NonZeroU32> {
         self.refresh_rate_millihertz
     }
 
diff --git a/src/platform_impl/linux/x11/monitor.rs b/src/platform_impl/linux/x11/monitor.rs
index 2a26a26d90..eaf9bef37a 100644
--- a/src/platform_impl/linux/x11/monitor.rs
+++ b/src/platform_impl/linux/x11/monitor.rs
@@ -1,3 +1,5 @@
+use std::num::{NonZeroU16, NonZeroU32};
+
 use x11rb::connection::RequestConnection;
 use x11rb::protocol::randr::{self, ConnectionExt as _};
 use x11rb::protocol::xproto;
@@ -18,9 +20,10 @@ impl XConnection {
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct VideoModeHandle {
+    pub(crate) current: bool,
     pub(crate) size: (u32, u32),
-    pub(crate) bit_depth: u16,
-    pub(crate) refresh_rate_millihertz: u32,
+    pub(crate) bit_depth: Option<NonZeroU16>,
+    pub(crate) refresh_rate_millihertz: Option<NonZeroU32>,
     pub(crate) native_mode: randr::Mode,
     pub(crate) monitor: Option<MonitorHandle>,
 }
@@ -32,12 +35,12 @@ impl VideoModeHandle {
     }
 
     #[inline]
-    pub fn bit_depth(&self) -> u16 {
+    pub fn bit_depth(&self) -> Option<NonZeroU16> {
         self.bit_depth
     }
 
     #[inline]
-    pub fn refresh_rate_millihertz(&self) -> u32 {
+    pub fn refresh_rate_millihertz(&self) -> Option<NonZeroU32> {
         self.refresh_rate_millihertz
     }
 
@@ -53,14 +56,10 @@ pub struct MonitorHandle {
     pub(crate) id: randr::Crtc,
     /// The name of the monitor
     pub(crate) name: String,
-    /// The size of the monitor
-    dimensions: (u32, u32),
     /// The position of the monitor in the X screen
-    position: (i32, i32),
+    pub(crate) position: (i32, i32),
     /// If the monitor is the primary one
     primary: bool,
-    /// The refresh rate used by monitor.
-    refresh_rate_millihertz: Option<u32>,
     /// The DPI scale factor
     pub(crate) scale_factor: f64,
     /// Used to determine which windows are on this monitor
@@ -96,10 +95,12 @@ impl std::hash::Hash for MonitorHandle {
 }
 
 #[inline]
-pub fn mode_refresh_rate_millihertz(mode: &randr::ModeInfo) -> Option<u32> {
+pub fn mode_refresh_rate_millihertz(mode: &randr::ModeInfo) -> Option<NonZeroU32> {
     if mode.dot_clock > 0 && mode.htotal > 0 && mode.vtotal > 0 {
         #[allow(clippy::unnecessary_cast)]
-        Some((mode.dot_clock as u64 * 1000 / (mode.htotal as u64 * mode.vtotal as u64)) as u32)
+        NonZeroU32::new(
+            (mode.dot_clock as u64 * 1000 / (mode.htotal as u64 * mode.vtotal as u64)) as u32,
+        )
     } else {
         None
     }
@@ -117,27 +118,9 @@ impl MonitorHandle {
         let dimensions = (crtc.width as u32, crtc.height as u32);
         let position = (crtc.x as i32, crtc.y as i32);
 
-        // Get the refresh rate of the current video mode.
-        let current_mode = crtc.mode;
-        let screen_modes = resources.modes();
-        let refresh_rate_millihertz = screen_modes
-            .iter()
-            .find(|mode| mode.id == current_mode)
-            .and_then(mode_refresh_rate_millihertz);
-
         let rect = util::AaRect::new(position, dimensions);
 
-        Some(MonitorHandle {
-            id,
-            name,
-            refresh_rate_millihertz,
-            scale_factor,
-            dimensions,
-            position,
-            primary,
-            rect,
-            video_modes,
-        })
+        Some(MonitorHandle { id, name, scale_factor, position, primary, rect, video_modes })
     }
 
     pub fn dummy() -> Self {
@@ -145,9 +128,7 @@ impl MonitorHandle {
             id: 0,
             name: "<dummy monitor>".into(),
             scale_factor: 1.0,
-            dimensions: (1, 1),
             position: (0, 0),
-            refresh_rate_millihertz: None,
             primary: true,
             rect: util::AaRect::new((0, 0), (1, 1)),
             video_modes: Vec::new(),
@@ -168,16 +149,8 @@ impl MonitorHandle {
         self.id as _
     }
 
-    pub fn size(&self) -> PhysicalSize<u32> {
-        self.dimensions.into()
-    }
-
-    pub fn position(&self) -> PhysicalPosition<i32> {
-        self.position.into()
-    }
-
-    pub fn refresh_rate_millihertz(&self) -> Option<u32> {
-        self.refresh_rate_millihertz
+    pub fn position(&self) -> Option<PhysicalPosition<i32>> {
+        Some(self.position.into())
     }
 
     #[inline]
@@ -185,6 +158,11 @@ impl MonitorHandle {
         self.scale_factor
     }
 
+    #[inline]
+    pub fn current_video_mode(&self) -> Option<PlatformVideoModeHandle> {
+        self.video_modes.iter().find(|mode| mode.current).cloned().map(PlatformVideoModeHandle::X)
+    }
+
     #[inline]
     pub fn video_modes(&self) -> impl Iterator<Item = PlatformVideoModeHandle> {
         let monitor = self.clone();
diff --git a/src/platform_impl/linux/x11/util/randr.rs b/src/platform_impl/linux/x11/util/randr.rs
index 19df178a85..f90068867c 100644
--- a/src/platform_impl/linux/x11/util/randr.rs
+++ b/src/platform_impl/linux/x11/util/randr.rs
@@ -1,3 +1,4 @@
+use std::num::NonZeroU16;
 use std::str::FromStr;
 use std::{env, str};
 
@@ -74,6 +75,7 @@ impl XConnection {
         let bit_depth = self.default_root().root_depth;
         let output_modes = &output_info.modes;
         let resource_modes = resources.modes();
+        let current_mode = crtc.mode;
 
         let modes = resource_modes
             .iter()
@@ -82,10 +84,10 @@ impl XConnection {
             .filter(|x| output_modes.iter().any(|id| x.id == *id))
             .map(|mode| {
                 VideoModeHandle {
+                    current: mode.id == current_mode,
                     size: (mode.width.into(), mode.height.into()),
-                    refresh_rate_millihertz: monitor::mode_refresh_rate_millihertz(mode)
-                        .unwrap_or(0),
-                    bit_depth: bit_depth as u16,
+                    refresh_rate_millihertz: monitor::mode_refresh_rate_millihertz(mode),
+                    bit_depth: NonZeroU16::new(bit_depth as u16),
                     native_mode: mode.id,
                     // This is populated in `MonitorHandle::video_modes` as the
                     // video mode is returned to the user
diff --git a/src/platform_impl/linux/x11/window.rs b/src/platform_impl/linux/x11/window.rs
index f19fbb51a2..31f06fd5c3 100644
--- a/src/platform_impl/linux/x11/window.rs
+++ b/src/platform_impl/linux/x11/window.rs
@@ -822,7 +822,7 @@ impl UnownedWindow {
 
                 let window_position = self.outer_position_physical();
                 self.shared_state_lock().restore_position = Some(window_position);
-                let monitor_origin: (i32, i32) = monitor.position().into();
+                let monitor_origin: (i32, i32) = monitor.position;
                 self.set_position_inner(monitor_origin.0, monitor_origin.1)
                     .expect_then_ignore_error("Failed to set window position");
                 self.set_fullscreen_hint(true).map(Some)
diff --git a/src/platform_impl/orbital/mod.rs b/src/platform_impl/orbital/mod.rs
index 34a8555309..4ba0923cc6 100644
--- a/src/platform_impl/orbital/mod.rs
+++ b/src/platform_impl/orbital/mod.rs
@@ -1,6 +1,7 @@
 #![cfg(target_os = "redox")]
 
 use std::fmt::{self, Display, Formatter};
+use std::num::{NonZeroU16, NonZeroU32};
 use std::str;
 use std::sync::Arc;
 
@@ -197,58 +198,45 @@ pub struct MonitorHandle;
 
 impl MonitorHandle {
     pub fn name(&self) -> Option<String> {
-        Some("Redox Device".to_owned())
-    }
-
-    pub fn size(&self) -> PhysicalSize<u32> {
-        PhysicalSize::new(0, 0) // TODO
+        None
     }
 
-    pub fn position(&self) -> PhysicalPosition<i32> {
-        (0, 0).into()
+    pub fn position(&self) -> Option<PhysicalPosition<i32>> {
+        None
     }
 
     pub fn scale_factor(&self) -> f64 {
         1.0 // TODO
     }
 
-    pub fn refresh_rate_millihertz(&self) -> Option<u32> {
-        // FIXME no way to get real refresh rate for now.
-        None
+    pub fn current_video_mode(&self) -> Option<VideoModeHandle> {
+        // (it is guaranteed to support 32 bit color though)
+        Some(VideoModeHandle { monitor: self.clone() })
     }
 
     pub fn video_modes(&self) -> impl Iterator<Item = VideoModeHandle> {
-        let size = self.size().into();
-        // FIXME this is not the real refresh rate
-        // (it is guaranteed to support 32 bit color though)
-        std::iter::once(VideoModeHandle {
-            size,
-            bit_depth: 32,
-            refresh_rate_millihertz: 60000,
-            monitor: self.clone(),
-        })
+        self.current_video_mode().into_iter()
     }
 }
 
 #[derive(Clone, Debug, Eq, Hash, PartialEq)]
 pub struct VideoModeHandle {
-    size: (u32, u32),
-    bit_depth: u16,
-    refresh_rate_millihertz: u32,
     monitor: MonitorHandle,
 }
 
 impl VideoModeHandle {
     pub fn size(&self) -> PhysicalSize<u32> {
-        self.size.into()
+        // TODO
+        PhysicalSize::default()
     }
 
-    pub fn bit_depth(&self) -> u16 {
-        self.bit_depth
+    pub fn bit_depth(&self) -> Option<NonZeroU16> {
+        None
     }
 
-    pub fn refresh_rate_millihertz(&self) -> u32 {
-        self.refresh_rate_millihertz
+    pub fn refresh_rate_millihertz(&self) -> Option<NonZeroU32> {
+        // TODO
+        None
     }
 
     pub fn monitor(&self) -> MonitorHandle {
diff --git a/src/platform_impl/web/monitor.rs b/src/platform_impl/web/monitor.rs
index 8decd2a00a..f6b1529dd4 100644
--- a/src/platform_impl/web/monitor.rs
+++ b/src/platform_impl/web/monitor.rs
@@ -1,9 +1,11 @@
 use std::cell::{OnceCell, Ref, RefCell};
 use std::cmp::Ordering;
+use std::fmt::{self, Debug, Formatter};
 use std::future::Future;
 use std::hash::{Hash, Hasher};
 use std::iter::{self, Once};
 use std::mem;
+use std::num::{NonZeroU16, NonZeroU32};
 use std::ops::{Deref, DerefMut};
 use std::pin::Pin;
 use std::rc::{Rc, Weak};
@@ -31,7 +33,7 @@ use crate::platform::web::{
     MonitorPermissionError, Orientation, OrientationData, OrientationLock, OrientationLockError,
 };
 
-#[derive(Debug, Clone, Eq)]
+#[derive(Clone, Eq)]
 pub struct MonitorHandle {
     /// [`None`] means [`web_sys::Screen`], which is always the same.
     id: Option<u64>,
@@ -45,48 +47,19 @@ impl MonitorHandle {
     }
 
     pub fn scale_factor(&self) -> f64 {
-        self.inner.queue(|inner| match &inner.screen {
-            Screen::Screen(_) => 0.,
-            Screen::Detailed { screen, .. } => screen.device_pixel_ratio(),
-        })
+        self.inner.queue(|inner| inner.scale_factor())
     }
 
-    pub fn position(&self) -> PhysicalPosition<i32> {
-        self.inner.queue(|inner| {
-            if let Screen::Detailed { screen, .. } = &inner.screen {
-                PhysicalPosition::new(screen.left(), screen.top())
-            } else {
-                PhysicalPosition::default()
-            }
-        })
+    pub fn position(&self) -> Option<PhysicalPosition<i32>> {
+        self.inner.queue(|inner| inner.position())
     }
 
     pub fn name(&self) -> Option<String> {
-        self.inner.queue(|inner| {
-            if let Screen::Detailed { screen, .. } = &inner.screen {
-                Some(screen.label())
-            } else {
-                None
-            }
-        })
+        self.inner.queue(|inner| inner.name())
     }
 
-    pub fn refresh_rate_millihertz(&self) -> Option<u32> {
-        None
-    }
-
-    pub fn size(&self) -> PhysicalSize<u32> {
-        self.inner.queue(|inner| {
-            let width = inner.screen.width().unwrap();
-            let height = inner.screen.height().unwrap();
-
-            if let Some(Engine::Chromium) = inner.engine {
-                PhysicalSize::new(width, height).cast()
-            } else {
-                LogicalSize::new(width, height)
-                    .to_physical(super::web_sys::scale_factor(&inner.window))
-            }
-        })
+    pub fn current_video_mode(&self) -> Option<VideoModeHandle> {
+        Some(VideoModeHandle(self.clone()))
     }
 
     pub fn video_modes(&self) -> Once<VideoModeHandle> {
@@ -94,36 +67,7 @@ impl MonitorHandle {
     }
 
     pub fn orientation(&self) -> OrientationData {
-        self.inner.queue(|inner| {
-            let orientation = inner.orientation();
-            let angle = orientation.angle().unwrap();
-
-            match orientation.type_().unwrap() {
-                OrientationType::LandscapePrimary => OrientationData {
-                    orientation: Orientation::Landscape,
-                    flipped: false,
-                    natural: angle == 0,
-                },
-                OrientationType::LandscapeSecondary => OrientationData {
-                    orientation: Orientation::Landscape,
-                    flipped: true,
-                    natural: angle == 180,
-                },
-                OrientationType::PortraitPrimary => OrientationData {
-                    orientation: Orientation::Portrait,
-                    flipped: false,
-                    natural: angle == 0,
-                },
-                OrientationType::PortraitSecondary => OrientationData {
-                    orientation: Orientation::Portrait,
-                    flipped: true,
-                    natural: angle == 180,
-                },
-                _ => {
-                    unreachable!("found unrecognized orientation: {}", orientation.type_string())
-                },
-            }
-        })
+        self.inner.queue(|inner| inner.orientation())
     }
 
     pub fn request_lock(&self, orientation_lock: OrientationLock) -> OrientationLockFuture {
@@ -140,7 +84,7 @@ impl MonitorHandle {
             }
 
             let future =
-                JsFuture::from(inner.orientation().lock(orientation_lock.to_js()).unwrap());
+                JsFuture::from(inner.orientation_raw().lock(orientation_lock.to_js()).unwrap());
             let notifier = Notifier::new();
             let notified = notifier.notified();
 
@@ -165,22 +109,16 @@ impl MonitorHandle {
                 return Err(OrientationLockError::Unsupported);
             }
 
-            inner.orientation().unlock().map_err(OrientationLockError::from_js)
+            inner.orientation_raw().unlock().map_err(OrientationLockError::from_js)
         })
     }
 
     pub fn is_internal(&self) -> Option<bool> {
-        self.inner.queue(|inner| {
-            if let Screen::Detailed { screen, .. } = &inner.screen {
-                Some(screen.is_internal())
-            } else {
-                None
-            }
-        })
+        self.inner.queue(|inner| inner.is_internal())
     }
 
     pub fn is_detailed(&self) -> bool {
-        self.inner.queue(|inner| matches!(inner.screen, Screen::Detailed { .. }))
+        self.inner.queue(|inner| inner.is_detailed())
     }
 
     pub(crate) fn detailed(
@@ -201,6 +139,31 @@ impl MonitorHandle {
     }
 }
 
+impl Debug for MonitorHandle {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        let (name, position, scale_factor, orientation, is_internal, is_detailed) =
+            self.inner.queue(|this| {
+                (
+                    this.name(),
+                    this.position(),
+                    this.scale_factor(),
+                    this.orientation(),
+                    this.is_internal(),
+                    this.is_detailed(),
+                )
+            });
+
+        f.debug_struct("MonitorHandle")
+            .field("name", &name)
+            .field("position", &position)
+            .field("scale_factor", &scale_factor)
+            .field("orientation", &orientation)
+            .field("is_internal", &is_internal)
+            .field("is_detailed", &is_detailed)
+            .finish()
+    }
+}
+
 impl Hash for MonitorHandle {
     fn hash<H: Hasher>(&self, state: &mut H) {
         self.id.hash(state)
@@ -282,20 +245,20 @@ impl OrientationLockError {
     }
 }
 
-#[derive(Clone, Debug, Eq, Hash, PartialEq)]
-pub struct VideoModeHandle(pub(super) MonitorHandle);
+#[derive(Clone, Eq, Hash, PartialEq)]
+pub struct VideoModeHandle(MonitorHandle);
 
 impl VideoModeHandle {
     pub fn size(&self) -> PhysicalSize<u32> {
-        self.0.size()
+        self.0.inner.queue(|inner| inner.size())
     }
 
-    pub fn bit_depth(&self) -> u16 {
-        self.0.inner.queue(|inner| inner.screen.color_depth().unwrap()).try_into().unwrap()
+    pub fn bit_depth(&self) -> Option<NonZeroU16> {
+        self.0.inner.queue(|inner| inner.bit_depth())
     }
 
-    pub fn refresh_rate_millihertz(&self) -> u32 {
-        0
+    pub fn refresh_rate_millihertz(&self) -> Option<NonZeroU32> {
+        None
     }
 
     pub fn monitor(&self) -> MonitorHandle {
@@ -303,6 +266,14 @@ impl VideoModeHandle {
     }
 }
 
+impl Debug for VideoModeHandle {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        let (size, bit_depth) = self.0.inner.queue(|this| (this.size(), this.bit_depth()));
+
+        f.debug_struct("MonitorHandle").field("size", &size).field("bit_depth", &bit_depth).finish()
+    }
+}
+
 struct Inner {
     window: WindowExt,
     engine: Option<Engine>,
@@ -315,12 +286,94 @@ impl Inner {
         Self { window, engine, screen, orientation: OnceCell::new() }
     }
 
-    fn orientation(&self) -> &ScreenOrientationExt {
+    fn scale_factor(&self) -> f64 {
+        match &self.screen {
+            Screen::Screen(_) => 0.,
+            Screen::Detailed { screen, .. } => screen.device_pixel_ratio(),
+        }
+    }
+
+    fn position(&self) -> Option<PhysicalPosition<i32>> {
+        if let Screen::Detailed { screen, .. } = &self.screen {
+            Some(PhysicalPosition::new(screen.left(), screen.top()))
+        } else {
+            None
+        }
+    }
+
+    fn name(&self) -> Option<String> {
+        if let Screen::Detailed { screen, .. } = &self.screen {
+            Some(screen.label())
+        } else {
+            None
+        }
+    }
+
+    fn orientation_raw(&self) -> &ScreenOrientationExt {
         self.orientation.get_or_init(|| self.screen.orientation().unchecked_into())
     }
 
+    fn orientation(&self) -> OrientationData {
+        let orientation = self.orientation_raw();
+
+        let angle = orientation.angle().unwrap();
+
+        match orientation.type_().unwrap() {
+            OrientationType::LandscapePrimary => OrientationData {
+                orientation: Orientation::Landscape,
+                flipped: false,
+                natural: angle == 0,
+            },
+            OrientationType::LandscapeSecondary => OrientationData {
+                orientation: Orientation::Landscape,
+                flipped: true,
+                natural: angle == 180,
+            },
+            OrientationType::PortraitPrimary => OrientationData {
+                orientation: Orientation::Portrait,
+                flipped: false,
+                natural: angle == 0,
+            },
+            OrientationType::PortraitSecondary => OrientationData {
+                orientation: Orientation::Portrait,
+                flipped: true,
+                natural: angle == 180,
+            },
+            _ => {
+                unreachable!("found unrecognized orientation: {}", orientation.type_string())
+            },
+        }
+    }
+
+    fn is_internal(&self) -> Option<bool> {
+        if let Screen::Detailed { screen, .. } = &self.screen {
+            Some(screen.is_internal())
+        } else {
+            None
+        }
+    }
+
+    fn is_detailed(&self) -> bool {
+        matches!(self.screen, Screen::Detailed { .. })
+    }
+
+    fn size(&self) -> PhysicalSize<u32> {
+        let width = self.screen.width().unwrap();
+        let height = self.screen.height().unwrap();
+
+        if let Some(Engine::Chromium) = self.engine {
+            PhysicalSize::new(width, height).cast()
+        } else {
+            LogicalSize::new(width, height).to_physical(super::web_sys::scale_factor(&self.window))
+        }
+    }
+
+    fn bit_depth(&self) -> Option<NonZeroU16> {
+        NonZeroU16::new(self.screen.color_depth().unwrap().try_into().unwrap())
+    }
+
     fn has_lock_support(&self) -> bool {
-        *HAS_LOCK_SUPPORT.get_or_init(|| !self.orientation().has_lock().is_undefined())
+        *HAS_LOCK_SUPPORT.get_or_init(|| !self.orientation_raw().has_lock().is_undefined())
     }
 }
 
diff --git a/src/platform_impl/windows/monitor.rs b/src/platform_impl/windows/monitor.rs
index 9a880db461..c6ab740da5 100644
--- a/src/platform_impl/windows/monitor.rs
+++ b/src/platform_impl/windows/monitor.rs
@@ -1,5 +1,6 @@
 use std::collections::{BTreeSet, VecDeque};
 use std::hash::Hash;
+use std::num::{NonZeroU16, NonZeroU32};
 use std::{io, mem, ptr};
 
 use windows_sys::Win32::Foundation::{BOOL, HWND, LPARAM, POINT, RECT};
@@ -20,8 +21,8 @@ use crate::platform_impl::platform::window::Window;
 #[derive(Clone)]
 pub struct VideoModeHandle {
     pub(crate) size: (u32, u32),
-    pub(crate) bit_depth: u16,
-    pub(crate) refresh_rate_millihertz: u32,
+    pub(crate) bit_depth: Option<NonZeroU16>,
+    pub(crate) refresh_rate_millihertz: Option<NonZeroU32>,
     pub(crate) monitor: MonitorHandle,
     // DEVMODEW is huge so we box it to avoid blowing up the size of winit::window::Fullscreen
     pub(crate) native_video_mode: Box<DEVMODEW>,
@@ -59,15 +60,29 @@ impl std::fmt::Debug for VideoModeHandle {
 }
 
 impl VideoModeHandle {
+    fn new(monitor: MonitorHandle, mode: DEVMODEW) -> Self {
+        const REQUIRED_FIELDS: u32 =
+            DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT | DM_DISPLAYFREQUENCY;
+        assert!(has_flag(mode.dmFields, REQUIRED_FIELDS));
+
+        VideoModeHandle {
+            size: (mode.dmPelsWidth, mode.dmPelsHeight),
+            bit_depth: NonZeroU16::new(mode.dmBitsPerPel as u16),
+            refresh_rate_millihertz: NonZeroU32::new(mode.dmDisplayFrequency * 1000),
+            monitor,
+            native_video_mode: Box::new(mode),
+        }
+    }
+
     pub fn size(&self) -> PhysicalSize<u32> {
         self.size.into()
     }
 
-    pub fn bit_depth(&self) -> u16 {
+    pub fn bit_depth(&self) -> Option<NonZeroU16> {
         self.bit_depth
     }
 
-    pub fn refresh_rate_millihertz(&self) -> u32 {
+    pub fn refresh_rate_millihertz(&self) -> Option<NonZeroU32> {
         self.refresh_rate_millihertz
     }
 
@@ -166,8 +181,7 @@ impl MonitorHandle {
         self.0
     }
 
-    #[inline]
-    pub fn size(&self) -> PhysicalSize<u32> {
+    pub(crate) fn size(&self) -> PhysicalSize<u32> {
         let rc_monitor = get_monitor_info(self.0).unwrap().monitorInfo.rcMonitor;
         PhysicalSize {
             width: (rc_monitor.right - rc_monitor.left) as u32,
@@ -176,7 +190,22 @@ impl MonitorHandle {
     }
 
     #[inline]
-    pub fn refresh_rate_millihertz(&self) -> Option<u32> {
+    pub fn position(&self) -> Option<PhysicalPosition<i32>> {
+        get_monitor_info(self.0)
+            .map(|info| {
+                let rc_monitor = info.monitorInfo.rcMonitor;
+                PhysicalPosition { x: rc_monitor.left, y: rc_monitor.top }
+            })
+            .ok()
+    }
+
+    #[inline]
+    pub fn scale_factor(&self) -> f64 {
+        dpi_to_scale_factor(get_monitor_dpi(self.0).unwrap_or(96))
+    }
+
+    #[inline]
+    pub fn current_video_mode(&self) -> Option<VideoModeHandle> {
         let monitor_info = get_monitor_info(self.0).ok()?;
         let device_name = monitor_info.szDevice.as_ptr();
         unsafe {
@@ -187,26 +216,11 @@ impl MonitorHandle {
             {
                 None
             } else {
-                Some(mode.dmDisplayFrequency * 1000)
+                Some(VideoModeHandle::new(self.clone(), mode))
             }
         }
     }
 
-    #[inline]
-    pub fn position(&self) -> PhysicalPosition<i32> {
-        get_monitor_info(self.0)
-            .map(|info| {
-                let rc_monitor = info.monitorInfo.rcMonitor;
-                PhysicalPosition { x: rc_monitor.left, y: rc_monitor.top }
-            })
-            .unwrap_or(PhysicalPosition { x: 0, y: 0 })
-    }
-
-    #[inline]
-    pub fn scale_factor(&self) -> f64 {
-        dpi_to_scale_factor(get_monitor_dpi(self.0).unwrap_or(96))
-    }
-
     #[inline]
     pub fn video_modes(&self) -> impl Iterator<Item = VideoModeHandle> {
         // EnumDisplaySettingsExW can return duplicate values (or some of the
@@ -233,19 +247,9 @@ impl MonitorHandle {
                 break;
             }
 
-            const REQUIRED_FIELDS: u32 =
-                DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT | DM_DISPLAYFREQUENCY;
-            assert!(has_flag(mode.dmFields, REQUIRED_FIELDS));
-
             // Use Ord impl of RootVideoModeHandle
             modes.insert(RootVideoModeHandle {
-                video_mode: VideoModeHandle {
-                    size: (mode.dmPelsWidth, mode.dmPelsHeight),
-                    bit_depth: mode.dmBitsPerPel as u16,
-                    refresh_rate_millihertz: mode.dmDisplayFrequency * 1000,
-                    monitor: self.clone(),
-                    native_video_mode: Box::new(mode),
-                },
+                video_mode: VideoModeHandle::new(self.clone(), mode),
             });
 
             i += 1;
diff --git a/src/platform_impl/windows/window.rs b/src/platform_impl/windows/window.rs
index 268767834d..afd399607f 100644
--- a/src/platform_impl/windows/window.rs
+++ b/src/platform_impl/windows/window.rs
@@ -786,7 +786,7 @@ impl Window {
                         Fullscreen::Borderless(None) => monitor::current_monitor(window),
                     };
 
-                    let position: (i32, i32) = monitor.position().into();
+                    let position: (i32, i32) = monitor.position().unwrap_or_default().into();
                     let size: (u32, u32) = monitor.size().into();
 
                     unsafe {