Initial precompiled shaders implementation

CHANGELOG.md

@@ -53,6 +53,9 @@ We have merged the acceleration structure feature into the `RayQuery` feature. T
 
 By @Vecvec in [#7913](https://github.com/gfx-rs/wgpu/pull/7913).
 
+### General
+- Added `Features::EXPERIMENTAL_PRECOMPILED_SHADERS`, replacing existing passthrough types with a unified `CreateShaderModuleDescriptorPassthrough` which allows passing multiple shader codes for different backends. By @SupaMaggie70Incorporated in [#7834](https://github.com/gfx-rs/wgpu/pull/7834)
+
 ## v26.0.1 (2025-07-10)
 
 ### Bug Fixes

deno_webgpu/webidl.rs

@@ -419,10 +419,6 @@ pub enum GPUFeatureName {
     VertexWritableStorage,
     #[webidl(rename = "clear-texture")]
     ClearTexture,
-    #[webidl(rename = "msl-shader-passthrough")]
-    MslShaderPassthrough,
-    #[webidl(rename = "spirv-shader-passthrough")]
-    SpirvShaderPassthrough,
     #[webidl(rename = "multiview")]
     Multiview,
     #[webidl(rename = "vertex-attribute-64-bit")]
@@ -482,8 +478,6 @@ pub fn feature_names_to_features(names: Vec<GPUFeatureName>) -> wgpu_types::Feat
       GPUFeatureName::ConservativeRasterization => Features::CONSERVATIVE_RASTERIZATION,
       GPUFeatureName::VertexWritableStorage => Features::VERTEX_WRITABLE_STORAGE,
       GPUFeatureName::ClearTexture => Features::CLEAR_TEXTURE,
-      GPUFeatureName::MslShaderPassthrough => Features::MSL_SHADER_PASSTHROUGH,
-      GPUFeatureName::SpirvShaderPassthrough => Features::SPIRV_SHADER_PASSTHROUGH,
       GPUFeatureName::Multiview => Features::MULTIVIEW,
       GPUFeatureName::VertexAttribute64Bit => Features::VERTEX_ATTRIBUTE_64BIT,
       GPUFeatureName::ShaderF64 => Features::SHADER_F64,
@@ -626,9 +620,6 @@ pub fn features_to_feature_names(features: wgpu_types::Features) -> HashSet<GPUF
     if features.contains(wgpu_types::Features::CLEAR_TEXTURE) {
         return_features.insert(ClearTexture);
     }
-    if features.contains(wgpu_types::Features::SPIRV_SHADER_PASSTHROUGH) {
-        return_features.insert(SpirvShaderPassthrough);
-    }
     if features.contains(wgpu_types::Features::MULTIVIEW) {
         return_features.insert(Multiview);
     }

player/src/lib.rs

@@ -8,7 +8,7 @@ extern crate wgpu_types as wgt;
 
 use wgc::device::trace;
 
-use std::{borrow::Cow, fs, path::Path};
+use std::{borrow::Cow, fs, io::Read, path::Path};
 
 pub trait GlobalPlay {
     fn encode_commands(
@@ -295,6 +295,94 @@ impl GlobalPlay for wgc::global::Global {
                     println!("shader compilation error:\n---{code}\n---\n{e}");
                 }
             }
+            Action::CreateShaderModulePassthrough {
+                id,
+                data,
+                entry_point,
+                label,
+                num_workgroups,
+                reflection,
+                runtime_checks,
+            } => {
+                let spirv = data.iter().find_map(|a| {
+                    if a.ends_with(".spv") {
+                        let mut file = fs::File::open(dir.join(a)).unwrap();
+                        let word_count = file.metadata().unwrap().len() as usize / 4;
+                        let mut vec = Vec::<u32>::with_capacity(word_count);
+                        unsafe {
+                            file.read_exact(std::slice::from_raw_parts_mut(
+                                vec.as_mut_ptr() as *mut u8,
+                                vec.len() * 4,
+                            ))
+                            .unwrap();
+                            vec.set_len(word_count);
+                        }
+                        Some(Cow::Owned(vec))
+                    } else {
+                        None
+                    }
+                });
+                let dxil = data.iter().find_map(|a| {
+                    if a.ends_with(".dxil") {
+                        let vec = std::fs::read(dir.join(a)).unwrap();
+                        Some(Cow::Owned(vec))
+                    } else {
+                        None
+                    }
+                });
+                let hlsl = data.iter().find_map(|a| {
+                    if a.ends_with(".hlsl") {
+                        let code = fs::read_to_string(dir.join(a)).unwrap();
+                        Some(Cow::Owned(code))
+                    } else {
+                        None
+                    }
+                });
+                let msl = data.iter().find_map(|a| {
+                    if a.ends_with(".msl") {
+                        let code = fs::read_to_string(dir.join(a)).unwrap();
+                        Some(Cow::Owned(code))
+                    } else {
+                        None
+                    }
+                });
+                let glsl = data.iter().find_map(|a| {
+                    if a.ends_with(".glsl") {
+                        let code = fs::read_to_string(dir.join(a)).unwrap();
+                        Some(Cow::Owned(code))
+                    } else {
+                        None
+                    }
+                });
+                let wgsl = data.iter().find_map(|a| {
+                    if a.ends_with(".wgsl") {
+                        let code = fs::read_to_string(dir.join(a)).unwrap();
+                        Some(Cow::Owned(code))
+                    } else {
+                        None
+                    }
+                });
+                let desc = wgt::CreateShaderModuleDescriptorPassthrough {
+                    entry_point,
+                    label,
+                    num_workgroups,
+                    reflection,
+                    runtime_checks,
+
+                    spirv,
+                    dxil,
+                    hlsl,
+                    msl,
+                    glsl,
+                    wgsl,
+                };
+                let (_, error) = unsafe {
+                    self.device_create_shader_module_passthrough(device, &desc, Some(id))
+                };
+                if let Some(e) = error {
+                    println!("shader compilation error: {e}");
+                }
+            }
             Action::DestroyShaderModule(id) => {
                 self.shader_module_drop(id);
             }

wgpu-core/src/device/global.rs

@@ -979,36 +979,28 @@ impl Global {
 
             #[cfg(feature = "trace")]
             if let Some(ref mut trace) = *device.trace.lock() {
-                let data = trace.make_binary(desc.trace_binary_ext(), desc.trace_data());
-                trace.add(trace::Action::CreateShaderModule {
+                let mut file_names = Vec::new();
+                for (data, ext) in [
+                    (desc.spirv.as_ref().map(|a| bytemuck::cast_slice(a)), "spv"),
+                    (desc.dxil.as_deref(), "dxil"),
+                    (desc.hlsl.as_ref().map(|a| a.as_bytes()), "hlsl"),
+                    (desc.msl.as_ref().map(|a| a.as_bytes()), "msl"),
+                    (desc.glsl.as_ref().map(|a| a.as_bytes()), "glsl"),
+                    (desc.wgsl.as_ref().map(|a| a.as_bytes()), "wgsl"),
+                ] {
+                    if let Some(data) = data {
+                        file_names.push(trace.make_binary(ext, data));
+                    }
+                }
+                trace.add(trace::Action::CreateShaderModulePassthrough {
                     id: fid.id(),
-                    desc: match desc {
-                        pipeline::ShaderModuleDescriptorPassthrough::SpirV(inner) => {
-                            pipeline::ShaderModuleDescriptor {
-                                label: inner.label.clone(),
-                                runtime_checks: wgt::ShaderRuntimeChecks::unchecked(),
-                            }
-                        }
-                        pipeline::ShaderModuleDescriptorPassthrough::Msl(inner) => {
-                            pipeline::ShaderModuleDescriptor {
-                                label: inner.label.clone(),
-                                runtime_checks: wgt::ShaderRuntimeChecks::unchecked(),
-                            }
-                        }
-                        pipeline::ShaderModuleDescriptorPassthrough::Dxil(inner) => {
-                            pipeline::ShaderModuleDescriptor {
-                                label: inner.label.clone(),
-                                runtime_checks: wgt::ShaderRuntimeChecks::unchecked(),
-                            }
-                        }
-                        pipeline::ShaderModuleDescriptorPassthrough::Hlsl(inner) => {
-                            pipeline::ShaderModuleDescriptor {
-                                label: inner.label.clone(),
-                                runtime_checks: wgt::ShaderRuntimeChecks::unchecked(),
-                            }
-                        }
-                    },
-                    data,
+                    data: file_names,
+
+                    entry_point: desc.entry_point.clone(),
+                    label: desc.label.clone(),
+                    num_workgroups: desc.num_workgroups,
+                    reflection: desc.reflection.clone(),
+                    runtime_checks: desc.runtime_checks,
                 });
             };
 
@@ -1023,7 +1015,7 @@ impl Global {
             return (id, None);
         };
 
-        let id = fid.assign(Fallible::Invalid(Arc::new(desc.label().to_string())));
+        let id = fid.assign(Fallible::Invalid(Arc::new(desc.label.to_string())));
         (id, Some(error))
     }
 

wgpu-core/src/device/resource.rs

@@ -1797,39 +1797,58 @@ impl Device {
         descriptor: &pipeline::ShaderModuleDescriptorPassthrough<'a>,
     ) -> Result<Arc<pipeline::ShaderModule>, pipeline::CreateShaderModuleError> {
         self.check_is_valid()?;
-        let hal_shader = match descriptor {
-            pipeline::ShaderModuleDescriptorPassthrough::SpirV(inner) => {
-                self.require_features(wgt::Features::SPIRV_SHADER_PASSTHROUGH)?;
-                hal::ShaderInput::SpirV(&inner.source)
-            }
-            pipeline::ShaderModuleDescriptorPassthrough::Msl(inner) => {
-                self.require_features(wgt::Features::MSL_SHADER_PASSTHROUGH)?;
-                hal::ShaderInput::Msl {
-                    shader: inner.source.to_string(),
-                    entry_point: inner.entry_point.to_string(),
-                    num_workgroups: inner.num_workgroups,
-                }
-            }
-            pipeline::ShaderModuleDescriptorPassthrough::Dxil(inner) => {
-                self.require_features(wgt::Features::HLSL_DXIL_SHADER_PASSTHROUGH)?;
-                hal::ShaderInput::Dxil {
-                    shader: inner.source,
-                    entry_point: inner.entry_point.clone(),
-                    num_workgroups: inner.num_workgroups,
+        self.require_features(wgt::Features::EXPERIMENTAL_PASSTHROUGH_SHADERS)?;
+
+        // TODO: when we get to use if-let chains, this will be a little nicer!
+
+        let hal_shader = match self.adapter.backend() {
+            wgt::Backend::Vulkan => hal::ShaderInput::SpirV(
+                descriptor
+                    .spirv
+                    .as_ref()
+                    .ok_or(pipeline::CreateShaderModuleError::NotCompiledForBackend)?,
+            ),
+            wgt::Backend::Dx12 => {
+                if let Some(dxil) = &descriptor.dxil {
+                    hal::ShaderInput::Dxil {
+                        shader: dxil,
+                        entry_point: descriptor.entry_point.clone(),
+                        num_workgroups: descriptor.num_workgroups,
+                    }
+                } else if let Some(hlsl) = &descriptor.hlsl {
+                    hal::ShaderInput::Hlsl {
+                        shader: hlsl,
+                        entry_point: descriptor.entry_point.clone(),
+                        num_workgroups: descriptor.num_workgroups,
+                    }
+                } else {
+                    return Err(pipeline::CreateShaderModuleError::NotCompiledForBackend);
                 }
             }
-            pipeline::ShaderModuleDescriptorPassthrough::Hlsl(inner) => {
-                self.require_features(wgt::Features::HLSL_DXIL_SHADER_PASSTHROUGH)?;
-                hal::ShaderInput::Hlsl {
-                    shader: inner.source,
-                    entry_point: inner.entry_point.clone(),
-                    num_workgroups: inner.num_workgroups,
-                }
+            wgt::Backend::Metal => hal::ShaderInput::Msl {
+                shader: descriptor
+                    .msl
+                    .as_ref()
+                    .ok_or(pipeline::CreateShaderModuleError::NotCompiledForBackend)?,
+                entry_point: descriptor.entry_point.clone(),
+                num_workgroups: descriptor.num_workgroups,
+            },
+            wgt::Backend::Gl => hal::ShaderInput::Glsl {
+                shader: descriptor
+                    .glsl
+                    .as_ref()
+                    .ok_or(pipeline::CreateShaderModuleError::NotCompiledForBackend)?,
+                entry_point: descriptor.entry_point.clone(),
+                num_workgroups: descriptor.num_workgroups,
+            },
+            wgt::Backend::Noop => {
+                return Err(pipeline::CreateShaderModuleError::NotCompiledForBackend)
             }
+            wgt::Backend::BrowserWebGpu => unreachable!(),
         };
 
         let hal_desc = hal::ShaderModuleDescriptor {
-            label: descriptor.label().to_hal(self.instance_flags),
+            label: descriptor.label.to_hal(self.instance_flags),
             runtime_checks: wgt::ShaderRuntimeChecks::unchecked(),
         };
 
@@ -1852,7 +1871,7 @@ impl Device {
             raw: ManuallyDrop::new(raw),
             device: self.clone(),
             interface: None,
-            label: descriptor.label().to_string(),
+            label: descriptor.label.to_string(),
         };
 
         Ok(Arc::new(module))

wgpu-core/src/device/trace.rs

@@ -86,6 +86,16 @@ pub enum Action<'a> {
         desc: crate::pipeline::ShaderModuleDescriptor<'a>,
         data: FileName,
     },
+    CreateShaderModulePassthrough {
+        id: id::ShaderModuleId,
+        data: Vec<FileName>,
+
+        entry_point: String,
+        label: crate::Label<'a>,
+        num_workgroups: (u32, u32, u32),
+        reflection: Option<wgt::ShaderModuleReflection>,
+        runtime_checks: wgt::ShaderRuntimeChecks,
+    },
     DestroyShaderModule(id::ShaderModuleId),
     CreateComputePipeline {
         id: id::ComputePipelineId,

wgpu-core/src/pipeline.rs

@@ -130,6 +130,8 @@ pub enum CreateShaderModuleError {
         group: u32,
         limit: u32,
     },
+    #[error("Generic shader passthrough does not contain any code compatible with this backend.")]
+    NotCompiledForBackend,
 }
 
 impl WebGpuError for CreateShaderModuleError {
@@ -147,6 +149,7 @@ impl WebGpuError for CreateShaderModuleError {
             Self::ParsingGlsl(..) => return ErrorType::Validation,
             #[cfg(feature = "spirv")]
             Self::ParsingSpirV(..) => return ErrorType::Validation,
+            Self::NotCompiledForBackend => return ErrorType::Validation,
         };
         e.webgpu_error_type()
     }

wgpu-hal/src/dx12/adapter.rs

@@ -361,7 +361,8 @@ impl super::Adapter {
             | wgt::Features::DUAL_SOURCE_BLENDING
             | wgt::Features::TEXTURE_FORMAT_NV12
             | wgt::Features::FLOAT32_FILTERABLE
-            | wgt::Features::TEXTURE_ATOMIC;
+            | wgt::Features::TEXTURE_ATOMIC
+            | wgt::Features::EXPERIMENTAL_PASSTHROUGH_SHADERS;
 
         //TODO: in order to expose this, we need to run a compute shader
         // that extract the necessary statistics out of the D3D12 result.

wgpu-hal/src/dx12/device.rs

@@ -1700,12 +1700,6 @@ impl crate::Device for super::Device {
                 raw_name,
                 runtime_checks: desc.runtime_checks,
             }),
-            crate::ShaderInput::SpirV(_) => {
-                panic!("SPIRV_SHADER_PASSTHROUGH is not enabled for this backend")
-            }
-            crate::ShaderInput::Msl { .. } => {
-                panic!("MSL_SHADER_PASSTHROUGH is not enabled for this backend")
-            }
             crate::ShaderInput::Dxil {
                 shader,
                 entry_point,
@@ -1732,6 +1726,11 @@ impl crate::Device for super::Device {
                 raw_name,
                 runtime_checks: desc.runtime_checks,
             }),
+            crate::ShaderInput::SpirV(_)
+            | crate::ShaderInput::Msl { .. }
+            | crate::ShaderInput::Glsl { .. } => {
+                unreachable!()
+            }
         }
     }
     unsafe fn destroy_shader_module(&self, _module: super::ShaderModule) {