diff --git a/src/backend/dx12/src/lib.rs b/src/backend/dx12/src/lib.rs
index 553d93d3..b101e335 100644
--- a/src/backend/dx12/src/lib.rs
+++ b/src/backend/dx12/src/lib.rs
@@ -709,25 +709,29 @@ impl hal::Instance for Instance {
         let mut cur_index = 0;
         let mut adapters = Vec::new();
         loop {
-            let adapter = {
-                let mut adapter: *mut dxgi::IDXGIAdapter1 = ptr::null_mut();
-                let hr = unsafe {
-                    self.factory
-                        .EnumAdapters1(cur_index, &mut adapter as *mut *mut _)
-                };
+            let adapter = unsafe {
+                let mut ptr: *mut dxgi::IDXGIAdapter1 = ptr::null_mut();
+                let hr = self.factory
+                    .EnumAdapters1(cur_index, &mut ptr as *mut *mut _);

                 if hr == winerror::DXGI_ERROR_NOT_FOUND {
                     break;
                 }

-                unsafe { ComPtr::from_raw(adapter as *mut dxgi1_2::IDXGIAdapter2) }
+                ComPtr::from_raw(ptr as *mut dxgi1_2::IDXGIAdapter2)
+            };
+
+            let real_adapter = unsafe {
+                let mut ptr = ptr::null_mut();
+                adapter.QueryInterface(&dxgi1_4::IDXGIAdapter3::uuidof(), &mut ptr);
+                ComPtr::from_raw(ptr as *mut dxgi1_4::IDXGIAdapter3)
             };

             cur_index += 1;

             // Check for D3D12 support
             // Create temporaty device to get physical device information
-            let device = {
+            /*let device = {
                 let mut device = ptr::null_mut();
                 let hr = unsafe {
                     d3d12::D3D12CreateDevice(
@@ -742,7 +746,7 @@ impl hal::Instance for Instance {
                 }

                 unsafe { ComPtr::<d3d12::ID3D12Device>::from_raw(device) }
-            };
+            };*/

             // We have found a possible adapter
             // acquire the device information
@@ -765,30 +769,30 @@ impl hal::Instance for Instance {
                     DeviceType::VirtualGpu
                 } else {
                     DeviceType::DiscreteGpu
-                },
+                },
             };

             let mut features: d3d12::D3D12_FEATURE_DATA_D3D12_OPTIONS = unsafe { mem::zeroed() };
-            assert_eq!(winerror::S_OK, unsafe {
+            /*assert_eq!(winerror::S_OK, unsafe {
                 device.CheckFeatureSupport(
                     d3d12::D3D12_FEATURE_D3D12_OPTIONS,
                     &mut features as *mut _ as *mut _,
                     mem::size_of::<d3d12::D3D12_FEATURE_DATA_D3D12_OPTIONS>() as _,
                 )
-            });
+            });*/

             let mut features_architecture: d3d12::D3D12_FEATURE_DATA_ARCHITECTURE =
                 unsafe { mem::zeroed() };
-            assert_eq!(winerror::S_OK, unsafe {
+            /*assert_eq!(winerror::S_OK, unsafe {
                 device.CheckFeatureSupport(
                     d3d12::D3D12_FEATURE_ARCHITECTURE,
                     &mut features_architecture as *mut _ as *mut _,
                     mem::size_of::<d3d12::D3D12_FEATURE_DATA_ARCHITECTURE>() as _,
                 )
-            });
+            });*/

             let depth_bounds_test_supported = {
-                let mut features2: d3d12::D3D12_FEATURE_DATA_D3D12_OPTIONS2 =
+                /*let mut features2: d3d12::D3D12_FEATURE_DATA_D3D12_OPTIONS2 =
                     unsafe { mem::zeroed() };
                 let hr = unsafe {
                     device.CheckFeatureSupport(
@@ -801,11 +805,12 @@ impl hal::Instance for Instance {
                     features2.DepthBoundsTestSupported != 0
                 } else {
                     false
-                }
+                }*/
+                false
             };

             let mut format_properties = [f::Properties::default(); f::NUM_FORMATS];
-            for (i, props) in &mut format_properties.iter_mut().enumerate().skip(1) {
+            /*for (i, props) in &mut format_properties.iter_mut().enumerate().skip(1) {
                 let format: f::Format = unsafe { mem::transmute(i as u32) };
                 let mut data = d3d12::D3D12_FEATURE_DATA_FORMAT_SUPPORT {
                     Format: match conv::map_format(format) {
@@ -879,7 +884,7 @@ impl hal::Instance for Instance {
                     }
                 }
                 //TODO: blits, linear tiling
-            }
+            }*/

             let heterogeneous_resource_heaps =
                 features.ResourceHeapTier != d3d12::D3D12_RESOURCE_HEAP_TIER_1;
@@ -995,7 +1000,7 @@ impl hal::Instance for Instance {

             let memory_heaps = {
                 // Get the IDXGIAdapter3 from the created device to query video memory information.
-                let adapter_id = unsafe { device.GetAdapterLuid() };
+                /*let adapter_id = unsafe { device.GetAdapterLuid() };
                 let adapter = {
                     let mut adapter: *mut dxgi1_4::IDXGIAdapter3 = ptr::null_mut();
                     unsafe {
@@ -1009,13 +1014,13 @@ impl hal::Instance for Instance {
                         );
                         ComPtr::from_raw(adapter)
                     }
-                };
+                };*/

                 let query_memory = |segment: dxgi1_4::DXGI_MEMORY_SEGMENT_GROUP| unsafe {
                     let mut mem_info: dxgi1_4::DXGI_QUERY_VIDEO_MEMORY_INFO = mem::uninitialized();
                     assert_eq!(
                         winerror::S_OK,
-                        adapter.QueryVideoMemoryInfo(0, segment, &mut mem_info,)
+                        real_adapter.QueryVideoMemoryInfo(0, segment, &mut mem_info,)
                     );
                     mem_info.Budget
                 };