diff --git a/Cargo.lock b/Cargo.lock
index 67e0813b7b..488c28b695 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2023,7 +2023,7 @@ dependencies = [
  "siphasher 0.3.11",
  "volatile",
  "widestring",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -2252,8 +2252,7 @@ dependencies = [
  "unicode_names2",
  "uuid",
  "widestring",
- "winapi",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
  "xml-rs",
 ]
 
@@ -2332,7 +2331,7 @@ dependencies = [
  "which",
  "widestring",
  "windows",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
  "winreg",
 ]
 
diff --git a/Cargo.toml b/Cargo.toml
index 807e821ca7..14e66b39eb 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -181,7 +181,7 @@ thiserror = "2.0"
 thread_local = "1.1.8"
 unicode_names2 = "1.3.0"
 widestring = "1.1.0"
-windows-sys = "0.52.0"
+windows-sys = "0.59.0"
 wasm-bindgen = "0.2.100"
 
 # Lints
diff --git a/common/src/fileutils.rs b/common/src/fileutils.rs
index 7d5ff01942..67713c0148 100644
--- a/common/src/fileutils.rs
+++ b/common/src/fileutils.rs
@@ -116,7 +116,7 @@ pub mod windows {
         let h = h?;
         // reset stat?
 
-        let file_type = unsafe { GetFileType(h) };
+        let file_type = unsafe { GetFileType(h as _) };
         if file_type == FILE_TYPE_UNKNOWN {
             return Err(std::io::Error::last_os_error());
         }
@@ -138,10 +138,10 @@ pub mod windows {
         let mut basic_info: FILE_BASIC_INFO = unsafe { std::mem::zeroed() };
         let mut id_info: FILE_ID_INFO = unsafe { std::mem::zeroed() };
 
-        if unsafe { GetFileInformationByHandle(h, &mut info) } == 0
+        if unsafe { GetFileInformationByHandle(h as _, &mut info) } == 0
             || unsafe {
                 GetFileInformationByHandleEx(
-                    h,
+                    h as _,
                     FileBasicInfo,
                     &mut basic_info as *mut _ as *mut _,
                     std::mem::size_of_val(&basic_info) as u32,
@@ -153,7 +153,7 @@ pub mod windows {
 
         let p_id_info = if unsafe {
             GetFileInformationByHandleEx(
-                h,
+                h as _,
                 FileIdInfo,
                 &mut id_info as *mut _ as *mut _,
                 std::mem::size_of_val(&id_info) as u32,
@@ -320,7 +320,7 @@ pub mod windows {
             .get_or_init(|| {
                 let library_name = OsString::from("api-ms-win-core-file-l2-1-4").to_wide_with_nul();
                 let module = unsafe { LoadLibraryW(library_name.as_ptr()) };
-                if module == 0 {
+                if module.is_null() {
                     return None;
                 }
                 let name = CString::new("GetFileInformationByName").unwrap();
diff --git a/stdlib/Cargo.toml b/stdlib/Cargo.toml
index 1086dea090..d7552844be 100644
--- a/stdlib/Cargo.toml
+++ b/stdlib/Cargo.toml
@@ -117,12 +117,6 @@ paste = { workspace = true }
 schannel = { workspace = true }
 widestring = { workspace = true }
 
-[target.'cfg(windows)'.dependencies.winapi]
-version = "0.3.9"
-features = [
-  "winsock2", "ifdef", "netioapi", "ws2tcpip",
-]
-
 [target.'cfg(windows)'.dependencies.windows-sys]
 workspace = true
 features = [
@@ -131,6 +125,7 @@ features = [
   "Win32_NetworkManagement_Ndis",
   "Win32_Security_Cryptography",
   "Win32_System_Environment",
+  "Win32_System_IO"
 ]
 
 [target.'cfg(target_os = "macos")'.dependencies]
diff --git a/stdlib/src/overlapped.rs b/stdlib/src/overlapped.rs
index f40494a432..234e3be53a 100644
--- a/stdlib/src/overlapped.rs
+++ b/stdlib/src/overlapped.rs
@@ -24,13 +24,17 @@ mod _overlapped {
     use windows_sys::Win32::{
         Foundation::{
             ERROR_IO_PENDING, ERROR_NETNAME_DELETED, ERROR_OPERATION_ABORTED, ERROR_PIPE_BUSY,
-            ERROR_PORT_UNREACHABLE, ERROR_SEM_TIMEOUT, INVALID_HANDLE_VALUE,
+            ERROR_PORT_UNREACHABLE, ERROR_SEM_TIMEOUT,
         },
         Networking::WinSock::{
             SO_UPDATE_ACCEPT_CONTEXT, SO_UPDATE_CONNECT_CONTEXT, TF_REUSE_SOCKET,
         },
         System::Threading::INFINITE,
     };
+    #[pyattr(once)]
+    fn INVALID_HANDLE_VALUE(_vm: &VirtualMachine) -> isize {
+        windows_sys::Win32::Foundation::INVALID_HANDLE_VALUE as isize
+    }
     #[pyattr]
     const NULL: isize = 0;
 
@@ -126,7 +130,7 @@ mod _overlapped {
 
     fn mark_as_completed(ov: &mut OVERLAPPED) {
         ov.Internal = 0;
-        if ov.hEvent != 0 {
+        if !ov.hEvent.is_null() {
             unsafe { windows_sys::Win32::System::Threading::SetEvent(ov.hEvent) };
         }
     }
@@ -164,7 +168,7 @@ mod _overlapped {
 
         fn WSARecv_inner(
             inner: &mut OverlappedInner,
-            handle: HANDLE,
+            handle: isize,
             buf: &[u8],
             mut flags: u32,
             vm: &VirtualMachine,
@@ -209,7 +213,7 @@ mod _overlapped {
         #[pymethod]
         fn WSARecv(
             zelf: &Py<Self>,
-            handle: HANDLE,
+            handle: isize,
             size: u32,
             flags: u32,
             vm: &VirtualMachine,
@@ -224,9 +228,9 @@ mod _overlapped {
 
             let buf = vec![0u8; std::cmp::max(size, 1) as usize];
             let buf = vm.ctx.new_bytes(buf);
-            inner.handle = handle;
+            inner.handle = handle as _;
 
-            let r = Self::WSARecv_inner(&mut inner, handle, buf.as_bytes(), flags, vm);
+            let r = Self::WSARecv_inner(&mut inner, handle as _, buf.as_bytes(), flags, vm);
             inner.data = OverlappedData::Read(buf);
             r
         }
@@ -256,17 +260,17 @@ mod _overlapped {
     }
 
     impl Constructor for Overlapped {
-        type Args = (HANDLE,);
+        type Args = (isize,);
 
         fn py_new(cls: PyTypeRef, (mut event,): Self::Args, vm: &VirtualMachine) -> PyResult {
-            if event == INVALID_HANDLE_VALUE {
+            if event == INVALID_HANDLE_VALUE(vm) {
                 event = unsafe {
                     windows_sys::Win32::System::Threading::CreateEventA(
                         std::ptr::null(),
                         Foundation::TRUE,
                         Foundation::FALSE,
                         std::ptr::null(),
-                    )
+                    ) as isize
                 };
                 if event == NULL {
                     return Err(errno_err(vm));
@@ -275,11 +279,11 @@ mod _overlapped {
 
             let mut overlapped: OVERLAPPED = unsafe { std::mem::zeroed() };
             if event != NULL {
-                overlapped.hEvent = event;
+                overlapped.hEvent = event as _;
             }
             let inner = OverlappedInner {
                 overlapped,
-                handle: NULL,
+                handle: NULL as _,
                 error: 0,
                 data: OverlappedData::None,
             };
@@ -292,29 +296,34 @@ mod _overlapped {
 
     #[pyfunction]
     fn CreateIoCompletionPort(
-        handle: HANDLE,
-        port: HANDLE,
+        handle: isize,
+        port: isize,
         key: usize,
         concurrency: u32,
         vm: &VirtualMachine,
-    ) -> PyResult<HANDLE> {
+    ) -> PyResult<isize> {
         let r = unsafe {
-            windows_sys::Win32::System::IO::CreateIoCompletionPort(handle, port, key, concurrency)
+            windows_sys::Win32::System::IO::CreateIoCompletionPort(
+                handle as _,
+                port as _,
+                key,
+                concurrency,
+            ) as isize
         };
-        if r == 0 {
+        if r as usize == 0 {
             return Err(errno_err(vm));
         }
         Ok(r)
     }
 
     #[pyfunction]
-    fn GetQueuedCompletionStatus(port: HANDLE, msecs: u32, vm: &VirtualMachine) -> PyResult {
+    fn GetQueuedCompletionStatus(port: isize, msecs: u32, vm: &VirtualMachine) -> PyResult {
         let mut bytes_transferred = 0;
         let mut completion_key = 0;
         let mut overlapped: *mut OVERLAPPED = std::ptr::null_mut();
         let ret = unsafe {
             windows_sys::Win32::System::IO::GetQueuedCompletionStatus(
-                port,
+                port as _,
                 &mut bytes_transferred,
                 &mut completion_key,
                 &mut overlapped,
diff --git a/stdlib/src/socket.rs b/stdlib/src/socket.rs
index 533a0a0b24..39bfde4bee 100644
--- a/stdlib/src/socket.rs
+++ b/stdlib/src/socket.rs
@@ -35,18 +35,11 @@ mod _socket {
     use libc as c;
     #[cfg(windows)]
     mod c {
-        pub use winapi::shared::netioapi::{if_indextoname, if_nametoindex};
-        pub use winapi::shared::ws2def::{
+        pub use windows_sys::Win32::NetworkManagement::IpHelper::{if_indextoname, if_nametoindex};
+        pub use windows_sys::Win32::Networking::WinSock::{
             INADDR_ANY, INADDR_BROADCAST, INADDR_LOOPBACK, INADDR_NONE,
         };
-        pub use winapi::um::winsock2::{
-            SO_EXCLUSIVEADDRUSE, getprotobyname, getservbyname, getservbyport, getsockopt,
-            setsockopt,
-        };
-        pub use winapi::um::ws2tcpip::{
-            EAI_AGAIN, EAI_BADFLAGS, EAI_FAIL, EAI_FAMILY, EAI_MEMORY, EAI_NODATA, EAI_NONAME,
-            EAI_SERVICE, EAI_SOCKTYPE,
-        };
+
         pub use windows_sys::Win32::Networking::WinSock::{
             AF_APPLETALK, AF_DECnet, AF_IPX, AF_LINK, AI_ADDRCONFIG, AI_ALL, AI_CANONNAME,
             AI_NUMERICSERV, AI_V4MAPPED, IP_ADD_MEMBERSHIP, IP_DROP_MEMBERSHIP, IP_HDRINCL,
@@ -68,6 +61,17 @@ mod _socket {
             SOL_SOCKET, SOMAXCONN, TCP_NODELAY, WSAEBADF, WSAECONNRESET, WSAENOTSOCK,
             WSAEWOULDBLOCK,
         };
+        pub use windows_sys::Win32::Networking::WinSock::{
+            SO_REUSEADDR as SO_EXCLUSIVEADDRUSE, getprotobyname, getservbyname, getservbyport,
+            getsockopt, setsockopt,
+        };
+        pub use windows_sys::Win32::Networking::WinSock::{
+            WSA_NOT_ENOUGH_MEMORY as EAI_MEMORY, WSAEAFNOSUPPORT as EAI_FAMILY,
+            WSAEINVAL as EAI_BADFLAGS, WSAESOCKTNOSUPPORT as EAI_SOCKTYPE,
+            WSAHOST_NOT_FOUND as EAI_NODATA, WSAHOST_NOT_FOUND as EAI_NONAME,
+            WSANO_RECOVERY as EAI_FAIL, WSATRY_AGAIN as EAI_AGAIN,
+            WSATYPE_NOT_FOUND as EAI_SERVICE,
+        };
         pub const IF_NAMESIZE: usize =
             windows_sys::Win32::NetworkManagement::Ndis::IF_MAX_STRING_SIZE as _;
         pub const AF_UNSPEC: i32 = windows_sys::Win32::Networking::WinSock::AF_UNSPEC as _;
@@ -755,7 +759,7 @@ mod _socket {
 }
 
     #[cfg(windows)]
-    use winapi::shared::netioapi;
+    use windows_sys::Win32::NetworkManagement::IpHelper;
 
     fn get_raw_sock(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<RawSocket> {
         #[cfg(unix)]
@@ -1755,7 +1759,7 @@ mod _socket {
             .map(|s| s.to_cstring(vm))
             .transpose()?;
         let cstr_proto = cstr_opt_as_ptr(&cstr_proto);
-        let serv = unsafe { c::getservbyname(cstr_name.as_ptr(), cstr_proto) };
+        let serv = unsafe { c::getservbyname(cstr_name.as_ptr() as _, cstr_proto as _) };
         if serv.is_null() {
             return Err(vm.new_os_error("service/proto not found".to_owned()));
         }
@@ -1777,11 +1781,11 @@ mod _socket {
             .map(|s| s.to_cstring(vm))
             .transpose()?;
         let cstr_proto = cstr_opt_as_ptr(&cstr_proto);
-        let serv = unsafe { c::getservbyport(port.to_be() as _, cstr_proto) };
+        let serv = unsafe { c::getservbyport(port.to_be() as _, cstr_proto as _) };
         if serv.is_null() {
             return Err(vm.new_os_error("port/proto not found".to_owned()));
         }
-        let s = unsafe { ffi::CStr::from_ptr((*serv).s_name) };
+        let s = unsafe { ffi::CStr::from_ptr((*serv).s_name as _) };
         Ok(s.to_string_lossy().into_owned())
     }
 
@@ -2033,7 +2037,7 @@ mod _socket {
     #[pyfunction]
     fn getprotobyname(name: PyStrRef, vm: &VirtualMachine) -> PyResult {
         let cstr = name.to_cstring(vm)?;
-        let proto = unsafe { c::getprotobyname(cstr.as_ptr()) };
+        let proto = unsafe { c::getprotobyname(cstr.as_ptr() as _) };
         if proto.is_null() {
             return Err(vm.new_os_error("protocol not found".to_owned()));
         }
@@ -2111,14 +2115,14 @@ mod _socket {
     #[cfg(all(unix, not(target_os = "redox")))]
     type IfIndex = c::c_uint;
     #[cfg(windows)]
-    type IfIndex = winapi::shared::ifdef::NET_IFINDEX;
+    type IfIndex = u32; // NET_IFINDEX but windows-sys 0.59 doesn't have it
 
     #[cfg(not(target_os = "redox"))]
     #[pyfunction]
     fn if_nametoindex(name: FsPath, vm: &VirtualMachine) -> PyResult<IfIndex> {
         let name = name.to_cstring(vm)?;
 
-        let ret = unsafe { c::if_nametoindex(name.as_ptr()) };
+        let ret = unsafe { c::if_nametoindex(name.as_ptr() as _) };
         if ret == 0 {
             Err(vm.new_os_error("no interface with this name".to_owned()))
         } else {
@@ -2134,7 +2138,7 @@ mod _socket {
         if ret.is_null() {
             Err(crate::vm::stdlib::os::errno_err(vm))
         } else {
-            let buf = unsafe { ffi::CStr::from_ptr(buf.as_ptr()) };
+            let buf = unsafe { ffi::CStr::from_ptr(buf.as_ptr() as _) };
             Ok(buf.to_string_lossy().into_owned())
         }
     }
@@ -2170,6 +2174,7 @@ mod _socket {
         #[cfg(windows)]
         {
             use std::ptr;
+            use windows_sys::Win32::NetworkManagement::Ndis::NET_LUID_LH;
 
             let table = MibTable::get_raw().map_err(|err| err.into_pyexception(vm))?;
             let list = table.as_slice().iter().map(|entry| {
@@ -2181,12 +2186,10 @@ mod _socket {
             let list = list.collect::<PyResult<_>>()?;
             return Ok(list);
 
-            fn get_name(
-                luid: &winapi::shared::ifdef::NET_LUID,
-            ) -> io::Result<widestring::WideCString> {
+            fn get_name(luid: &NET_LUID_LH) -> io::Result<widestring::WideCString> {
                 let mut buf = [0; c::IF_NAMESIZE + 1];
                 let ret = unsafe {
-                    netioapi::ConvertInterfaceLuidToNameW(luid, buf.as_mut_ptr(), buf.len())
+                    IpHelper::ConvertInterfaceLuidToNameW(luid, buf.as_mut_ptr(), buf.len())
                 };
                 if ret == 0 {
                     Ok(widestring::WideCString::from_ustr_truncate(
@@ -2197,12 +2200,12 @@ mod _socket {
                 }
             }
             struct MibTable {
-                ptr: ptr::NonNull<netioapi::MIB_IF_TABLE2>,
+                ptr: ptr::NonNull<IpHelper::MIB_IF_TABLE2>,
             }
             impl MibTable {
                 fn get_raw() -> io::Result<Self> {
                     let mut ptr = ptr::null_mut();
-                    let ret = unsafe { netioapi::GetIfTable2Ex(netioapi::MibIfTableRaw, &mut ptr) };
+                    let ret = unsafe { IpHelper::GetIfTable2Ex(IpHelper::MibIfTableRaw, &mut ptr) };
                     if ret == 0 {
                         let ptr = unsafe { ptr::NonNull::new_unchecked(ptr) };
                         Ok(Self { ptr })
@@ -2212,17 +2215,17 @@ mod _socket {
                 }
             }
             impl MibTable {
-                fn as_slice(&self) -> &[netioapi::MIB_IF_ROW2] {
+                fn as_slice(&self) -> &[IpHelper::MIB_IF_ROW2] {
                     unsafe {
                         let p = self.ptr.as_ptr();
-                        let ptr = &raw const (*p).Table as *const netioapi::MIB_IF_ROW2;
+                        let ptr = &raw const (*p).Table as *const IpHelper::MIB_IF_ROW2;
                         std::slice::from_raw_parts(ptr, (*p).NumEntries as usize)
                     }
                 }
             }
             impl Drop for MibTable {
                 fn drop(&mut self) {
-                    unsafe { netioapi::FreeMibTable(self.ptr.as_ptr() as *mut _) }
+                    unsafe { IpHelper::FreeMibTable(self.ptr.as_ptr() as *mut _) };
                 }
             }
         }
diff --git a/vm/Cargo.toml b/vm/Cargo.toml
index acc645bb74..0b823c11a3 100644
--- a/vm/Cargo.toml
+++ b/vm/Cargo.toml
@@ -141,6 +141,7 @@ features = [
   "Win32_System_SystemInformation",
   "Win32_System_SystemServices",
   "Win32_System_Threading",
+  "Win32_System_WindowsProgramming",
   "Win32_UI_Shell",
   "Win32_UI_WindowsAndMessaging",
 ]
diff --git a/vm/src/stdlib/nt.rs b/vm/src/stdlib/nt.rs
index 34fa8792d5..ecc63e0aa6 100644
--- a/vm/src/stdlib/nt.rs
+++ b/vm/src/stdlib/nt.rs
@@ -150,7 +150,7 @@ pub(crate) mod module {
         }
 
         let h = unsafe { Threading::OpenProcess(Threading::PROCESS_ALL_ACCESS, 0, pid) };
-        if h == 0 {
+        if h.is_null() {
             return Err(errno_err(vm));
         }
         let ret = unsafe { Threading::TerminateProcess(h, sig) };
@@ -172,7 +172,7 @@ pub(crate) mod module {
                 _ => return Err(vm.new_value_error("bad file descriptor".to_owned())),
             };
             let h = unsafe { Console::GetStdHandle(stdhandle) };
-            if h == 0 {
+            if h.is_null() {
                 return Err(vm.new_os_error("handle cannot be retrieved".to_owned()));
             }
             if h == INVALID_HANDLE_VALUE {
diff --git a/vm/src/stdlib/winapi.rs b/vm/src/stdlib/winapi.rs
index c1edb2739e..7ffc4227e6 100644
--- a/vm/src/stdlib/winapi.rs
+++ b/vm/src/stdlib/winapi.rs
@@ -79,7 +79,7 @@ mod _winapi {
 
     #[pyfunction]
     fn CloseHandle(handle: HANDLE) -> WindowsSysResult<BOOL> {
-        WindowsSysResult(unsafe { windows_sys::Win32::Foundation::CloseHandle(handle.0) })
+        WindowsSysResult(unsafe { windows_sys::Win32::Foundation::CloseHandle(handle.0 as _) })
     }
 
     #[pyfunction]
@@ -99,8 +99,8 @@ mod _winapi {
             let mut read = std::mem::MaybeUninit::<isize>::uninit();
             let mut write = std::mem::MaybeUninit::<isize>::uninit();
             WindowsSysResult(windows_sys::Win32::System::Pipes::CreatePipe(
-                read.as_mut_ptr(),
-                write.as_mut_ptr(),
+                read.as_mut_ptr() as _,
+                write.as_mut_ptr() as _,
                 std::ptr::null(),
                 size,
             ))
@@ -122,10 +122,10 @@ mod _winapi {
         let target = unsafe {
             let mut target = std::mem::MaybeUninit::<isize>::uninit();
             WindowsSysResult(windows_sys::Win32::Foundation::DuplicateHandle(
-                src_process.0,
-                src.0,
-                target_process.0,
-                target.as_mut_ptr(),
+                src_process.0 as _,
+                src.0 as _,
+                target_process.0 as _,
+                target.as_mut_ptr() as _,
                 access,
                 inherit,
                 options.unwrap_or(0),
@@ -151,7 +151,7 @@ mod _winapi {
         h: HANDLE,
         vm: &VirtualMachine,
     ) -> PyResult<windows_sys::Win32::Storage::FileSystem::FILE_TYPE> {
-        let file_type = unsafe { windows_sys::Win32::Storage::FileSystem::GetFileType(h.0) };
+        let file_type = unsafe { windows_sys::Win32::Storage::FileSystem::GetFileType(h.0 as _) };
         if file_type == 0 && unsafe { windows_sys::Win32::Foundation::GetLastError() } != 0 {
             Err(errno_err(vm))
         } else {
@@ -274,25 +274,21 @@ mod _winapi {
         };
 
         Ok((
-            HANDLE(procinfo.hProcess),
-            HANDLE(procinfo.hThread),
+            HANDLE(procinfo.hProcess as _),
+            HANDLE(procinfo.hThread as _),
             procinfo.dwProcessId,
             procinfo.dwThreadId,
         ))
     }
 
     #[pyfunction]
-    fn OpenProcess(
-        desired_access: u32,
-        inherit_handle: bool,
-        process_id: u32,
-    ) -> windows_sys::Win32::Foundation::HANDLE {
+    fn OpenProcess(desired_access: u32, inherit_handle: bool, process_id: u32) -> isize {
         unsafe {
             windows_sys::Win32::System::Threading::OpenProcess(
                 desired_access,
                 BOOL::from(inherit_handle),
                 process_id,
-            )
+            ) as _
         }
     }
 
@@ -438,7 +434,8 @@ mod _winapi {
 
     #[pyfunction]
     fn WaitForSingleObject(h: HANDLE, ms: u32, vm: &VirtualMachine) -> PyResult<u32> {
-        let ret = unsafe { windows_sys::Win32::System::Threading::WaitForSingleObject(h.0, ms) };
+        let ret =
+            unsafe { windows_sys::Win32::System::Threading::WaitForSingleObject(h.0 as _, ms) };
         if ret == windows_sys::Win32::Foundation::WAIT_FAILED {
             Err(errno_err(vm))
         } else {
@@ -451,7 +448,7 @@ mod _winapi {
         unsafe {
             let mut ec = std::mem::MaybeUninit::uninit();
             WindowsSysResult(windows_sys::Win32::System::Threading::GetExitCodeProcess(
-                h.0,
+                h.0 as _,
                 ec.as_mut_ptr(),
             ))
             .to_pyresult(vm)?;
@@ -462,7 +459,7 @@ mod _winapi {
     #[pyfunction]
     fn TerminateProcess(h: HANDLE, exit_code: u32) -> WindowsSysResult<BOOL> {
         WindowsSysResult(unsafe {
-            windows_sys::Win32::System::Threading::TerminateProcess(h.0, exit_code)
+            windows_sys::Win32::System::Threading::TerminateProcess(h.0 as _, exit_code)
         })
     }
 
@@ -507,11 +504,13 @@ mod _winapi {
         // if handle.is_invalid() {
         //     return Err(errno_err(vm));
         // }
-        Ok(handle)
+        Ok(handle as _)
     }
 
     #[pyfunction]
     fn ReleaseMutex(handle: isize) -> WindowsSysResult<BOOL> {
-        WindowsSysResult(unsafe { windows_sys::Win32::System::Threading::ReleaseMutex(handle) })
+        WindowsSysResult(unsafe {
+            windows_sys::Win32::System::Threading::ReleaseMutex(handle as _)
+        })
     }
 }
diff --git a/vm/src/windows.rs b/vm/src/windows.rs
index f4f4dad0b3..a14216768e 100644
--- a/vm/src/windows.rs
+++ b/vm/src/windows.rs
@@ -23,7 +23,7 @@ impl WindowsSysResultValue for RAW_HANDLE {
         *self == INVALID_HANDLE_VALUE
     }
     fn into_ok(self) -> Self::Ok {
-        HANDLE(self)
+        HANDLE(self as _)
     }
 }