Changed enumerate_adapters to be able to work with custom backends (#8230)

Co-authored-by: Andreas Reich <[email protected]>

Author: R-Cramer4

CHANGELOG.md

@@ -40,6 +40,20 @@ Bottom level categories:
 
 ## Unreleased
 
+#### 'wgpu::Instance::enumerate_adapters` is now `async` & available on WebGPU
+
+Making `enumerate_adapters` async allows custom backends to use it along with elimnating some native/non-native distinctions
+
+This is a breaking change
+
+```diff
+- pub fn enumerate_adapters(&self, backends: Backends) -> Vec<Adapter> {
++ pub fn enumerate_adapters(&self, backends: Backends) -> impl Future<Output = Vec<Adapter>> {
+
+```
+
+By @R-Cramer4 in [#8230](https://github.com/gfx-rs/wgpu/pull/8230)
+
 ## v27.0.2 (2025-10-03)
 
 ### Bug Fixes
@@ -175,7 +189,6 @@ by if the `Feature::MULTI_DRAW_INDIRECT_COUNT` feature is available on the devic
 
 By @cwfitzgerald in [#8162](https://github.com/gfx-rs/wgpu/pull/8162).
 
-
 #### `wgpu::PollType::Wait` has now an optional timeout
 
 We removed `wgpu::PollType::WaitForSubmissionIndex` and added fields to `wgpu::PollType::Wait` in order to express timeouts.

Cargo.lock

@@ -203,7 +203,7 @@ pub(crate) async fn get_adapter_with_capabilities_or_from_env(
             );
         adapter
     } else {
-        let adapters = instance.enumerate_adapters(Backends::all());
+        let adapters = instance.enumerate_adapters(Backends::all()).await;
 
         let mut chosen_adapter = None;
         for adapter in adapters {

examples/features/src/utils.rs

@@ -55,6 +55,13 @@ impl InstanceInterface for CustomInstance {
     fn wgsl_language_features(&self) -> wgpu::WgslLanguageFeatures {
         unimplemented!()
     }
+
+    fn enumerate_adapters(
+        &self,
+        _backends: wgpu::Backends,
+    ) -> Pin<Box<dyn wgpu::custom::EnumerateAdapterFuture>> {
+        unimplemented!()
+    }
 }
 
 #[derive(Debug)]

examples/standalone/custom_backend/src/custom.rs

@@ -122,7 +122,7 @@ pub async fn initialize_adapter(
 
     cfg_if::cfg_if! {
         if #[cfg(not(target_arch = "wasm32"))] {
-            let adapter_iter = instance.enumerate_adapters(backends);
+            let adapter_iter = instance.enumerate_adapters(backends).await;
             let adapter = adapter_iter.into_iter()
                 // If we have a report, we only want to match the adapter with the same info.
                 //
@@ -136,7 +136,7 @@ pub async fn initialize_adapter(
                 panic!(
                     "Could not find adapter with info {:#?} in {:#?}",
                     adapter_report.map(|r| &r.info),
-                    instance.enumerate_adapters(backends).into_iter().map(|a| a.get_info()).collect::<Vec<_>>(),
+                    instance.enumerate_adapters(backends).await.into_iter().map(|a| a.get_info()).collect::<Vec<_>>(),
                 );
             };
         } else {

tests/src/init.rs

@@ -16,6 +16,7 @@ bitflags.workspace = true
 env_logger.workspace = true
 hashbrown = { workspace = true, features = ["serde"] }
 pico-args.workspace = true
+pollster.workspace = true
 serde = { workspace = true, features = ["default"] }
 serde_json.workspace = true
 wgpu.workspace = true

wgpu-info/Cargo.toml

@@ -25,7 +25,8 @@ impl GpuReport {
             desc.flags = wgpu::InstanceFlags::debugging();
             desc.with_env()
         });
-        let adapters = instance.enumerate_adapters(wgpu::Backends::all());
+
+        let adapters = pollster::block_on(instance.enumerate_adapters(wgpu::Backends::all()));
 
         let mut devices = Vec::with_capacity(adapters.len());
         for adapter in adapters {

wgpu-info/src/report.rs

@@ -1,4 +1,3 @@
-#[cfg(wgpu_core)]
 use alloc::vec::Vec;
 use core::future::Future;
 
@@ -142,23 +141,18 @@ impl Instance {
     /// # Arguments
     ///
     /// - `backends` - Backends from which to enumerate adapters.
-    #[cfg(wgpu_core)]
-    pub fn enumerate_adapters(&self, backends: Backends) -> Vec<Adapter> {
-        let Some(core_instance) = self.inner.as_core_opt() else {
-            return Vec::new();
-        };
-
-        core_instance
-            .enumerate_adapters(backends)
-            .into_iter()
-            .map(|adapter| {
-                let core = backend::wgpu_core::CoreAdapter {
-                    context: core_instance.clone(),
-                    id: adapter,
-                };
-                crate::Adapter { inner: core.into() }
-            })
-            .collect()
+    pub fn enumerate_adapters(&self, backends: Backends) -> impl Future<Output = Vec<Adapter>> {
+        let future = self.inner.enumerate_adapters(backends);
+
+        async move {
+            future
+                .await
+                .iter()
+                .map(|adapter| Adapter {
+                    inner: adapter.clone(),
+                })
+                .collect()
+        }
     }
 
     /// Retrieves an [`Adapter`] which matches the given [`RequestAdapterOptions`].

wgpu/src/api/instance.rs

@@ -1569,6 +1569,20 @@ impl dispatch::InstanceInterface for ContextWebGpu {
             ))))
         }
     }
+    fn enumerate_adapters(
+        &self,
+        _backends: crate::Backends,
+    ) -> Pin<Box<dyn dispatch::EnumerateAdapterFuture>> {
+        let future = self.request_adapter(&crate::RequestAdapterOptions::default());
+        let enumerate_future = async move {
+            let adapter = future.await;
+            match adapter {
+                Ok(a) => vec![a],
+                Err(_) => vec![],
+            }
+        };
+        Box::pin(enumerate_future)
+    }
 
     fn poll_all_devices(&self, _force_wait: bool) -> bool {
         // Devices are automatically polled.

wgpu/src/backend/webgpu.rs

@@ -28,14 +28,14 @@ use wgt::{
     WasmNotSendSync,
 };
 
-use crate::util::Mutex;
 use crate::{
     api,
     dispatch::{self, BlasCompactCallback, BufferMappedRangeInterface},
     BindingResource, Blas, BufferBinding, BufferDescriptor, CompilationInfo, CompilationMessage,
     CompilationMessageType, ErrorSource, Features, Label, LoadOp, MapMode, Operations,
     ShaderSource, SurfaceTargetUnsafe, TextureDescriptor, Tlas,
 };
+use crate::{dispatch::DispatchAdapter, util::Mutex};
 
 #[derive(Clone)]
 pub struct ContextWgpuCore(Arc<wgc::global::Global>);
@@ -902,6 +902,24 @@ impl dispatch::InstanceInterface for ContextWgpuCore {
             },
         )
     }
+
+    fn enumerate_adapters(
+        &self,
+        backends: crate::Backends,
+    ) -> Pin<Box<dyn dispatch::EnumerateAdapterFuture>> {
+        let adapters: Vec<DispatchAdapter> = self
+            .enumerate_adapters(backends)
+            .into_iter()
+            .map(|adapter| {
+                let core = crate::backend::wgpu_core::CoreAdapter {
+                    context: self.clone(),
+                    id: adapter,
+                };
+                core.into()
+            })
+            .collect();
+        Box::pin(ready(adapters))
+    }
 }
 
 impl dispatch::AdapterInterface for CoreAdapter {