Adding upstream version 124.0.1.upstream/124.0.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

5 files changed, 3604 insertions, 0 deletions

diff --git a/gfx/wgpu_bindings/src/client.rs b/gfx/wgpu_bindings/src/client.rs
new file mode 100644
index 0000000000..bf53a8c871
--- /dev/null
+++ b/gfx/wgpu_bindings/src/client.rs
@@ -0,0 +1,1361 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use crate::{
+    cow_label, error::HasErrorBufferType, wgpu_string, AdapterInformation, ByteBuf,
+    CommandEncoderAction, DeviceAction, DropAction, ImageDataLayout, ImplicitLayout,
+    QueueWriteAction, RawString, TextureAction,
+};
+
+use crate::SwapChainId;
+
+use wgc::{id, identity::IdentityManager};
+use wgt::{Backend, TextureFormat};
+
+pub use wgc::command::{compute_ffi::*, render_ffi::*};
+use wgc::id::markers;
+
+use parking_lot::Mutex;
+
+use nsstring::{nsACString, nsString};
+
+use std::{borrow::Cow, ptr};
+
+// we can't call `from_raw_parts` unconditionally because the caller
+// may not even have a valid pointer (e.g. NULL) if the `length` is zero.
+fn make_slice<'a, T>(pointer: *const T, length: usize) -> &'a [T] {
+    if length == 0 {
+        &[]
+    } else {
+        unsafe { std::slice::from_raw_parts(pointer, length) }
+    }
+}
+
+fn make_byte_buf<T: serde::Serialize>(data: &T) -> ByteBuf {
+    let vec = bincode::serialize(data).unwrap();
+    ByteBuf::from_vec(vec)
+}
+
+#[repr(C)]
+pub struct ProgrammableStageDescriptor {
+    module: id::ShaderModuleId,
+    entry_point: RawString,
+}
+
+impl ProgrammableStageDescriptor {
+    fn to_wgpu(&self) -> wgc::pipeline::ProgrammableStageDescriptor {
+        wgc::pipeline::ProgrammableStageDescriptor {
+            module: self.module,
+            entry_point: cow_label(&self.entry_point).unwrap(),
+        }
+    }
+}
+
+#[repr(C)]
+pub struct ComputePipelineDescriptor<'a> {
+    label: Option<&'a nsACString>,
+    layout: Option<id::PipelineLayoutId>,
+    stage: ProgrammableStageDescriptor,
+}
+
+#[repr(C)]
+pub struct VertexBufferLayout {
+    array_stride: wgt::BufferAddress,
+    step_mode: wgt::VertexStepMode,
+    attributes: *const wgt::VertexAttribute,
+    attributes_length: usize,
+}
+
+#[repr(C)]
+pub struct VertexState {
+    stage: ProgrammableStageDescriptor,
+    buffers: *const VertexBufferLayout,
+    buffers_length: usize,
+}
+
+impl VertexState {
+    fn to_wgpu(&self) -> wgc::pipeline::VertexState {
+        let buffer_layouts = make_slice(self.buffers, self.buffers_length)
+            .iter()
+            .map(|vb| wgc::pipeline::VertexBufferLayout {
+                array_stride: vb.array_stride,
+                step_mode: vb.step_mode,
+                attributes: Cow::Borrowed(make_slice(vb.attributes, vb.attributes_length)),
+            })
+            .collect();
+        wgc::pipeline::VertexState {
+            stage: self.stage.to_wgpu(),
+            buffers: Cow::Owned(buffer_layouts),
+        }
+    }
+}
+
+#[repr(C)]
+pub struct ColorTargetState<'a> {
+    format: wgt::TextureFormat,
+    blend: Option<&'a wgt::BlendState>,
+    write_mask: wgt::ColorWrites,
+}
+
+#[repr(C)]
+pub struct FragmentState<'a> {
+    stage: ProgrammableStageDescriptor,
+    targets: *const ColorTargetState<'a>,
+    targets_length: usize,
+}
+
+impl FragmentState<'_> {
+    fn to_wgpu(&self) -> wgc::pipeline::FragmentState {
+        let color_targets = make_slice(self.targets, self.targets_length)
+            .iter()
+            .map(|ct| {
+                Some(wgt::ColorTargetState {
+                    format: ct.format,
+                    blend: ct.blend.cloned(),
+                    write_mask: ct.write_mask,
+                })
+            })
+            .collect();
+        wgc::pipeline::FragmentState {
+            stage: self.stage.to_wgpu(),
+            targets: Cow::Owned(color_targets),
+        }
+    }
+}
+
+#[repr(C)]
+pub struct PrimitiveState<'a> {
+    topology: wgt::PrimitiveTopology,
+    strip_index_format: Option<&'a wgt::IndexFormat>,
+    front_face: wgt::FrontFace,
+    cull_mode: Option<&'a wgt::Face>,
+    polygon_mode: wgt::PolygonMode,
+    unclipped_depth: bool,
+}
+
+impl PrimitiveState<'_> {
+    fn to_wgpu(&self) -> wgt::PrimitiveState {
+        wgt::PrimitiveState {
+            topology: self.topology,
+            strip_index_format: self.strip_index_format.cloned(),
+            front_face: self.front_face.clone(),
+            cull_mode: self.cull_mode.cloned(),
+            polygon_mode: self.polygon_mode,
+            unclipped_depth: self.unclipped_depth,
+            conservative: false,
+        }
+    }
+}
+
+#[repr(C)]
+pub struct RenderPipelineDescriptor<'a> {
+    label: Option<&'a nsACString>,
+    layout: Option<id::PipelineLayoutId>,
+    vertex: &'a VertexState,
+    primitive: PrimitiveState<'a>,
+    fragment: Option<&'a FragmentState<'a>>,
+    depth_stencil: Option<&'a wgt::DepthStencilState>,
+    multisample: wgt::MultisampleState,
+}
+
+#[repr(C)]
+pub enum RawTextureSampleType {
+    Float,
+    UnfilterableFloat,
+    Uint,
+    Sint,
+    Depth,
+}
+
+#[repr(C)]
+pub enum RawBindingType {
+    UniformBuffer,
+    StorageBuffer,
+    ReadonlyStorageBuffer,
+    Sampler,
+    SampledTexture,
+    ReadonlyStorageTexture,
+    WriteonlyStorageTexture,
+}
+
+#[repr(C)]
+pub struct BindGroupLayoutEntry<'a> {
+    binding: u32,
+    visibility: wgt::ShaderStages,
+    ty: RawBindingType,
+    has_dynamic_offset: bool,
+    min_binding_size: Option<wgt::BufferSize>,
+    view_dimension: Option<&'a wgt::TextureViewDimension>,
+    texture_sample_type: Option<&'a RawTextureSampleType>,
+    multisampled: bool,
+    storage_texture_format: Option<&'a wgt::TextureFormat>,
+    sampler_filter: bool,
+    sampler_compare: bool,
+}
+
+#[repr(C)]
+pub struct BindGroupLayoutDescriptor<'a> {
+    label: Option<&'a nsACString>,
+    entries: *const BindGroupLayoutEntry<'a>,
+    entries_length: usize,
+}
+
+#[repr(C)]
+#[derive(Debug)]
+pub struct BindGroupEntry {
+    binding: u32,
+    buffer: Option<id::BufferId>,
+    offset: wgt::BufferAddress,
+    size: Option<wgt::BufferSize>,
+    sampler: Option<id::SamplerId>,
+    texture_view: Option<id::TextureViewId>,
+}
+
+#[repr(C)]
+pub struct BindGroupDescriptor<'a> {
+    label: Option<&'a nsACString>,
+    layout: id::BindGroupLayoutId,
+    entries: *const BindGroupEntry,
+    entries_length: usize,
+}
+
+#[repr(C)]
+pub struct PipelineLayoutDescriptor<'a> {
+    label: Option<&'a nsACString>,
+    bind_group_layouts: *const id::BindGroupLayoutId,
+    bind_group_layouts_length: usize,
+}
+
+#[repr(C)]
+pub struct SamplerDescriptor<'a> {
+    label: Option<&'a nsACString>,
+    address_modes: [wgt::AddressMode; 3],
+    mag_filter: wgt::FilterMode,
+    min_filter: wgt::FilterMode,
+    mipmap_filter: wgt::FilterMode,
+    lod_min_clamp: f32,
+    lod_max_clamp: f32,
+    compare: Option<&'a wgt::CompareFunction>,
+    anisotropy_clamp: Option<&'a u16>,
+}
+
+#[repr(C)]
+pub struct TextureViewDescriptor<'a> {
+    label: Option<&'a nsACString>,
+    format: Option<&'a wgt::TextureFormat>,
+    dimension: Option<&'a wgt::TextureViewDimension>,
+    aspect: wgt::TextureAspect,
+    base_mip_level: u32,
+    mip_level_count: Option<&'a u32>,
+    base_array_layer: u32,
+    array_layer_count: Option<&'a u32>,
+}
+
+#[repr(C)]
+pub struct RenderBundleEncoderDescriptor<'a> {
+    label: Option<&'a nsACString>,
+    color_formats: *const wgt::TextureFormat,
+    color_formats_length: usize,
+    depth_stencil_format: Option<&'a wgt::TextureFormat>,
+    depth_read_only: bool,
+    stencil_read_only: bool,
+    sample_count: u32,
+}
+
+#[derive(Debug)]
+struct IdentityHub {
+    adapters: IdentityManager<markers::Adapter>,
+    devices: IdentityManager<markers::Device>,
+    buffers: IdentityManager<markers::Buffer>,
+    command_buffers: IdentityManager<markers::CommandBuffer>,
+    render_bundles: IdentityManager<markers::RenderBundle>,
+    bind_group_layouts: IdentityManager<markers::BindGroupLayout>,
+    pipeline_layouts: IdentityManager<markers::PipelineLayout>,
+    bind_groups: IdentityManager<markers::BindGroup>,
+    shader_modules: IdentityManager<markers::ShaderModule>,
+    compute_pipelines: IdentityManager<markers::ComputePipeline>,
+    render_pipelines: IdentityManager<markers::RenderPipeline>,
+    textures: IdentityManager<markers::Texture>,
+    texture_views: IdentityManager<markers::TextureView>,
+    samplers: IdentityManager<markers::Sampler>,
+}
+
+impl Default for IdentityHub {
+    fn default() -> Self {
+        IdentityHub {
+            adapters: IdentityManager::new(),
+            devices: IdentityManager::new(),
+            buffers: IdentityManager::new(),
+            command_buffers: IdentityManager::new(),
+            render_bundles: IdentityManager::new(),
+            bind_group_layouts: IdentityManager::new(),
+            pipeline_layouts: IdentityManager::new(),
+            bind_groups: IdentityManager::new(),
+            shader_modules: IdentityManager::new(),
+            compute_pipelines: IdentityManager::new(),
+            render_pipelines: IdentityManager::new(),
+            textures: IdentityManager::new(),
+            texture_views: IdentityManager::new(),
+            samplers: IdentityManager::new(),
+        }
+    }
+}
+
+impl ImplicitLayout<'_> {
+    fn new(identities: &mut IdentityHub, backend: Backend) -> Self {
+        ImplicitLayout {
+            pipeline: identities.pipeline_layouts.process(backend),
+            bind_groups: Cow::Owned(
+                (0..8) // hal::MAX_BIND_GROUPS
+                    .map(|_| Some(identities.bind_group_layouts.process(backend)))
+                    .collect(),
+            ),
+        }
+    }
+}
+
+#[derive(Debug, Default)]
+struct Identities {
+    vulkan: IdentityHub,
+    #[cfg(any(target_os = "ios", target_os = "macos"))]
+    metal: IdentityHub,
+    #[cfg(windows)]
+    dx12: IdentityHub,
+}
+
+impl Identities {
+    fn select(&mut self, backend: Backend) -> &mut IdentityHub {
+        match backend {
+            Backend::Vulkan => &mut self.vulkan,
+            #[cfg(any(target_os = "ios", target_os = "macos"))]
+            Backend::Metal => &mut self.metal,
+            #[cfg(windows)]
+            Backend::Dx12 => &mut self.dx12,
+            _ => panic!("Unexpected backend: {:?}", backend),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct Client {
+    identities: Mutex<Identities>,
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wgpu_client_drop_action(client: &mut Client, byte_buf: &ByteBuf) {
+    let mut cursor = std::io::Cursor::new(byte_buf.as_slice());
+    let mut identities = client.identities.lock();
+    while let Ok(action) = bincode::deserialize_from(&mut cursor) {
+        match action {
+            DropAction::Adapter(id) => identities.select(id.backend()).adapters.free(id),
+            DropAction::Device(id) => identities.select(id.backend()).devices.free(id),
+            DropAction::ShaderModule(id) => identities.select(id.backend()).shader_modules.free(id),
+            DropAction::PipelineLayout(id) => {
+                identities.select(id.backend()).pipeline_layouts.free(id)
+            }
+            DropAction::BindGroupLayout(id) => {
+                identities.select(id.backend()).bind_group_layouts.free(id)
+            }
+            DropAction::BindGroup(id) => identities.select(id.backend()).bind_groups.free(id),
+            DropAction::CommandBuffer(id) => {
+                identities.select(id.backend()).command_buffers.free(id)
+            }
+            DropAction::RenderBundle(id) => identities.select(id.backend()).render_bundles.free(id),
+            DropAction::RenderPipeline(id) => {
+                identities.select(id.backend()).render_pipelines.free(id)
+            }
+            DropAction::ComputePipeline(id) => {
+                identities.select(id.backend()).compute_pipelines.free(id)
+            }
+            DropAction::Buffer(id) => identities.select(id.backend()).buffers.free(id),
+            DropAction::Texture(id) => identities.select(id.backend()).textures.free(id),
+            DropAction::TextureView(id) => identities.select(id.backend()).texture_views.free(id),
+            DropAction::Sampler(id) => identities.select(id.backend()).samplers.free(id),
+        }
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn wgpu_client_kill_device_id(client: &Client, id: id::DeviceId) {
+    client
+        .identities
+        .lock()
+        .select(id.backend())
+        .devices
+        .free(id)
+}
+
+#[repr(C)]
+#[derive(Debug)]
+pub struct Infrastructure {
+    pub client: *mut Client,
+    pub error: *const u8,
+}
+
+#[no_mangle]
+pub extern "C" fn wgpu_client_new() -> Infrastructure {
+    log::info!("Initializing WGPU client");
+    let client = Box::new(Client {
+        identities: Mutex::new(Identities::default()),
+    });
+    Infrastructure {
+        client: Box::into_raw(client),
+        error: ptr::null(),
+    }
+}
+
+/// # Safety
+///
+/// This function is unsafe because improper use may lead to memory
+/// problems. For example, a double-free may occur if the function is called
+/// twice on the same raw pointer.
+#[no_mangle]
+pub unsafe extern "C" fn wgpu_client_delete(client: *mut Client) {
+    log::info!("Terminating WGPU client");
+    let _client = Box::from_raw(client);
+}
+
+/// # Safety
+///
+/// This function is unsafe as there is no guarantee that the given pointer is
+/// valid for `id_length` elements.
+#[no_mangle]
+pub unsafe extern "C" fn wgpu_client_make_adapter_ids(
+    client: &Client,
+    ids: *mut id::AdapterId,
+    id_length: usize,
+) -> usize {
+    let identities = client.identities.lock();
+    assert_ne!(id_length, 0);
+    let mut ids = std::slice::from_raw_parts_mut(ids, id_length).iter_mut();
+
+    *ids.next().unwrap() = identities.vulkan.adapters.process(Backend::Vulkan);
+
+    #[cfg(any(target_os = "ios", target_os = "macos"))]
+    {
+        *ids.next().unwrap() = identities.metal.adapters.process(Backend::Metal);
+    }
+    #[cfg(windows)]
+    {
+        *ids.next().unwrap() = identities.dx12.adapters.process(Backend::Dx12);
+    }
+
+    id_length - ids.len()
+}
+
+#[no_mangle]
+pub extern "C" fn wgpu_client_fill_default_limits(limits: &mut wgt::Limits) {
+    *limits = wgt::Limits::default();
+}
+
+#[no_mangle]
+pub extern "C" fn wgpu_client_adapter_extract_info(
+    byte_buf: &ByteBuf,
+    info: &mut AdapterInformation<nsString>,
+) {
+    let AdapterInformation {
+        backend,
+        device_type,
+        device,
+        driver_info,
+        driver,
+        features,
+        id,
+        limits,
+        name,
+        vendor,
+    } = bincode::deserialize::<AdapterInformation<String>>(unsafe { byte_buf.as_slice() }).unwrap();
+
+    let nss = |s: &str| {
+        let mut ns_string = nsString::new();
+        ns_string.assign_str(s);
+        ns_string
+    };
+    *info = AdapterInformation {
+        backend,
+        device_type,
+        device,
+        driver_info: nss(&driver_info),
+        driver: nss(&driver),
+        features,
+        id,
+        limits,
+        name: nss(&name),
+        vendor,
+    };
+}
+
+#[no_mangle]
+pub extern "C" fn wgpu_client_serialize_device_descriptor(
+    desc: &wgt::DeviceDescriptor<Option<&nsACString>>,
+    bb: &mut ByteBuf,
+) {
+    let label = wgpu_string(desc.label);
+    *bb = make_byte_buf(&desc.map_label(|_| label));
+}
+
+#[no_mangle]
+pub extern "C" fn wgpu_client_make_device_id(
+    client: &Client,
+    adapter_id: id::AdapterId,
+) -> id::DeviceId {
+    let backend = adapter_id.backend();
+    client
+        .identities
+        .lock()
+        .select(backend)
+        .devices
+        .process(backend)
+}
+
+#[no_mangle]
+pub extern "C" fn wgpu_client_make_buffer_id(
+    client: &Client,
+    device_id: id::DeviceId,
+) -> id::BufferId {
+    let backend = device_id.backend();
+    client
+        .identities
+        .lock()
+        .select(backend)
+        .buffers
+        .process(backend)
+}
+
+#[no_mangle]
+pub extern "C" fn wgpu_client_create_texture(
+    client: &Client,
+    device_id: id::DeviceId,
+    desc: &wgt::TextureDescriptor<Option<&nsACString>, crate::FfiSlice<TextureFormat>>,
+    swap_chain_id: Option<&SwapChainId>,
+    bb: &mut ByteBuf,
+) -> id::TextureId {
+    let label = wgpu_string(desc.label);
+
+    let backend = device_id.backend();
+    let id = client
+        .identities
+        .lock()
+        .select(backend)
+        .textures
+        .process(backend);
+
+    let view_formats = unsafe { desc.view_formats.as_slice() }.to_vec();
+
+    let action = DeviceAction::CreateTexture(
+        id,
+        desc.map_label_and_view_formats(|_| label, |_| view_formats),
+        swap_chain_id.copied(),
+    );
+    *bb = make_byte_buf(&action);
+
+    id
+}
+
+#[no_mangle]
+pub extern "C" fn wgpu_client_create_texture_view(
+    client: &Client,
+    device_id: id::DeviceId,
+    desc: &TextureViewDescriptor,
+    bb: &mut ByteBuf,
+) -> id::TextureViewId {
+    let label = wgpu_string(desc.label);
+
+    let backend = device_id.backend();
+    let id = client
+        .identities
+        .lock()
+        .select(backend)
+        .texture_views
+        .process(backend);
+
+    let wgpu_desc = wgc::resource::TextureViewDescriptor {
+        label,
+        format: desc.format.cloned(),
+        dimension: desc.dimension.cloned(),
+        range: wgt::ImageSubresourceRange {
+            aspect: desc.aspect,
+            base_mip_level: desc.base_mip_level,
+            mip_level_count: desc.mip_level_count.map(|ptr| *ptr),
+            base_array_layer: desc.base_array_layer,
+            array_layer_count: desc.array_layer_count.map(|ptr| *ptr),
+        },
+    };
+
+    let action = TextureAction::CreateView(id, wgpu_desc);
+    *bb = make_byte_buf(&action);
+    id
+}
+
+#[no_mangle]
+pub extern "C" fn wgpu_client_create_sampler(
+    client: &Client,
+    device_id: id::DeviceId,
+    desc: &SamplerDescriptor,
+    bb: &mut ByteBuf,
+) -> id::SamplerId {
+    let label = wgpu_string(desc.label);
+
+    let backend = device_id.backend();
+    let id = client
+        .identities
+        .lock()
+        .select(backend)
+        .samplers
+        .process(backend);
+
+    let wgpu_desc = wgc::resource::SamplerDescriptor {
+        label,
+        address_modes: desc.address_modes,
+        mag_filter: desc.mag_filter,
+        min_filter: desc.min_filter,
+        mipmap_filter: desc.mipmap_filter,
+        lod_min_clamp: desc.lod_min_clamp,
+        lod_max_clamp: desc.lod_max_clamp,
+        compare: desc.compare.cloned(),
+        anisotropy_clamp: *desc.anisotropy_clamp.unwrap_or(&1),
+        border_color: None,
+    };
+    let action = DeviceAction::CreateSampler(id, wgpu_desc);
+    *bb = make_byte_buf(&action);
+    id
+}
+
+#[no_mangle]
+pub extern "C" fn wgpu_client_make_encoder_id(
+    client: &Client,
+    device_id: id::DeviceId,
+) -> id::CommandEncoderId {
+    let backend = device_id.backend();
+    client
+        .identities
+        .lock()
+        .select(backend)
+        .command_buffers
+        .process(backend)
+        .transmute()
+}
+
+#[no_mangle]
+pub extern "C" fn wgpu_client_create_command_encoder(
+    client: &Client,
+    device_id: id::DeviceId,
+    desc: &wgt::CommandEncoderDescriptor<Option<&nsACString>>,
+    bb: &mut ByteBuf,
+) -> id::CommandEncoderId {
+    let label = wgpu_string(desc.label);
+
+    let backend = device_id.backend();
+    let id = client
+        .identities
+        .lock()
+        .select(backend)
+        .command_buffers
+        .process(backend)
+        .transmute();
+
+    let action = DeviceAction::CreateCommandEncoder(id, desc.map_label(|_| label));
+    *bb = make_byte_buf(&action);
+    id
+}
+
+#[no_mangle]
+pub extern "C" fn wgpu_device_create_render_bundle_encoder(
+    device_id: id::DeviceId,
+    desc: &RenderBundleEncoderDescriptor,
+    bb: &mut ByteBuf,
+) -> *mut wgc::command::RenderBundleEncoder {
+    let label = wgpu_string(desc.label);
+
+    let color_formats: Vec<_> = make_slice(desc.color_formats, desc.color_formats_length)
+        .iter()
+        .map(|format| Some(format.clone()))
+        .collect();
+    let descriptor = wgc::command::RenderBundleEncoderDescriptor {
+        label,
+        color_formats: Cow::Owned(color_formats),
+        depth_stencil: desc
+            .depth_stencil_format
+            .map(|&format| wgt::RenderBundleDepthStencil {
+                format,
+                depth_read_only: desc.depth_read_only,
+                stencil_read_only: desc.stencil_read_only,
+            }),
+        sample_count: desc.sample_count,
+        multiview: None,
+    };
+    match wgc::command::RenderBundleEncoder::new(&descriptor, device_id, None) {
+        Ok(encoder) => Box::into_raw(Box::new(encoder)),
+        Err(e) => {
+            let message = format!("Error in `Device::create_render_bundle_encoder`: {}", e);
+            let action = DeviceAction::Error {
+                message,
+                r#type: e.error_type(),
+            };
+            *bb = make_byte_buf(&action);
+            ptr::null_mut()
+        }
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wgpu_render_bundle_encoder_destroy(
+    pass: *mut wgc::command::RenderBundleEncoder,
+) {
+    // The RB encoder is just a boxed Rust struct, it doesn't have any API primitives
+    // associated with it right now, but in the future it will.
+    let _ = Box::from_raw(pass);
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wgpu_client_create_render_bundle(
+    client: &Client,
+    encoder: *mut wgc::command::RenderBundleEncoder,
+    device_id: id::DeviceId,
+    desc: &wgt::RenderBundleDescriptor<Option<&nsACString>>,
+    bb: &mut ByteBuf,
+) -> id::RenderBundleId {
+    let label = wgpu_string(desc.label);
+
+    let backend = device_id.backend();
+    let id = client
+        .identities
+        .lock()
+        .select(backend)
+        .render_bundles
+        .process(backend);
+
+    let action =
+        DeviceAction::CreateRenderBundle(id, *Box::from_raw(encoder), desc.map_label(|_| label));
+    *bb = make_byte_buf(&action);
+    id
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wgpu_client_create_render_bundle_error(
+    client: &Client,
+    device_id: id::DeviceId,
+    label: Option<&nsACString>,
+    bb: &mut ByteBuf,
+) -> id::RenderBundleId {
+    let label = wgpu_string(label);
+
+    let backend = device_id.backend();
+    let id = client
+        .identities
+        .lock()
+        .select(backend)
+        .render_bundles
+        .process(backend);
+
+    let action = DeviceAction::CreateRenderBundleError(id, label);
+    *bb = make_byte_buf(&action);
+    id
+}
+
+#[repr(C)]
+pub struct ComputePassDescriptor<'a> {
+    pub label: Option<&'a nsACString>,
+    pub timestamp_writes: Option<&'a ComputePassTimestampWrites<'a>>,
+}
+
+#[repr(C)]
+pub struct ComputePassTimestampWrites<'a> {
+    pub query_set: id::QuerySetId,
+    pub beginning_of_pass_write_index: Option<&'a u32>,
+    pub end_of_pass_write_index: Option<&'a u32>,
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wgpu_command_encoder_begin_compute_pass(
+    encoder_id: id::CommandEncoderId,
+    desc: &ComputePassDescriptor,
+) -> *mut wgc::command::ComputePass {
+    let &ComputePassDescriptor {
+        label,
+        timestamp_writes,
+    } = desc;
+
+    let label = wgpu_string(label);
+
+    let timestamp_writes = timestamp_writes.map(|tsw| {
+        let &ComputePassTimestampWrites {
+            query_set,
+            beginning_of_pass_write_index,
+            end_of_pass_write_index,
+        } = tsw;
+        let beginning_of_pass_write_index = beginning_of_pass_write_index.cloned();
+        let end_of_pass_write_index = end_of_pass_write_index.cloned();
+        wgc::command::ComputePassTimestampWrites {
+            query_set,
+            beginning_of_pass_write_index,
+            end_of_pass_write_index,
+        }
+    });
+    let timestamp_writes = timestamp_writes.as_ref();
+
+    let pass = wgc::command::ComputePass::new(
+        encoder_id,
+        &wgc::command::ComputePassDescriptor {
+            label,
+            timestamp_writes,
+        },
+    );
+    Box::into_raw(Box::new(pass))
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wgpu_compute_pass_finish(
+    pass: *mut wgc::command::ComputePass,
+    output: &mut ByteBuf,
+) {
+    let command = Box::from_raw(pass).into_command();
+    *output = make_byte_buf(&command);
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wgpu_compute_pass_destroy(pass: *mut wgc::command::ComputePass) {
+    let _ = Box::from_raw(pass);
+}
+
+#[repr(C)]
+pub struct RenderPassDescriptor<'a> {
+    pub label: Option<&'a nsACString>,
+    pub color_attachments: *const wgc::command::RenderPassColorAttachment,
+    pub color_attachments_length: usize,
+    pub depth_stencil_attachment: *const wgc::command::RenderPassDepthStencilAttachment,
+    pub timestamp_writes: Option<&'a RenderPassTimestampWrites<'a>>,
+    pub occlusion_query_set: Option<wgc::id::QuerySetId>,
+}
+
+#[repr(C)]
+pub struct RenderPassTimestampWrites<'a> {
+    pub query_set: wgc::id::QuerySetId,
+    pub beginning_of_pass_write_index: Option<&'a u32>,
+    pub end_of_pass_write_index: Option<&'a u32>,
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wgpu_command_encoder_begin_render_pass(
+    encoder_id: id::CommandEncoderId,
+    desc: &RenderPassDescriptor,
+) -> *mut wgc::command::RenderPass {
+    let &RenderPassDescriptor {
+        label,
+        color_attachments,
+        color_attachments_length,
+        depth_stencil_attachment,
+        timestamp_writes,
+        occlusion_query_set,
+    } = desc;
+
+    let label = wgpu_string(label);
+
+    let timestamp_writes = timestamp_writes.map(|tsw| {
+        let &RenderPassTimestampWrites {
+            query_set,
+            beginning_of_pass_write_index,
+            end_of_pass_write_index,
+        } = tsw;
+        let beginning_of_pass_write_index = beginning_of_pass_write_index.cloned();
+        let end_of_pass_write_index = end_of_pass_write_index.cloned();
+        wgc::command::RenderPassTimestampWrites {
+            query_set,
+            beginning_of_pass_write_index,
+            end_of_pass_write_index,
+        }
+    });
+
+    let timestamp_writes = timestamp_writes.as_ref();
+
+    let color_attachments: Vec<_> = make_slice(color_attachments, color_attachments_length)
+        .iter()
+        .map(|format| Some(format.clone()))
+        .collect();
+    let pass = wgc::command::RenderPass::new(
+        encoder_id,
+        &wgc::command::RenderPassDescriptor {
+            label,
+            color_attachments: Cow::Owned(color_attachments),
+            depth_stencil_attachment: depth_stencil_attachment.as_ref(),
+            timestamp_writes,
+            occlusion_query_set,
+        },
+    );
+    Box::into_raw(Box::new(pass))
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wgpu_render_pass_finish(
+    pass: *mut wgc::command::RenderPass,
+    output: &mut ByteBuf,
+) {
+    let command = Box::from_raw(pass).into_command();
+    *output = make_byte_buf(&command);
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wgpu_render_pass_destroy(pass: *mut wgc::command::RenderPass) {
+    let _ = Box::from_raw(pass);
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wgpu_client_create_bind_group_layout(
+    client: &Client,
+    device_id: id::DeviceId,
+    desc: &BindGroupLayoutDescriptor,
+    bb: &mut ByteBuf,
+) -> id::BindGroupLayoutId {
+    let label = wgpu_string(desc.label);
+
+    let backend = device_id.backend();
+    let id = client
+        .identities
+        .lock()
+        .select(backend)
+        .bind_group_layouts
+        .process(backend);
+
+    let mut entries = Vec::with_capacity(desc.entries_length);
+    for entry in make_slice(desc.entries, desc.entries_length) {
+        entries.push(wgt::BindGroupLayoutEntry {
+            binding: entry.binding,
+            visibility: entry.visibility,
+            count: None,
+            ty: match entry.ty {
+                RawBindingType::UniformBuffer => wgt::BindingType::Buffer {
+                    ty: wgt::BufferBindingType::Uniform,
+                    has_dynamic_offset: entry.has_dynamic_offset,
+                    min_binding_size: entry.min_binding_size,
+                },
+                RawBindingType::StorageBuffer => wgt::BindingType::Buffer {
+                    ty: wgt::BufferBindingType::Storage { read_only: false },
+                    has_dynamic_offset: entry.has_dynamic_offset,
+                    min_binding_size: entry.min_binding_size,
+                },
+                RawBindingType::ReadonlyStorageBuffer => wgt::BindingType::Buffer {
+                    ty: wgt::BufferBindingType::Storage { read_only: true },
+                    has_dynamic_offset: entry.has_dynamic_offset,
+                    min_binding_size: entry.min_binding_size,
+                },
+                RawBindingType::Sampler => wgt::BindingType::Sampler(if entry.sampler_compare {
+                    wgt::SamplerBindingType::Comparison
+                } else if entry.sampler_filter {
+                    wgt::SamplerBindingType::Filtering
+                } else {
+                    wgt::SamplerBindingType::NonFiltering
+                }),
+                RawBindingType::SampledTexture => wgt::BindingType::Texture {
+                    //TODO: the spec has a bug here
+                    view_dimension: *entry
+                        .view_dimension
+                        .unwrap_or(&wgt::TextureViewDimension::D2),
+                    sample_type: match entry.texture_sample_type {
+                        None | Some(RawTextureSampleType::Float) => {
+                            wgt::TextureSampleType::Float { filterable: true }
+                        }
+                        Some(RawTextureSampleType::UnfilterableFloat) => {
+                            wgt::TextureSampleType::Float { filterable: false }
+                        }
+                        Some(RawTextureSampleType::Uint) => wgt::TextureSampleType::Uint,
+                        Some(RawTextureSampleType::Sint) => wgt::TextureSampleType::Sint,
+                        Some(RawTextureSampleType::Depth) => wgt::TextureSampleType::Depth,
+                    },
+                    multisampled: entry.multisampled,
+                },
+                RawBindingType::ReadonlyStorageTexture => wgt::BindingType::StorageTexture {
+                    access: wgt::StorageTextureAccess::ReadOnly,
+                    view_dimension: *entry.view_dimension.unwrap(),
+                    format: *entry.storage_texture_format.unwrap(),
+                },
+                RawBindingType::WriteonlyStorageTexture => wgt::BindingType::StorageTexture {
+                    access: wgt::StorageTextureAccess::WriteOnly,
+                    view_dimension: *entry.view_dimension.unwrap(),
+                    format: *entry.storage_texture_format.unwrap(),
+                },
+            },
+        });
+    }
+    let wgpu_desc = wgc::binding_model::BindGroupLayoutDescriptor {
+        label,
+        entries: Cow::Owned(entries),
+    };
+
+    let action = DeviceAction::CreateBindGroupLayout(id, wgpu_desc);
+    *bb = make_byte_buf(&action);
+    id
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wgpu_client_render_pipeline_get_bind_group_layout(
+    client: &Client,
+    pipeline_id: id::RenderPipelineId,
+    index: u32,
+    bb: &mut ByteBuf,
+) -> id::BindGroupLayoutId {
+    let backend = pipeline_id.backend();
+    let bgl_id = client
+        .identities
+        .lock()
+        .select(backend)
+        .bind_group_layouts
+        .process(backend);
+
+    let action = DeviceAction::RenderPipelineGetBindGroupLayout(pipeline_id, index, bgl_id);
+    *bb = make_byte_buf(&action);
+
+    bgl_id
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wgpu_client_compute_pipeline_get_bind_group_layout(
+    client: &Client,
+    pipeline_id: id::ComputePipelineId,
+    index: u32,
+    bb: &mut ByteBuf,
+) -> id::BindGroupLayoutId {
+    let backend = pipeline_id.backend();
+    let bgl_id = client
+        .identities
+        .lock()
+        .select(backend)
+        .bind_group_layouts
+        .process(backend);
+
+    let action = DeviceAction::ComputePipelineGetBindGroupLayout(pipeline_id, index, bgl_id);
+    *bb = make_byte_buf(&action);
+
+    bgl_id
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wgpu_client_create_pipeline_layout(
+    client: &Client,
+    device_id: id::DeviceId,
+    desc: &PipelineLayoutDescriptor,
+    bb: &mut ByteBuf,
+) -> id::PipelineLayoutId {
+    let label = wgpu_string(desc.label);
+
+    let backend = device_id.backend();
+    let id = client
+        .identities
+        .lock()
+        .select(backend)
+        .pipeline_layouts
+        .process(backend);
+
+    let wgpu_desc = wgc::binding_model::PipelineLayoutDescriptor {
+        label,
+        bind_group_layouts: Cow::Borrowed(make_slice(
+            desc.bind_group_layouts,
+            desc.bind_group_layouts_length,
+        )),
+        push_constant_ranges: Cow::Borrowed(&[]),
+    };
+
+    let action = DeviceAction::CreatePipelineLayout(id, wgpu_desc);
+    *bb = make_byte_buf(&action);
+    id
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wgpu_client_create_bind_group(
+    client: &Client,
+    device_id: id::DeviceId,
+    desc: &BindGroupDescriptor,
+    bb: &mut ByteBuf,
+) -> id::BindGroupId {
+    let label = wgpu_string(desc.label);
+
+    let backend = device_id.backend();
+    let id = client
+        .identities
+        .lock()
+        .select(backend)
+        .bind_groups
+        .process(backend);
+
+    let mut entries = Vec::with_capacity(desc.entries_length);
+    for entry in make_slice(desc.entries, desc.entries_length) {
+        entries.push(wgc::binding_model::BindGroupEntry {
+            binding: entry.binding,
+            resource: if let Some(id) = entry.buffer {
+                wgc::binding_model::BindingResource::Buffer(wgc::binding_model::BufferBinding {
+                    buffer_id: id,
+                    offset: entry.offset,
+                    size: entry.size,
+                })
+            } else if let Some(id) = entry.sampler {
+                wgc::binding_model::BindingResource::Sampler(id)
+            } else if let Some(id) = entry.texture_view {
+                wgc::binding_model::BindingResource::TextureView(id)
+            } else {
+                panic!("Unexpected binding entry {:?}", entry);
+            },
+        });
+    }
+    let wgpu_desc = wgc::binding_model::BindGroupDescriptor {
+        label,
+        layout: desc.layout,
+        entries: Cow::Owned(entries),
+    };
+
+    let action = DeviceAction::CreateBindGroup(id, wgpu_desc);
+    *bb = make_byte_buf(&action);
+    id
+}
+
+#[no_mangle]
+pub extern "C" fn wgpu_client_make_shader_module_id(
+    client: &Client,
+    device_id: id::DeviceId,
+) -> id::ShaderModuleId {
+    let backend = device_id.backend();
+    client
+        .identities
+        .lock()
+        .select(backend)
+        .shader_modules
+        .process(backend)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wgpu_client_create_compute_pipeline(
+    client: &Client,
+    device_id: id::DeviceId,
+    desc: &ComputePipelineDescriptor,
+    bb: &mut ByteBuf,
+    implicit_pipeline_layout_id: *mut Option<id::PipelineLayoutId>,
+    implicit_bind_group_layout_ids: *mut Option<id::BindGroupLayoutId>,
+) -> id::ComputePipelineId {
+    let label = wgpu_string(desc.label);
+
+    let backend = device_id.backend();
+    let mut identities = client.identities.lock();
+    let id = identities
+        .select(backend)
+        .compute_pipelines
+        .process(backend);
+
+    let wgpu_desc = wgc::pipeline::ComputePipelineDescriptor {
+        label,
+        layout: desc.layout,
+        stage: desc.stage.to_wgpu(),
+    };
+
+    let implicit = match desc.layout {
+        Some(_) => None,
+        None => {
+            let implicit = ImplicitLayout::new(identities.select(backend), backend);
+            ptr::write(implicit_pipeline_layout_id, Some(implicit.pipeline));
+            for (i, bgl_id) in implicit.bind_groups.iter().enumerate() {
+                *implicit_bind_group_layout_ids.add(i) = *bgl_id;
+            }
+            Some(implicit)
+        }
+    };
+
+    let action = DeviceAction::CreateComputePipeline(id, wgpu_desc, implicit);
+    *bb = make_byte_buf(&action);
+    id
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wgpu_client_create_render_pipeline(
+    client: &Client,
+    device_id: id::DeviceId,
+    desc: &RenderPipelineDescriptor,
+    bb: &mut ByteBuf,
+    implicit_pipeline_layout_id: *mut Option<id::PipelineLayoutId>,
+    implicit_bind_group_layout_ids: *mut Option<id::BindGroupLayoutId>,
+) -> id::RenderPipelineId {
+    let label = wgpu_string(desc.label);
+
+    let backend = device_id.backend();
+    let mut identities = client.identities.lock();
+    let id = identities.select(backend).render_pipelines.process(backend);
+
+    let wgpu_desc = wgc::pipeline::RenderPipelineDescriptor {
+        label,
+        layout: desc.layout,
+        vertex: desc.vertex.to_wgpu(),
+        fragment: desc.fragment.map(FragmentState::to_wgpu),
+        primitive: desc.primitive.to_wgpu(),
+        depth_stencil: desc.depth_stencil.cloned(),
+        multisample: desc.multisample.clone(),
+        multiview: None,
+    };
+
+    let implicit = match desc.layout {
+        Some(_) => None,
+        None => {
+            let implicit = ImplicitLayout::new(identities.select(backend), backend);
+            ptr::write(implicit_pipeline_layout_id, Some(implicit.pipeline));
+            for (i, bgl_id) in implicit.bind_groups.iter().enumerate() {
+                *implicit_bind_group_layout_ids.add(i) = *bgl_id;
+            }
+            Some(implicit)
+        }
+    };
+
+    let action = DeviceAction::CreateRenderPipeline(id, wgpu_desc, implicit);
+    *bb = make_byte_buf(&action);
+    id
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wgpu_command_encoder_copy_buffer_to_buffer(
+    src: id::BufferId,
+    src_offset: wgt::BufferAddress,
+    dst: id::BufferId,
+    dst_offset: wgt::BufferAddress,
+    size: wgt::BufferAddress,
+    bb: &mut ByteBuf,
+) {
+    let action = CommandEncoderAction::CopyBufferToBuffer {
+        src,
+        src_offset,
+        dst,
+        dst_offset,
+        size,
+    };
+    *bb = make_byte_buf(&action);
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wgpu_command_encoder_copy_texture_to_buffer(
+    src: wgc::command::ImageCopyTexture,
+    dst_buffer: wgc::id::BufferId,
+    dst_layout: &ImageDataLayout,
+    size: wgt::Extent3d,
+    bb: &mut ByteBuf,
+) {
+    let action = CommandEncoderAction::CopyTextureToBuffer {
+        src,
+        dst: wgc::command::ImageCopyBuffer {
+            buffer: dst_buffer,
+            layout: dst_layout.into_wgt(),
+        },
+        size,
+    };
+    *bb = make_byte_buf(&action);
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wgpu_command_encoder_copy_buffer_to_texture(
+    src_buffer: wgc::id::BufferId,
+    src_layout: &ImageDataLayout,
+    dst: wgc::command::ImageCopyTexture,
+    size: wgt::Extent3d,
+    bb: &mut ByteBuf,
+) {
+    let action = CommandEncoderAction::CopyBufferToTexture {
+        src: wgc::command::ImageCopyBuffer {
+            buffer: src_buffer,
+            layout: src_layout.into_wgt(),
+        },
+        dst,
+        size,
+    };
+    *bb = make_byte_buf(&action);
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wgpu_command_encoder_copy_texture_to_texture(
+    src: wgc::command::ImageCopyTexture,
+    dst: wgc::command::ImageCopyTexture,
+    size: wgt::Extent3d,
+    bb: &mut ByteBuf,
+) {
+    let action = CommandEncoderAction::CopyTextureToTexture { src, dst, size };
+    *bb = make_byte_buf(&action);
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wgpu_command_encoder_clear_buffer(
+    dst: wgc::id::BufferId,
+    offset: u64,
+    size: Option<&u64>,
+    bb: &mut ByteBuf,
+) {
+    let action = CommandEncoderAction::ClearBuffer {
+        dst,
+        offset,
+        size: size.cloned(),
+    };
+    *bb = make_byte_buf(&action);
+}
+
+#[no_mangle]
+pub extern "C" fn wgpu_command_encoder_push_debug_group(marker: &nsACString, bb: &mut ByteBuf) {
+    let string = marker.to_string();
+    let action = CommandEncoderAction::PushDebugGroup(string);
+    *bb = make_byte_buf(&action);
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wgpu_command_encoder_pop_debug_group(bb: &mut ByteBuf) {
+    let action = CommandEncoderAction::PopDebugGroup;
+    *bb = make_byte_buf(&action);
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wgpu_command_encoder_insert_debug_marker(
+    marker: &nsACString,
+    bb: &mut ByteBuf,
+) {
+    let string = marker.to_string();
+    let action = CommandEncoderAction::InsertDebugMarker(string);
+    *bb = make_byte_buf(&action);
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wgpu_queue_write_buffer(
+    dst: id::BufferId,
+    offset: wgt::BufferAddress,
+    bb: &mut ByteBuf,
+) {
+    let action = QueueWriteAction::Buffer { dst, offset };
+    *bb = make_byte_buf(&action);
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wgpu_queue_write_texture(
+    dst: wgt::ImageCopyTexture<id::TextureId>,
+    layout: ImageDataLayout,
+    size: wgt::Extent3d,
+    bb: &mut ByteBuf,
+) {
+    let layout = layout.into_wgt();
+    let action = QueueWriteAction::Texture { dst, layout, size };
+    *bb = make_byte_buf(&action);
+}
+
+/// Returns the block size or zero if the format has multiple aspects (for example depth+stencil).
+#[no_mangle]
+pub extern "C" fn wgpu_texture_format_block_size_single_aspect(format: wgt::TextureFormat) -> u32 {
+    format.block_copy_size(None).unwrap_or(0)
+}
+
+#[no_mangle]
+pub extern "C" fn wgpu_client_use_external_texture_in_swapChain(
+    device_id: id::DeviceId,
+    format: wgt::TextureFormat,
+) -> bool {
+    if device_id.backend() != wgt::Backend::Dx12 {
+        return false;
+    }
+
+    if !static_prefs::pref!("dom.webgpu.swap-chain.external-texture-dx12") {
+        return false;
+    }
+
+    let supported = match format {
+        wgt::TextureFormat::Bgra8Unorm => true,
+        _ => false,
+    };
+
+    supported
+}
diff --git a/gfx/wgpu_bindings/src/error.rs b/gfx/wgpu_bindings/src/error.rs
new file mode 100644
index 0000000000..4497f35102
--- /dev/null
+++ b/gfx/wgpu_bindings/src/error.rs
@@ -0,0 +1,662 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+//! Types needed to marshal [`server`](crate::server) errors back to C++ in Firefox. The main type
+//! of this module is [`ErrorBuffer`](crate::server::ErrorBuffer).
+
+use std::{
+    error::Error,
+    fmt::{self, Display, Formatter},
+    os::raw::c_char,
+    ptr,
+};
+
+use serde::{Deserialize, Serialize};
+
+/// A non-owning representation of `mozilla::webgpu::ErrorBuffer` in C++, passed as an argument to
+/// other functions in [this module](self).
+///
+/// C++ callers of Rust functions (presumably in `WebGPUParent.cpp`) that expect one of these
+/// structs can create a `mozilla::webgpu::ErrorBuffer` object, and call its `ToFFI` method to
+/// construct a value of this type, available to C++ as `mozilla::webgpu::ffi::WGPUErrorBuffer`. If
+/// we catch a `Result::Err` in other functions of [this module](self), the error is converted to
+/// this type.
+#[repr(C)]
+pub struct ErrorBuffer {
+    /// The type of error that `string` is associated with. If this location is set to
+    /// [`ErrorBufferType::None`] after being passed as an argument to a function in [this module](self),
+    /// then the remaining fields are guaranteed to not have been altered by that function from
+    /// their original state.
+    r#type: *mut ErrorBufferType,
+    /// The (potentially truncated) message associated with this error. A fixed-capacity,
+    /// null-terminated UTF-8 string buffer owned by C++.
+    ///
+    /// When we convert WGPU errors to this type, we render the error as a string, copying into
+    /// `message` up to `capacity - 1`, and null-terminate it.
+    message: *mut c_char,
+    message_capacity: usize,
+}
+
+impl ErrorBuffer {
+    /// Fill this buffer with the textual representation of `error`.
+    ///
+    /// If the error message is too long, truncate it to `self.capacity`. In either case, the error
+    /// message is always terminated by a zero byte.
+    ///
+    /// Note that there is no explicit indication of the message's length, only the terminating zero
+    /// byte. If the textual form of `error` itself includes a zero byte (as Rust strings can), then
+    /// the C++ code receiving this error message has no way to distinguish that from the
+    /// terminating zero byte, and will see the message as shorter than it is.
+    pub(crate) fn init(&mut self, error: impl HasErrorBufferType) {
+        use std::fmt::Write;
+
+        let mut message = format!("{}", error);
+        let mut e = error.source();
+        while let Some(source) = e {
+            write!(message, ", caused by: {}", source).unwrap();
+            e = source.source();
+        }
+
+        let err_ty = error.error_type();
+        // SAFETY: We presume the pointer provided by the caller is safe to write to.
+        unsafe { *self.r#type = err_ty };
+
+        if matches!(err_ty, ErrorBufferType::None) {
+            log::warn!("{message}");
+            return;
+        }
+
+        assert_ne!(self.message_capacity, 0);
+        let length = if message.len() >= self.message_capacity {
+            log::warn!(
+                "Error message's length {} reached capacity {}, truncating",
+                message.len(),
+                self.message_capacity
+            );
+            self.message_capacity - 1
+        } else {
+            message.len()
+        };
+        unsafe {
+            ptr::copy_nonoverlapping(message.as_ptr(), self.message as *mut u8, length);
+            *self.message.add(length) = 0;
+        }
+    }
+}
+
+/// Corresponds to an optional discriminant of [`GPUError`] type in the WebGPU API. Strongly
+/// correlates to [`GPUErrorFilter`]s.
+///
+/// [`GPUError`]: https://gpuweb.github.io/gpuweb/#gpuerror
+/// [`GPUErrorFilter`]: https://gpuweb.github.io/gpuweb/#enumdef-gpuerrorfilter
+#[repr(u8)]
+#[derive(Clone, Copy, Debug, Deserialize, Serialize)]
+pub(crate) enum ErrorBufferType {
+    None = 0,
+    DeviceLost = 1,
+    Internal = 2,
+    OutOfMemory = 3,
+    Validation = 4,
+}
+
+/// A trait for querying the [`ErrorBufferType`] classification of an error. Used by
+/// [`ErrorBuffer::init`](crate::server::ErrorBuffer::init).
+pub(crate) trait HasErrorBufferType: Error {
+    fn error_type(&self) -> ErrorBufferType;
+}
+
+/// Representation an error whose error message is already rendered as a [`&str`], and has no error
+/// sources. Used for convenience in [`server`](crate::server) code.
+#[derive(Clone, Debug)]
+pub(crate) struct ErrMsg<'a> {
+    pub(crate) message: &'a str,
+    pub(crate) r#type: ErrorBufferType,
+}
+
+impl Display for ErrMsg<'_> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        let Self { message, r#type: _ } = self;
+        write!(f, "{message}")
+    }
+}
+
+impl Error for ErrMsg<'_> {}
+
+impl HasErrorBufferType for ErrMsg<'_> {
+    fn error_type(&self) -> ErrorBufferType {
+        self.r#type
+    }
+}
+
+/// Encapsulates implementations of [`HasErrorType`] for [`wgpu_core`] types.
+mod foreign {
+    use wgc::{
+        binding_model::{
+            CreateBindGroupError, CreateBindGroupLayoutError, CreatePipelineLayoutError,
+            GetBindGroupLayoutError,
+        },
+        command::{
+            ClearError, CommandEncoderError, ComputePassError, CopyError, CreateRenderBundleError,
+            QueryError, QueryUseError, RenderBundleError, RenderPassError, ResolveError,
+            TransferError,
+        },
+        device::{
+            queue::{QueueSubmitError, QueueWriteError},
+            DeviceError,
+        },
+        instance::{RequestAdapterError, RequestDeviceError},
+        pipeline::{
+            CreateComputePipelineError, CreateRenderPipelineError, CreateShaderModuleError,
+        },
+        resource::{
+            BufferAccessError, CreateBufferError, CreateSamplerError, CreateTextureError,
+            CreateTextureViewError, DestroyError,
+        },
+    };
+
+    use super::{ErrorBufferType, HasErrorBufferType};
+
+    impl HasErrorBufferType for RequestAdapterError {
+        fn error_type(&self) -> ErrorBufferType {
+            match self {
+                RequestAdapterError::NotFound | RequestAdapterError::InvalidSurface(_) => {
+                    ErrorBufferType::Validation
+                }
+
+                // N.B: forced non-exhaustiveness
+                _ => ErrorBufferType::Validation,
+            }
+        }
+    }
+
+    impl HasErrorBufferType for RequestDeviceError {
+        fn error_type(&self) -> ErrorBufferType {
+            match self {
+                RequestDeviceError::OutOfMemory => ErrorBufferType::OutOfMemory,
+
+                RequestDeviceError::DeviceLost => ErrorBufferType::DeviceLost,
+
+                RequestDeviceError::Internal
+                | RequestDeviceError::InvalidAdapter
+                | RequestDeviceError::NoGraphicsQueue => ErrorBufferType::Internal,
+
+                RequestDeviceError::UnsupportedFeature(_)
+                | RequestDeviceError::LimitsExceeded(_) => ErrorBufferType::Validation,
+
+                // N.B: forced non-exhaustiveness
+                _ => ErrorBufferType::Validation,
+            }
+        }
+    }
+
+    impl HasErrorBufferType for CreateBufferError {
+        fn error_type(&self) -> ErrorBufferType {
+            match self {
+                CreateBufferError::Device(e) => e.error_type(),
+                CreateBufferError::AccessError(e) => e.error_type(),
+
+                CreateBufferError::UnalignedSize
+                | CreateBufferError::InvalidUsage(_)
+                | CreateBufferError::UsageMismatch(_)
+                | CreateBufferError::MaxBufferSize { .. }
+                | CreateBufferError::MissingDownlevelFlags(_) => ErrorBufferType::Validation,
+
+                // N.B: forced non-exhaustiveness
+                _ => ErrorBufferType::Validation,
+            }
+        }
+    }
+
+    impl HasErrorBufferType for BufferAccessError {
+        fn error_type(&self) -> ErrorBufferType {
+            match self {
+                BufferAccessError::Device(e) => e.error_type(),
+
+                BufferAccessError::Failed
+                | BufferAccessError::Invalid
+                | BufferAccessError::Destroyed
+                | BufferAccessError::AlreadyMapped
+                | BufferAccessError::MapAlreadyPending
+                | BufferAccessError::MissingBufferUsage(_)
+                | BufferAccessError::NotMapped
+                | BufferAccessError::UnalignedRange
+                | BufferAccessError::UnalignedOffset { .. }
+                | BufferAccessError::UnalignedRangeSize { .. }
+                | BufferAccessError::OutOfBoundsUnderrun { .. }
+                | BufferAccessError::OutOfBoundsOverrun { .. }
+                | BufferAccessError::NegativeRange { .. }
+                | BufferAccessError::MapAborted => ErrorBufferType::Validation,
+
+                // N.B: forced non-exhaustiveness
+                _ => ErrorBufferType::Validation,
+            }
+        }
+    }
+
+    impl HasErrorBufferType for CreateTextureError {
+        fn error_type(&self) -> ErrorBufferType {
+            match self {
+                CreateTextureError::Device(e) => e.error_type(),
+
+                CreateTextureError::InvalidUsage(_)
+                | CreateTextureError::InvalidDimension(_)
+                | CreateTextureError::InvalidDepthDimension(_, _)
+                | CreateTextureError::InvalidCompressedDimension(_, _)
+                | CreateTextureError::InvalidMipLevelCount { .. }
+                | CreateTextureError::InvalidFormatUsages(_, _, _)
+                | CreateTextureError::InvalidViewFormat(_, _)
+                | CreateTextureError::InvalidDimensionUsages(_, _)
+                | CreateTextureError::InvalidMultisampledStorageBinding
+                | CreateTextureError::InvalidMultisampledFormat(_)
+                | CreateTextureError::InvalidSampleCount(..)
+                | CreateTextureError::MultisampledNotRenderAttachment
+                | CreateTextureError::MissingFeatures(_, _)
+                | CreateTextureError::MissingDownlevelFlags(_) => ErrorBufferType::Validation,
+
+                // N.B: forced non-exhaustiveness
+                _ => ErrorBufferType::Validation,
+            }
+        }
+    }
+
+    impl HasErrorBufferType for CreateSamplerError {
+        fn error_type(&self) -> ErrorBufferType {
+            match self {
+                CreateSamplerError::Device(e) => e.error_type(),
+
+                CreateSamplerError::InvalidLodMinClamp(_)
+                | CreateSamplerError::InvalidLodMaxClamp { .. }
+                | CreateSamplerError::InvalidAnisotropy(_)
+                | CreateSamplerError::InvalidFilterModeWithAnisotropy { .. }
+                | CreateSamplerError::TooManyObjects
+                | CreateSamplerError::MissingFeatures(_) => ErrorBufferType::Validation,
+
+                // N.B: forced non-exhaustiveness
+                _ => ErrorBufferType::Validation,
+            }
+        }
+    }
+
+    impl HasErrorBufferType for CreateBindGroupLayoutError {
+        fn error_type(&self) -> ErrorBufferType {
+            match self {
+                CreateBindGroupLayoutError::Device(e) => e.error_type(),
+
+                CreateBindGroupLayoutError::ConflictBinding(_)
+                | CreateBindGroupLayoutError::Entry { .. }
+                | CreateBindGroupLayoutError::TooManyBindings(_)
+                | CreateBindGroupLayoutError::InvalidBindingIndex { .. }
+                | CreateBindGroupLayoutError::InvalidVisibility(_) => ErrorBufferType::Validation,
+
+                // N.B: forced non-exhaustiveness
+                _ => ErrorBufferType::Validation,
+            }
+        }
+    }
+
+    impl HasErrorBufferType for CreatePipelineLayoutError {
+        fn error_type(&self) -> ErrorBufferType {
+            match self {
+                CreatePipelineLayoutError::Device(e) => e.error_type(),
+
+                CreatePipelineLayoutError::InvalidBindGroupLayout(_)
+                | CreatePipelineLayoutError::MisalignedPushConstantRange { .. }
+                | CreatePipelineLayoutError::MissingFeatures(_)
+                | CreatePipelineLayoutError::MoreThanOnePushConstantRangePerStage { .. }
+                | CreatePipelineLayoutError::PushConstantRangeTooLarge { .. }
+                | CreatePipelineLayoutError::TooManyBindings(_)
+                | CreatePipelineLayoutError::TooManyGroups { .. } => ErrorBufferType::Validation,
+
+                // N.B: forced non-exhaustiveness
+                _ => ErrorBufferType::Validation,
+            }
+        }
+    }
+
+    impl HasErrorBufferType for CreateBindGroupError {
+        fn error_type(&self) -> ErrorBufferType {
+            match self {
+                CreateBindGroupError::Device(e) => e.error_type(),
+
+                CreateBindGroupError::InvalidLayout
+                | CreateBindGroupError::InvalidBuffer(_)
+                | CreateBindGroupError::InvalidTextureView(_)
+                | CreateBindGroupError::InvalidTexture(_)
+                | CreateBindGroupError::InvalidSampler(_)
+                | CreateBindGroupError::BindingArrayPartialLengthMismatch { .. }
+                | CreateBindGroupError::BindingArrayLengthMismatch { .. }
+                | CreateBindGroupError::BindingArrayZeroLength
+                | CreateBindGroupError::BindingRangeTooLarge { .. }
+                | CreateBindGroupError::BindingSizeTooSmall { .. }
+                | CreateBindGroupError::BindingZeroSize(_)
+                | CreateBindGroupError::BindingsNumMismatch { .. }
+                | CreateBindGroupError::DuplicateBinding(_)
+                | CreateBindGroupError::MissingBindingDeclaration(_)
+                | CreateBindGroupError::MissingBufferUsage(_)
+                | CreateBindGroupError::MissingTextureUsage(_)
+                | CreateBindGroupError::SingleBindingExpected
+                | CreateBindGroupError::UnalignedBufferOffset(_, _, _)
+                | CreateBindGroupError::BufferRangeTooLarge { .. }
+                | CreateBindGroupError::WrongBindingType { .. }
+                | CreateBindGroupError::InvalidTextureMultisample { .. }
+                | CreateBindGroupError::InvalidTextureSampleType { .. }
+                | CreateBindGroupError::InvalidTextureDimension { .. }
+                | CreateBindGroupError::InvalidStorageTextureFormat { .. }
+                | CreateBindGroupError::InvalidStorageTextureMipLevelCount { .. }
+                | CreateBindGroupError::WrongSamplerComparison { .. }
+                | CreateBindGroupError::WrongSamplerFiltering { .. }
+                | CreateBindGroupError::DepthStencilAspect
+                | CreateBindGroupError::StorageReadNotSupported(_)
+                | CreateBindGroupError::ResourceUsageConflict(_) => ErrorBufferType::Validation,
+
+                // N.B: forced non-exhaustiveness
+                _ => ErrorBufferType::Validation,
+            }
+        }
+    }
+
+    impl HasErrorBufferType for CreateShaderModuleError {
+        fn error_type(&self) -> ErrorBufferType {
+            match self {
+                CreateShaderModuleError::Device(e) => e.error_type(),
+
+                CreateShaderModuleError::Generation => ErrorBufferType::Internal,
+
+                CreateShaderModuleError::Parsing(_)
+                | CreateShaderModuleError::Validation(_)
+                | CreateShaderModuleError::MissingFeatures(_)
+                | CreateShaderModuleError::InvalidGroupIndex { .. } => ErrorBufferType::Validation,
+
+                // N.B: forced non-exhaustiveness
+                _ => ErrorBufferType::Validation,
+            }
+        }
+    }
+
+    impl HasErrorBufferType for CreateComputePipelineError {
+        fn error_type(&self) -> ErrorBufferType {
+            match self {
+                CreateComputePipelineError::Device(e) => e.error_type(),
+
+                CreateComputePipelineError::Internal(_) => ErrorBufferType::Internal,
+
+                CreateComputePipelineError::InvalidLayout
+                | CreateComputePipelineError::Implicit(_)
+                | CreateComputePipelineError::Stage(_)
+                | CreateComputePipelineError::MissingDownlevelFlags(_) => {
+                    ErrorBufferType::Validation
+                }
+
+                // N.B: forced non-exhaustiveness
+                _ => ErrorBufferType::Validation,
+            }
+        }
+    }
+
+    impl HasErrorBufferType for CreateRenderPipelineError {
+        fn error_type(&self) -> ErrorBufferType {
+            match self {
+                CreateRenderPipelineError::Device(e) => e.error_type(),
+
+                CreateRenderPipelineError::Internal { .. } => ErrorBufferType::Internal,
+
+                CreateRenderPipelineError::ColorAttachment(_)
+                | CreateRenderPipelineError::InvalidLayout
+                | CreateRenderPipelineError::Implicit(_)
+                | CreateRenderPipelineError::ColorState(_, _)
+                | CreateRenderPipelineError::DepthStencilState(_)
+                | CreateRenderPipelineError::InvalidSampleCount(_)
+                | CreateRenderPipelineError::TooManyVertexBuffers { .. }
+                | CreateRenderPipelineError::TooManyVertexAttributes { .. }
+                | CreateRenderPipelineError::VertexStrideTooLarge { .. }
+                | CreateRenderPipelineError::UnalignedVertexStride { .. }
+                | CreateRenderPipelineError::InvalidVertexAttributeOffset { .. }
+                | CreateRenderPipelineError::ShaderLocationClash(_)
+                | CreateRenderPipelineError::StripIndexFormatForNonStripTopology { .. }
+                | CreateRenderPipelineError::ConservativeRasterizationNonFillPolygonMode
+                | CreateRenderPipelineError::MissingFeatures(_)
+                | CreateRenderPipelineError::MissingDownlevelFlags(_)
+                | CreateRenderPipelineError::Stage { .. }
+                | CreateRenderPipelineError::UnalignedShader { .. } => ErrorBufferType::Validation,
+
+                // N.B: forced non-exhaustiveness
+                _ => ErrorBufferType::Validation,
+            }
+        }
+    }
+
+    impl HasErrorBufferType for RenderBundleError {
+        fn error_type(&self) -> ErrorBufferType {
+            // We can't classify this ourselves, because inner error classification is private. May
+            // need some upstream work to do this properly.
+            ErrorBufferType::Validation
+        }
+    }
+
+    impl HasErrorBufferType for DeviceError {
+        fn error_type(&self) -> ErrorBufferType {
+            match self {
+                DeviceError::Invalid | DeviceError::WrongDevice => ErrorBufferType::Validation,
+                DeviceError::InvalidQueueId => ErrorBufferType::Validation,
+                DeviceError::Lost => ErrorBufferType::DeviceLost,
+                DeviceError::OutOfMemory => ErrorBufferType::OutOfMemory,
+                DeviceError::ResourceCreationFailed => ErrorBufferType::Internal,
+                _ => ErrorBufferType::Internal,
+            }
+        }
+    }
+
+    impl HasErrorBufferType for CreateTextureViewError {
+        fn error_type(&self) -> ErrorBufferType {
+            match self {
+                CreateTextureViewError::OutOfMemory => ErrorBufferType::OutOfMemory,
+
+                CreateTextureViewError::InvalidTexture
+                | CreateTextureViewError::InvalidTextureViewDimension { .. }
+                | CreateTextureViewError::InvalidMultisampledTextureViewDimension(_)
+                | CreateTextureViewError::InvalidCubemapTextureDepth { .. }
+                | CreateTextureViewError::InvalidCubemapArrayTextureDepth { .. }
+                | CreateTextureViewError::InvalidCubeTextureViewSize
+                | CreateTextureViewError::ZeroMipLevelCount
+                | CreateTextureViewError::ZeroArrayLayerCount
+                | CreateTextureViewError::TooManyMipLevels { .. }
+                | CreateTextureViewError::TooManyArrayLayers { .. }
+                | CreateTextureViewError::InvalidArrayLayerCount { .. }
+                | CreateTextureViewError::InvalidAspect { .. }
+                | CreateTextureViewError::FormatReinterpretation { .. } => {
+                    ErrorBufferType::Validation
+                }
+
+                // N.B: forced non-exhaustiveness
+                _ => ErrorBufferType::Validation,
+            }
+        }
+    }
+
+    impl HasErrorBufferType for CopyError {
+        fn error_type(&self) -> ErrorBufferType {
+            match self {
+                CopyError::Encoder(e) => e.error_type(),
+                CopyError::Transfer(e) => e.error_type(),
+
+                // N.B: forced non-exhaustiveness
+                _ => ErrorBufferType::Validation,
+            }
+        }
+    }
+
+    impl HasErrorBufferType for TransferError {
+        fn error_type(&self) -> ErrorBufferType {
+            match self {
+                TransferError::MemoryInitFailure(e) => e.error_type(),
+
+                TransferError::InvalidBuffer(_)
+                | TransferError::InvalidTexture(_)
+                | TransferError::SameSourceDestinationBuffer
+                | TransferError::MissingCopySrcUsageFlag
+                | TransferError::MissingCopyDstUsageFlag(_, _)
+                | TransferError::MissingRenderAttachmentUsageFlag(_)
+                | TransferError::BufferOverrun { .. }
+                | TransferError::TextureOverrun { .. }
+                | TransferError::InvalidTextureAspect { .. }
+                | TransferError::InvalidTextureMipLevel { .. }
+                | TransferError::InvalidDimensionExternal(_)
+                | TransferError::UnalignedBufferOffset(_)
+                | TransferError::UnalignedCopySize(_)
+                | TransferError::UnalignedCopyWidth
+                | TransferError::UnalignedCopyHeight
+                | TransferError::UnalignedCopyOriginX
+                | TransferError::UnalignedCopyOriginY
+                | TransferError::UnalignedBytesPerRow
+                | TransferError::UnspecifiedBytesPerRow
+                | TransferError::UnspecifiedRowsPerImage
+                | TransferError::InvalidBytesPerRow
+                | TransferError::InvalidCopySize
+                | TransferError::InvalidRowsPerImage
+                | TransferError::CopySrcMissingAspects
+                | TransferError::CopyDstMissingAspects
+                | TransferError::CopyAspectNotOne
+                | TransferError::CopyFromForbiddenTextureFormat { .. }
+                | TransferError::CopyToForbiddenTextureFormat { .. }
+                | TransferError::ExternalCopyToForbiddenTextureFormat(_)
+                | TransferError::InvalidDepthTextureExtent
+                | TransferError::TextureFormatsNotCopyCompatible { .. }
+                | TransferError::MissingDownlevelFlags(_)
+                | TransferError::InvalidSampleCount { .. }
+                | TransferError::InvalidMipLevel { .. } => ErrorBufferType::Validation,
+
+                // N.B: forced non-exhaustiveness
+                _ => ErrorBufferType::Validation,
+            }
+        }
+    }
+
+    impl HasErrorBufferType for ComputePassError {
+        fn error_type(&self) -> ErrorBufferType {
+            // We can't classify this ourselves, because inner error classification is private. We
+            // may need some upstream work to do this properly. For now, we trust that this opaque
+            // type only ever represents `Validation`.
+            ErrorBufferType::Validation
+        }
+    }
+
+    impl HasErrorBufferType for QueryError {
+        fn error_type(&self) -> ErrorBufferType {
+            match self {
+                QueryError::Encoder(e) => e.error_type(),
+                QueryError::Use(e) => e.error_type(),
+                QueryError::Resolve(e) => e.error_type(),
+
+                QueryError::InvalidBuffer(_) | QueryError::InvalidQuerySet(_) => {
+                    ErrorBufferType::Validation
+                }
+
+                // N.B: forced non-exhaustiveness
+                _ => ErrorBufferType::Validation,
+            }
+        }
+    }
+
+    impl HasErrorBufferType for QueryUseError {
+        fn error_type(&self) -> ErrorBufferType {
+            // We can't classify this ourselves, because inner error classification is private. We
+            // may need some upstream work to do this properly. For now, we trust that this opaque
+            // type only ever represents `Validation`.
+            ErrorBufferType::Validation
+        }
+    }
+
+    impl HasErrorBufferType for ResolveError {
+        fn error_type(&self) -> ErrorBufferType {
+            // We can't classify this ourselves, because inner error classification is private. We
+            // may need some upstream work to do this properly. For now, we trust that this opaque
+            // type only ever represents `Validation`.
+            ErrorBufferType::Validation
+        }
+    }
+
+    impl HasErrorBufferType for RenderPassError {
+        fn error_type(&self) -> ErrorBufferType {
+            // TODO: This type's `inner` member has an `OutOfMemory` variant. We definitely need to
+            // expose this upstream, or move this implementation upstream.
+            //
+            // Bug for tracking: https://bugzilla.mozilla.org/show_bug.cgi?id=1840926
+            ErrorBufferType::Validation
+        }
+    }
+
+    impl HasErrorBufferType for ClearError {
+        fn error_type(&self) -> ErrorBufferType {
+            // We can't classify this ourselves, because inner error classification is private. We
+            // may need some upstream work to do this properly. For now, we trust that this opaque
+            // type only ever represents `Validation`.
+            ErrorBufferType::Validation
+        }
+    }
+
+    impl HasErrorBufferType for CommandEncoderError {
+        fn error_type(&self) -> ErrorBufferType {
+            // We can't classify this ourselves, because inner error classification is private. We
+            // may need some upstream work to do this properly. For now, we trust that this opaque
+            // type only ever represents `Validation`.
+            ErrorBufferType::Validation
+        }
+    }
+
+    impl HasErrorBufferType for QueueSubmitError {
+        fn error_type(&self) -> ErrorBufferType {
+            match self {
+                QueueSubmitError::Queue(e) => e.error_type(),
+                QueueSubmitError::Unmap(e) => e.error_type(),
+
+                QueueSubmitError::StuckGpu => ErrorBufferType::Internal, // TODO: validate
+                QueueSubmitError::DestroyedBuffer(_)
+                | QueueSubmitError::DestroyedTexture(_)
+                | QueueSubmitError::BufferStillMapped(_)
+                | QueueSubmitError::SurfaceOutputDropped
+                | QueueSubmitError::SurfaceUnconfigured => ErrorBufferType::Validation,
+
+                // N.B: forced non-exhaustiveness
+                _ => ErrorBufferType::Validation,
+            }
+        }
+    }
+
+    impl HasErrorBufferType for QueueWriteError {
+        fn error_type(&self) -> ErrorBufferType {
+            match self {
+                QueueWriteError::Queue(e) => e.error_type(),
+                QueueWriteError::Transfer(e) => e.error_type(),
+                QueueWriteError::MemoryInitFailure(e) => e.error_type(),
+
+                // N.B: forced non-exhaustiveness
+                _ => ErrorBufferType::Validation,
+            }
+        }
+    }
+
+    impl HasErrorBufferType for GetBindGroupLayoutError {
+        fn error_type(&self) -> ErrorBufferType {
+            // We can't classify this ourselves, because inner error classification is private. We
+            // may need some upstream work to do this properly. For now, we trust that this opaque
+            // type only ever represents `Validation`.
+            ErrorBufferType::Validation
+        }
+    }
+
+    impl HasErrorBufferType for CreateRenderBundleError {
+        fn error_type(&self) -> ErrorBufferType {
+            // We can't classify this ourselves, because inner error classification is private. We
+            // may need some upstream work to do this properly. For now, we trust that this opaque
+            // type only ever represents `Validation`.
+            ErrorBufferType::Validation
+        }
+    }
+
+    impl HasErrorBufferType for DestroyError {
+        fn error_type(&self) -> ErrorBufferType {
+            ErrorBufferType::Validation
+        }
+    }
+}
diff --git a/gfx/wgpu_bindings/src/identity.rs b/gfx/wgpu_bindings/src/identity.rs
new file mode 100644
index 0000000000..e0032240a4
--- /dev/null
+++ b/gfx/wgpu_bindings/src/identity.rs
@@ -0,0 +1,3 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
diff --git a/gfx/wgpu_bindings/src/lib.rs b/gfx/wgpu_bindings/src/lib.rs
new file mode 100644
index 0000000000..3299234182
--- /dev/null
+++ b/gfx/wgpu_bindings/src/lib.rs
@@ -0,0 +1,233 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use crate::error::ErrorBufferType;
+use wgc::id;
+
+pub use wgc::command::{compute_ffi::*, render_ffi::*};
+
+pub mod client;
+pub mod error;
+pub mod server;
+
+pub use wgc::device::trace::Command as CommandEncoderAction;
+
+use std::marker::PhantomData;
+use std::{borrow::Cow, mem, slice};
+
+use nsstring::nsACString;
+
+type RawString = *const std::os::raw::c_char;
+
+//TODO: figure out why 'a and 'b have to be different here
+//TODO: remove this
+fn cow_label<'a, 'b>(raw: &'a RawString) -> Option<Cow<'b, str>> {
+    if raw.is_null() {
+        None
+    } else {
+        let cstr = unsafe { std::ffi::CStr::from_ptr(*raw) };
+        cstr.to_str().ok().map(Cow::Borrowed)
+    }
+}
+
+// Hides the repeated boilerplate of turning a `Option<&nsACString>` into a `Option<Cow<str>`.
+pub fn wgpu_string(gecko_string: Option<&nsACString>) -> Option<Cow<str>> {
+    gecko_string.map(|s| s.to_utf8())
+}
+
+/// An equivalent of `&[T]` for ffi structures and function parameters.
+#[repr(C)]
+pub struct FfiSlice<'a, T> {
+    // `data` may be null.
+    pub data: *const T,
+    pub length: usize,
+    pub _marker: PhantomData<&'a T>,
+}
+
+impl<'a, T> FfiSlice<'a, T> {
+    pub unsafe fn as_slice(&self) -> &'a [T] {
+        if self.data.is_null() {
+            // It is invalid to construct a rust slice with a null pointer.
+            return &[];
+        }
+
+        std::slice::from_raw_parts(self.data, self.length)
+    }
+}
+
+impl<'a, T> Copy for FfiSlice<'a, T> {}
+impl<'a, T> Clone for FfiSlice<'a, T> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+#[repr(C)]
+pub struct ByteBuf {
+    data: *const u8,
+    len: usize,
+    capacity: usize,
+}
+
+impl ByteBuf {
+    fn from_vec(vec: Vec<u8>) -> Self {
+        if vec.is_empty() {
+            ByteBuf {
+                data: std::ptr::null(),
+                len: 0,
+                capacity: 0,
+            }
+        } else {
+            let bb = ByteBuf {
+                data: vec.as_ptr(),
+                len: vec.len(),
+                capacity: vec.capacity(),
+            };
+            mem::forget(vec);
+            bb
+        }
+    }
+
+    unsafe fn as_slice(&self) -> &[u8] {
+        slice::from_raw_parts(self.data, self.len)
+    }
+}
+
+#[repr(C)]
+#[derive(serde::Serialize, serde::Deserialize)]
+pub struct AdapterInformation<S> {
+    id: id::AdapterId,
+    limits: wgt::Limits,
+    features: wgt::Features,
+    name: S,
+    vendor: u32,
+    device: u32,
+    device_type: wgt::DeviceType,
+    driver: S,
+    driver_info: S,
+    backend: wgt::Backend,
+}
+
+#[derive(serde::Serialize, serde::Deserialize)]
+struct ImplicitLayout<'a> {
+    pipeline: id::PipelineLayoutId,
+    bind_groups: Cow<'a, [Option<id::BindGroupLayoutId>]>,
+}
+
+#[derive(serde::Serialize, serde::Deserialize)]
+enum DeviceAction<'a> {
+    CreateTexture(
+        id::TextureId,
+        wgc::resource::TextureDescriptor<'a>,
+        Option<SwapChainId>,
+    ),
+    CreateSampler(id::SamplerId, wgc::resource::SamplerDescriptor<'a>),
+    CreateBindGroupLayout(
+        id::BindGroupLayoutId,
+        wgc::binding_model::BindGroupLayoutDescriptor<'a>,
+    ),
+    RenderPipelineGetBindGroupLayout(id::RenderPipelineId, u32, id::BindGroupLayoutId),
+    ComputePipelineGetBindGroupLayout(id::ComputePipelineId, u32, id::BindGroupLayoutId),
+    CreatePipelineLayout(
+        id::PipelineLayoutId,
+        wgc::binding_model::PipelineLayoutDescriptor<'a>,
+    ),
+    CreateBindGroup(id::BindGroupId, wgc::binding_model::BindGroupDescriptor<'a>),
+    CreateShaderModule(
+        id::ShaderModuleId,
+        wgc::pipeline::ShaderModuleDescriptor<'a>,
+        Cow<'a, str>,
+    ),
+    CreateComputePipeline(
+        id::ComputePipelineId,
+        wgc::pipeline::ComputePipelineDescriptor<'a>,
+        Option<ImplicitLayout<'a>>,
+    ),
+    CreateRenderPipeline(
+        id::RenderPipelineId,
+        wgc::pipeline::RenderPipelineDescriptor<'a>,
+        Option<ImplicitLayout<'a>>,
+    ),
+    CreateRenderBundle(
+        id::RenderBundleId,
+        wgc::command::RenderBundleEncoder,
+        wgc::command::RenderBundleDescriptor<'a>,
+    ),
+    CreateRenderBundleError(id::RenderBundleId, wgc::Label<'a>),
+    CreateCommandEncoder(
+        id::CommandEncoderId,
+        wgt::CommandEncoderDescriptor<wgc::Label<'a>>,
+    ),
+    Error {
+        message: String,
+        r#type: ErrorBufferType,
+    },
+}
+
+#[derive(serde::Serialize, serde::Deserialize)]
+enum QueueWriteAction {
+    Buffer {
+        dst: id::BufferId,
+        offset: wgt::BufferAddress,
+    },
+    Texture {
+        dst: wgt::ImageCopyTexture<id::TextureId>,
+        layout: wgt::ImageDataLayout,
+        size: wgt::Extent3d,
+    },
+}
+
+#[derive(serde::Serialize, serde::Deserialize)]
+enum TextureAction<'a> {
+    CreateView(id::TextureViewId, wgc::resource::TextureViewDescriptor<'a>),
+}
+
+#[repr(C)]
+#[derive(serde::Serialize, serde::Deserialize)]
+enum DropAction {
+    Adapter(id::AdapterId),
+    Device(id::DeviceId),
+    ShaderModule(id::ShaderModuleId),
+    PipelineLayout(id::PipelineLayoutId),
+    BindGroupLayout(id::BindGroupLayoutId),
+    BindGroup(id::BindGroupId),
+    CommandBuffer(id::CommandBufferId),
+    RenderBundle(id::RenderBundleId),
+    RenderPipeline(id::RenderPipelineId),
+    ComputePipeline(id::ComputePipelineId),
+    Buffer(id::BufferId),
+    Texture(id::TextureId),
+    TextureView(id::TextureViewId),
+    Sampler(id::SamplerId),
+}
+
+impl DropAction {
+    // helper function to construct byte bufs
+    fn to_byte_buf(&self) -> ByteBuf {
+        let mut data = Vec::new();
+        bincode::serialize_into(&mut data, self).unwrap();
+        ByteBuf::from_vec(data)
+    }
+}
+
+#[repr(C)]
+pub struct ImageDataLayout<'a> {
+    pub offset: wgt::BufferAddress,
+    pub bytes_per_row: Option<&'a u32>,
+    pub rows_per_image: Option<&'a u32>,
+}
+
+impl<'a> ImageDataLayout<'a> {
+    fn into_wgt(&self) -> wgt::ImageDataLayout {
+        wgt::ImageDataLayout {
+            offset: self.offset,
+            bytes_per_row: self.bytes_per_row.map(|bpr| *bpr),
+            rows_per_image: self.rows_per_image.map(|rpi| *rpi),
+        }
+    }
+}
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+pub struct SwapChainId(pub u64);
diff --git a/gfx/wgpu_bindings/src/server.rs b/gfx/wgpu_bindings/src/server.rs
new file mode 100644
index 0000000000..7a7e08aa30
--- /dev/null
+++ b/gfx/wgpu_bindings/src/server.rs
@@ -0,0 +1,1345 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use crate::{
+    error::{ErrMsg, ErrorBuffer, ErrorBufferType},
+    wgpu_string, AdapterInformation, ByteBuf, CommandEncoderAction, DeviceAction, DropAction,
+    QueueWriteAction, SwapChainId, TextureAction,
+};
+
+use nsstring::{nsACString, nsCString, nsString};
+
+use wgc::{device::DeviceError, gfx_select, id};
+use wgc::{pipeline::CreateShaderModuleError, resource::BufferAccessError};
+#[allow(unused_imports)]
+use wgh::Instance;
+
+use std::borrow::Cow;
+#[allow(unused_imports)]
+use std::mem;
+use std::os::raw::c_void;
+use std::ptr;
+use std::slice;
+use std::sync::atomic::{AtomicU32, Ordering};
+
+use std::ffi::{c_long, c_ulong};
+#[cfg(target_os = "windows")]
+use winapi::shared::dxgi;
+#[cfg(target_os = "windows")]
+use winapi::um::d3d12 as d3d12_ty;
+#[cfg(target_os = "windows")]
+use winapi::um::winnt::GENERIC_ALL;
+#[cfg(target_os = "windows")]
+use winapi::Interface;
+
+// The seemingly redundant u64 suffixes help cbindgen with generating the right C++ code.
+// See https://github.com/mozilla/cbindgen/issues/849.
+
+/// We limit the size of buffer allocations for stability reason.
+/// We can reconsider this limit in the future. Note that some drivers (mesa for example),
+/// have issues when the size of a buffer, mapping or copy command does not fit into a
+/// signed 32 bits integer, so beyond a certain size, large allocations will need some form
+/// of driver allow/blocklist.
+pub const MAX_BUFFER_SIZE: wgt::BufferAddress = 1u64 << 30u64;
+const MAX_BUFFER_SIZE_U32: u32 = MAX_BUFFER_SIZE as u32;
+
+// Mesa has issues with height/depth that don't fit in a 16 bits signed integers.
+const MAX_TEXTURE_EXTENT: u32 = std::i16::MAX as u32;
+// We have to restrict the number of bindings for any given resource type so that
+// the sum of these limits multiplied by the number of shader stages fits
+// maxBindingsPerBindGroup (1000). This restriction is arbitrary and is likely to
+// change eventually. See github.com/gpuweb/gpuweb/pull/4484
+// For now it's impractical for users to have very large numbers of bindings so this
+// limit should not be too restrictive until we add support for a bindless API.
+// Then we may have to ignore the spec or get it changed.
+const MAX_BINDINGS_PER_RESOURCE_TYPE: u32 = 64;
+
+fn restrict_limits(limits: wgt::Limits) -> wgt::Limits {
+    wgt::Limits {
+        max_buffer_size: limits.max_buffer_size.min(MAX_BUFFER_SIZE),
+        max_texture_dimension_1d: limits.max_texture_dimension_1d.min(MAX_TEXTURE_EXTENT),
+        max_texture_dimension_2d: limits.max_texture_dimension_2d.min(MAX_TEXTURE_EXTENT),
+        max_texture_dimension_3d: limits.max_texture_dimension_3d.min(MAX_TEXTURE_EXTENT),
+        max_sampled_textures_per_shader_stage: limits
+            .max_sampled_textures_per_shader_stage
+            .min(MAX_BINDINGS_PER_RESOURCE_TYPE),
+        max_samplers_per_shader_stage: limits
+            .max_samplers_per_shader_stage
+            .min(MAX_BINDINGS_PER_RESOURCE_TYPE),
+        max_storage_textures_per_shader_stage: limits
+            .max_storage_textures_per_shader_stage
+            .min(MAX_BINDINGS_PER_RESOURCE_TYPE),
+        max_uniform_buffers_per_shader_stage: limits
+            .max_uniform_buffers_per_shader_stage
+            .min(MAX_BINDINGS_PER_RESOURCE_TYPE),
+        max_storage_buffers_per_shader_stage: limits
+            .max_storage_buffers_per_shader_stage
+            .min(MAX_BINDINGS_PER_RESOURCE_TYPE),
+        max_uniform_buffer_binding_size: limits
+            .max_uniform_buffer_binding_size
+            .min(MAX_BUFFER_SIZE_U32),
+        max_storage_buffer_binding_size: limits
+            .max_storage_buffer_binding_size
+            .min(MAX_BUFFER_SIZE_U32),
+        max_non_sampler_bindings: 10_000,
+        ..limits
+    }
+}
+
+// hide wgc's global in private
+pub struct Global {
+    global: wgc::global::Global,
+    #[allow(dead_code)]
+    owner: *mut c_void,
+}
+
+impl std::ops::Deref for Global {
+    type Target = wgc::global::Global;
+    fn deref(&self) -> &Self::Target {
+        &self.global
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn wgpu_server_new(owner: *mut c_void) -> *mut Global {
+    log::info!("Initializing WGPU server");
+    let backends_pref = static_prefs::pref!("dom.webgpu.wgpu-backend").to_string();
+    let backends = if backends_pref.is_empty() {
+        #[cfg(windows)]
+        {
+            wgt::Backends::DX12
+        }
+        #[cfg(not(windows))]
+        {
+            wgt::Backends::PRIMARY
+        }
+    } else {
+        log::info!(
+            "Selecting backends based on dom.webgpu.wgpu-backend pref: {:?}",
+            backends_pref
+        );
+        wgc::instance::parse_backends_from_comma_list(&backends_pref)
+    };
+
+    let mut instance_flags = wgt::InstanceFlags::from_build_config().with_env();
+    if !static_prefs::pref!("dom.webgpu.hal-labels") {
+        instance_flags.insert(wgt::InstanceFlags::DISCARD_HAL_LABELS);
+    }
+
+    let global = wgc::global::Global::new(
+        "wgpu",
+        wgt::InstanceDescriptor {
+            backends,
+            flags: instance_flags,
+            dx12_shader_compiler: wgt::Dx12Compiler::Fxc,
+            gles_minor_version: wgt::Gles3MinorVersion::Automatic,
+        },
+    );
+    let global = Global { global, owner };
+    Box::into_raw(Box::new(global))
+}
+
+/// # Safety
+///
+/// This function is unsafe because improper use may lead to memory
+/// problems. For example, a double-free may occur if the function is called
+/// twice on the same raw pointer.
+#[no_mangle]
+pub unsafe extern "C" fn wgpu_server_delete(global: *mut Global) {
+    log::info!("Terminating WGPU server");
+    let _ = Box::from_raw(global);
+}
+
+#[no_mangle]
+pub extern "C" fn wgpu_server_poll_all_devices(global: &Global, force_wait: bool) {
+    global.poll_all_devices(force_wait).unwrap();
+}
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug)]
+pub struct FfiLUID {
+    low_part: c_ulong,
+    high_part: c_long,
+}
+
+/// Request an adapter according to the specified options.
+/// Provide the list of IDs to pick from.
+///
+/// Returns the index in this list, or -1 if unable to pick.
+///
+/// # Safety
+///
+/// This function is unsafe as there is no guarantee that the given pointer is
+/// valid for `id_length` elements.
+#[allow(unused_variables)]
+#[no_mangle]
+pub unsafe extern "C" fn wgpu_server_instance_request_adapter(
+    global: &Global,
+    desc: &wgc::instance::RequestAdapterOptions,
+    ids: *const id::AdapterId,
+    id_length: usize,
+    adapter_luid: Option<&FfiLUID>,
+    mut error_buf: ErrorBuffer,
+) -> i8 {
+    let ids = slice::from_raw_parts(ids, id_length);
+
+    // Prefer to use the dx12 backend, if one exists, and use the same DXGI adapter as WebRender.
+    // If wgpu uses a different adapter than WebRender, textures created by
+    // webgpu::ExternalTexture do not work with wgpu.
+    #[cfg(target_os = "windows")]
+    if global.global.instance.dx12.is_some() && adapter_luid.is_some() {
+        let hal = global.global.instance_as_hal::<wgc::api::Dx12>().unwrap();
+        for adapter in hal.enumerate_adapters() {
+            let raw_adapter = adapter.adapter.raw_adapter();
+            let mut desc: dxgi::DXGI_ADAPTER_DESC = unsafe { mem::zeroed() };
+            unsafe {
+                raw_adapter.GetDesc(&mut desc);
+            }
+            let id = ids
+                .iter()
+                .find_map(|id| (id.backend() == wgt::Backend::Dx12).then_some(id));
+            if id.is_some()
+                && desc.AdapterLuid.LowPart == adapter_luid.unwrap().low_part
+                && desc.AdapterLuid.HighPart == adapter_luid.unwrap().high_part
+            {
+                let adapter_id = global
+                    .create_adapter_from_hal::<wgh::api::Dx12>(adapter, Some(id.unwrap().clone()));
+                return ids.iter().position(|&i| i == adapter_id).unwrap() as i8;
+            }
+        }
+        error_buf.init(ErrMsg {
+            message: "Failed to create adapter for dx12",
+            r#type: ErrorBufferType::Internal,
+        });
+        return -1;
+    }
+
+    match global.request_adapter(desc, wgc::instance::AdapterInputs::IdSet(ids)) {
+        Ok(id) => ids.iter().position(|&i| i == id).unwrap() as i8,
+        Err(e) => {
+            error_buf.init(e);
+            -1
+        }
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wgpu_server_adapter_pack_info(
+    global: &Global,
+    self_id: Option<id::AdapterId>,
+    byte_buf: &mut ByteBuf,
+) {
+    let mut data = Vec::new();
+    match self_id {
+        Some(id) => {
+            let wgt::AdapterInfo {
+                name,
+                vendor,
+                device,
+                device_type,
+                driver,
+                driver_info,
+                backend,
+            } = gfx_select!(id => global.adapter_get_info(id)).unwrap();
+
+            if static_prefs::pref!("dom.webgpu.testing.assert-hardware-adapter") {
+                let is_hardware = match device_type {
+                    wgt::DeviceType::IntegratedGpu | wgt::DeviceType::DiscreteGpu => true,
+                    _ => false,
+                };
+                assert!(
+                    is_hardware,
+                    "Expected a hardware gpu adapter, got {:?}",
+                    device_type
+                );
+            }
+
+            let info = AdapterInformation {
+                id,
+                limits: restrict_limits(gfx_select!(id => global.adapter_limits(id)).unwrap()),
+                features: gfx_select!(id => global.adapter_features(id)).unwrap(),
+                name,
+                vendor,
+                device,
+                device_type,
+                driver,
+                driver_info,
+                backend,
+            };
+            bincode::serialize_into(&mut data, &info).unwrap();
+        }
+        None => {
+            bincode::serialize_into(&mut data, &0u64).unwrap();
+        }
+    }
+    *byte_buf = ByteBuf::from_vec(data);
+}
+
+static TRACE_IDX: AtomicU32 = AtomicU32::new(0);
+
+#[no_mangle]
+pub unsafe extern "C" fn wgpu_server_adapter_request_device(
+    global: &Global,
+    self_id: id::AdapterId,
+    byte_buf: &ByteBuf,
+    new_id: id::DeviceId,
+    mut error_buf: ErrorBuffer,
+) {
+    let desc: wgc::device::DeviceDescriptor = bincode::deserialize(byte_buf.as_slice()).unwrap();
+    let trace_string = std::env::var("WGPU_TRACE").ok().map(|s| {
+        let idx = TRACE_IDX.fetch_add(1, Ordering::Relaxed);
+        let path = format!("{}/{}/", s, idx);
+
+        if std::fs::create_dir_all(&path).is_err() {
+            log::warn!("Failed to create directory {:?} for wgpu recording.", path);
+        }
+
+        path
+    });
+    let trace_path = trace_string
+        .as_ref()
+        .map(|string| std::path::Path::new(string.as_str()));
+    // TODO: in https://github.com/gfx-rs/wgpu/pull/3626/files#diff-033343814319f5a6bd781494692ea626f06f6c3acc0753a12c867b53a646c34eR97
+    // which introduced the queue id parameter, the queue id is also the device id. I don't know how applicable this is to
+    // other situations (this one in particular).
+    let (_, _, error) = gfx_select!(self_id => global.adapter_request_device(self_id, &desc, trace_path, Some(new_id), Some(new_id.transmute())));
+    if let Some(err) = error {
+        error_buf.init(err);
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn wgpu_server_adapter_drop(global: &Global, adapter_id: id::AdapterId) {
+    gfx_select!(adapter_id => global.adapter_drop(adapter_id))
+}
+
+#[no_mangle]
+pub extern "C" fn wgpu_server_device_destroy(global: &Global, self_id: id::DeviceId) {
+    gfx_select!(self_id => global.device_destroy(self_id))
+}
+
+#[no_mangle]
+pub extern "C" fn wgpu_server_device_drop(global: &Global, self_id: id::DeviceId) {
+    gfx_select!(self_id => global.device_drop(self_id))
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wgpu_server_set_device_lost_callback(
+    global: &Global,
+    self_id: id::DeviceId,
+    callback: wgc::device::DeviceLostClosureC,
+) {
+    gfx_select!(self_id => global.device_set_device_lost_closure(self_id, wgc::device::DeviceLostClosure::from_c(callback)));
+}
+
+impl ShaderModuleCompilationMessage {
+    fn set_error(&mut self, error: &CreateShaderModuleError, source: &str) {
+        // The WebGPU spec says that if the message doesn't point to a particular position in
+        // the source, the line number, position, offset and lengths should be zero.
+        self.line_number = 0;
+        self.line_pos = 0;
+        self.utf16_offset = 0;
+        self.utf16_length = 0;
+
+        if let Some(location) = error.location(source) {
+            self.line_number = location.line_number as u64;
+            self.line_pos = location.line_position as u64;
+
+            let start = location.offset as usize;
+            let end = start + location.length as usize;
+            self.utf16_offset = source[0..start].chars().map(|c| c.len_utf16() as u64).sum();
+            self.utf16_length = source[start..end]
+                .chars()
+                .map(|c| c.len_utf16() as u64)
+                .sum();
+        }
+
+        let error_string = error.to_string();
+
+        if !error_string.is_empty() {
+            self.message = nsString::from(&error_string[..]);
+        }
+    }
+}
+
+/// A compilation message representation for the ffi boundary.
+/// the message is immediately copied into an equivalent C++
+/// structure that owns its strings.
+#[repr(C)]
+#[derive(Clone)]
+pub struct ShaderModuleCompilationMessage {
+    pub line_number: u64,
+    pub line_pos: u64,
+    pub utf16_offset: u64,
+    pub utf16_length: u64,
+    pub message: nsString,
+}
+
+/// Creates a shader module and returns an object describing the errors if any.
+///
+/// If there was no error, the returned pointer is nil.
+#[no_mangle]
+pub extern "C" fn wgpu_server_device_create_shader_module(
+    global: &Global,
+    self_id: id::DeviceId,
+    module_id: id::ShaderModuleId,
+    label: Option<&nsACString>,
+    code: &nsCString,
+    out_message: &mut ShaderModuleCompilationMessage,
+    mut error_buf: ErrorBuffer,
+) -> bool {
+    let utf8_label = label.map(|utf16| utf16.to_string());
+    let label = utf8_label.as_ref().map(|s| Cow::from(&s[..]));
+
+    let source_str = code.to_utf8();
+
+    let source = wgc::pipeline::ShaderModuleSource::Wgsl(Cow::from(&source_str[..]));
+
+    let desc = wgc::pipeline::ShaderModuleDescriptor {
+        label,
+        shader_bound_checks: wgt::ShaderBoundChecks::new(),
+    };
+
+    let (_, error) = gfx_select!(
+        self_id => global.device_create_shader_module(
+            self_id, &desc, source, Some(module_id)
+        )
+    );
+
+    if let Some(err) = error {
+        out_message.set_error(&err, &source_str[..]);
+        let err_type = match &err {
+            CreateShaderModuleError::Device(DeviceError::OutOfMemory) => ErrorBufferType::OutOfMemory,
+            CreateShaderModuleError::Device(DeviceError::Lost) => ErrorBufferType::DeviceLost,
+            _ => ErrorBufferType::Validation,
+        };
+
+        // Per spec: "User agents should not include detailed compiler error messages or
+        // shader text in the message text of validation errors arising here: these details
+        // are accessible via getCompilationInfo()"
+        let message = match &err {
+            CreateShaderModuleError::Parsing(_) => "Parsing error".to_string(),
+            CreateShaderModuleError::Validation(_) => "Shader validation error".to_string(),
+            CreateShaderModuleError::Device(device_err) => format!("{device_err:?}"),
+            _ => format!("{err:?}"),
+        };
+
+        error_buf.init(ErrMsg {
+            message: &format!("Shader module creation failed: {message}"),
+            r#type: err_type,
+        });
+        return false;
+    }
+
+    // Avoid allocating the structure that holds errors in the common case (no errors).
+    return true;
+}
+
+#[no_mangle]
+pub extern "C" fn wgpu_server_device_create_buffer(
+    global: &Global,
+    self_id: id::DeviceId,
+    buffer_id: id::BufferId,
+    label: Option<&nsACString>,
+    size: wgt::BufferAddress,
+    usage: u32,
+    mapped_at_creation: bool,
+    shm_allocation_failed: bool,
+    mut error_buf: ErrorBuffer,
+) {
+    let utf8_label = label.map(|utf16| utf16.to_string());
+    let label = utf8_label.as_ref().map(|s| Cow::from(&s[..]));
+    let usage = wgt::BufferUsages::from_bits_retain(usage);
+
+    // Don't trust the graphics driver with buffer sizes larger than our conservative max texture size.
+    if shm_allocation_failed || size > MAX_BUFFER_SIZE {
+        error_buf.init(ErrMsg {
+            message: "Out of memory",
+            r#type: ErrorBufferType::OutOfMemory,
+        });
+        gfx_select!(self_id => global.create_buffer_error(Some(buffer_id), label));
+        return;
+    }
+
+    let desc = wgc::resource::BufferDescriptor {
+        label,
+        size,
+        usage,
+        mapped_at_creation,
+    };
+    let (_, error) =
+        gfx_select!(self_id => global.device_create_buffer(self_id, &desc, Some(buffer_id)));
+    if let Some(err) = error {
+        error_buf.init(err);
+    }
+}
+
+/// # Safety
+///
+/// Callers are responsible for ensuring `callback` is well-formed.
+#[no_mangle]
+pub unsafe extern "C" fn wgpu_server_buffer_map(
+    global: &Global,
+    buffer_id: id::BufferId,
+    start: wgt::BufferAddress,
+    size: wgt::BufferAddress,
+    map_mode: wgc::device::HostMap,
+    callback: wgc::resource::BufferMapCallbackC,
+    mut error_buf: ErrorBuffer,
+) {
+    let callback = wgc::resource::BufferMapCallback::from_c(callback);
+    let operation = wgc::resource::BufferMapOperation {
+        host: map_mode,
+        callback: Some(callback),
+    };
+    // All errors are also exposed to the mapping callback, so we handle them there and ignore
+    // the returned value of buffer_map_async.
+    let result = gfx_select!(buffer_id => global.buffer_map_async(
+        buffer_id,
+        start .. start + size,
+        operation
+    ));
+
+    if let Err(error) = result {
+        error_buf.init(error);
+    }
+}
+
+#[repr(C)]
+pub struct MappedBufferSlice {
+    pub ptr: *mut u8,
+    pub length: u64,
+}
+
+/// # Safety
+///
+/// This function is unsafe as there is no guarantee that the given pointer is
+/// valid for `size` elements.
+#[no_mangle]
+pub unsafe extern "C" fn wgpu_server_buffer_get_mapped_range(
+    global: &Global,
+    buffer_id: id::BufferId,
+    start: wgt::BufferAddress,
+    size: wgt::BufferAddress,
+    mut error_buf: ErrorBuffer,
+) -> MappedBufferSlice {
+    let result = gfx_select!(buffer_id => global.buffer_get_mapped_range(
+        buffer_id,
+        start,
+        Some(size)
+    ));
+
+    let (ptr, length) = result.unwrap_or_else(|error| {
+        error_buf.init(error);
+        (std::ptr::null_mut(), 0)
+    });
+    MappedBufferSlice { ptr, length }
+}
+
+#[no_mangle]
+pub extern "C" fn wgpu_server_buffer_unmap(
+    global: &Global,
+    buffer_id: id::BufferId,
+    mut error_buf: ErrorBuffer,
+) {
+    if let Err(e) = gfx_select!(buffer_id => global.buffer_unmap(buffer_id)) {
+        match e {
+            // NOTE: This is presumed by CTS test cases, and was even formally specified in the
+            // WebGPU spec. previously, but this doesn't seem formally specified now. :confused:
+            //
+            // TODO: upstream this; see <https://bugzilla.mozilla.org/show_bug.cgi?id=1842297>.
+            BufferAccessError::Invalid => (),
+            other => error_buf.init(other),
+        }
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn wgpu_server_buffer_destroy(global: &Global, self_id: id::BufferId) {
+    // Per spec, there is no need for the buffer or even device to be in a valid state,
+    // even calling calling destroy multiple times is fine, so no error to push into
+    // an error scope.
+    let _ = gfx_select!(self_id => global.buffer_destroy(self_id));
+}
+
+#[no_mangle]
+pub extern "C" fn wgpu_server_buffer_drop(global: &Global, self_id: id::BufferId) {
+    gfx_select!(self_id => global.buffer_drop(self_id, false));
+}
+
+#[allow(unused_variables)]
+#[no_mangle]
+pub extern "C" fn wgpu_server_get_device_fence_handle(
+    global: &Global,
+    device_id: id::DeviceId,
+) -> *mut c_void {
+    assert!(device_id.backend() == wgt::Backend::Dx12);
+
+    #[cfg(target_os = "windows")]
+    if device_id.backend() == wgt::Backend::Dx12 {
+        let mut handle = ptr::null_mut();
+        let dx12_device = unsafe {
+            global.device_as_hal::<wgc::api::Dx12, _, Option<d3d12::Device>>(device_id, |hal_device| {
+                hal_device.map(|device| device.raw_device().clone())
+            })
+        };
+        let dx12_device = match dx12_device {
+            Some(device) => device,
+            None => {
+                return ptr::null_mut();
+            }
+        };
+
+        let dx12_fence = unsafe {
+            global.device_fence_as_hal::<wgc::api::Dx12, _, Option<d3d12::Fence>>(device_id, |hal_fence| {
+                hal_fence.map(|fence| fence.raw_fence().clone())
+            })
+        };
+        let dx12_fence = match dx12_fence {
+            Some(fence) => fence,
+            None => {
+                return ptr::null_mut();
+            }
+        };
+
+        let hr = unsafe {
+            dx12_device.CreateSharedHandle(
+                dx12_fence.as_mut_ptr() as *mut winapi::um::d3d12::ID3D12DeviceChild,
+                std::ptr::null(),
+                GENERIC_ALL,
+                std::ptr::null(),
+                &mut handle,
+            )
+        };
+
+        if hr != 0 {
+            return ptr::null_mut();
+        }
+
+        return handle;
+    }
+    ptr::null_mut()
+}
+
+extern "C" {
+    #[allow(dead_code)]
+    fn wgpu_server_use_external_texture_for_swap_chain(
+        param: *mut c_void,
+        swap_chain_id: SwapChainId,
+    ) -> bool;
+    #[allow(dead_code)]
+    fn wgpu_server_ensure_external_texture_for_swap_chain(
+        param: *mut c_void,
+        swap_chain_id: SwapChainId,
+        device_id: id::DeviceId,
+        texture_id: id::TextureId,
+        width: u32,
+        height: u32,
+        format: wgt::TextureFormat,
+        usage: wgt::TextureUsages,
+    ) -> bool;
+    #[allow(dead_code)]
+    fn wgpu_server_get_external_texture_handle(
+        param: *mut c_void,
+        id: id::TextureId,
+    ) -> *mut c_void;
+}
+
+impl Global {
+    fn device_action<A: wgc::hal_api::HalApi>(
+        &self,
+        self_id: id::DeviceId,
+        action: DeviceAction,
+        mut error_buf: ErrorBuffer,
+    ) {
+        match action {
+            #[allow(unused_variables)]
+            DeviceAction::CreateTexture(id, desc, swap_chain_id) => {
+                let max = MAX_TEXTURE_EXTENT;
+                if desc.size.width > max
+                    || desc.size.height > max
+                    || desc.size.depth_or_array_layers > max
+                {
+                    gfx_select!(self_id => self.create_texture_error(Some(id), desc.label));
+                    error_buf.init(ErrMsg {
+                        message: "Out of memory",
+                        r#type: ErrorBufferType::OutOfMemory,
+                    });
+                    return;
+                }
+
+                #[cfg(target_os = "windows")]
+                {
+                    let use_external_texture = if swap_chain_id.is_some() {
+                        unsafe {
+                            wgpu_server_use_external_texture_for_swap_chain(
+                                self.owner,
+                                swap_chain_id.unwrap(),
+                            )
+                        }
+                    } else {
+                        false
+                    };
+
+                    if use_external_texture && self_id.backend() == wgt::Backend::Dx12 {
+                        let ret = unsafe {
+                            wgpu_server_ensure_external_texture_for_swap_chain(
+                                self.owner,
+                                swap_chain_id.unwrap(),
+                                self_id,
+                                id,
+                                desc.size.width,
+                                desc.size.height,
+                                desc.format,
+                                desc.usage,
+                            )
+                        };
+                        if ret != true {
+                            error_buf.init(ErrMsg {
+                                message: "Failed to create external texture",
+                                r#type: ErrorBufferType::Internal,
+                            });
+                            return;
+                        }
+
+                        let dx12_device = unsafe {
+                            self.device_as_hal::<wgc::api::Dx12, _, d3d12::Device>(
+                                self_id,
+                                |hal_device| hal_device.unwrap().raw_device().clone(),
+                            )
+                        };
+
+                        let handle =
+                            unsafe { wgpu_server_get_external_texture_handle(self.owner, id) };
+                        if handle.is_null() {
+                            error_buf.init(ErrMsg {
+                                message: "Failed to get external texture handle",
+                                r#type: ErrorBufferType::Internal,
+                            });
+                        }
+                        let mut resource = d3d12::Resource::null();
+                        let hr = unsafe {
+                            dx12_device.OpenSharedHandle(
+                                handle,
+                                &d3d12_ty::ID3D12Resource::uuidof(),
+                                resource.mut_void(),
+                            )
+                        };
+                        if hr != 0 {
+                            error_buf.init(ErrMsg {
+                                message: "Failed to open shared handle",
+                                r#type: ErrorBufferType::Internal,
+                            });
+                        }
+
+                        let hal_texture = unsafe {
+                            <wgh::api::Dx12 as wgh::Api>::Device::texture_from_raw(
+                                resource,
+                                wgt::TextureFormat::Bgra8Unorm,
+                                wgt::TextureDimension::D2,
+                                desc.size,
+                                1,
+                                1,
+                            )
+                        };
+                        let (_, error) = unsafe {
+                            self.create_texture_from_hal::<wgh::api::Dx12>(
+                                hal_texture,
+                                self_id,
+                                &desc,
+                                Some(id),
+                            )
+                        };
+                        if let Some(err) = error {
+                            error_buf.init(err);
+                        }
+                        return;
+                    }
+                }
+
+                let (_, error) = self.device_create_texture::<A>(self_id, &desc, Some(id));
+                if let Some(err) = error {
+                    error_buf.init(err);
+                }
+            }
+            DeviceAction::CreateSampler(id, desc) => {
+                let (_, error) = self.device_create_sampler::<A>(self_id, &desc, Some(id));
+                if let Some(err) = error {
+                    error_buf.init(err);
+                }
+            }
+            DeviceAction::CreateBindGroupLayout(id, desc) => {
+                let (_, error) =
+                    self.device_create_bind_group_layout::<A>(self_id, &desc, Some(id));
+                if let Some(err) = error {
+                    error_buf.init(err);
+                }
+            }
+            DeviceAction::RenderPipelineGetBindGroupLayout(pipeline_id, index, bgl_id) => {
+                let (_, error) = self.render_pipeline_get_bind_group_layout::<A>(
+                    pipeline_id,
+                    index,
+                    Some(bgl_id),
+                );
+                if let Some(err) = error {
+                    error_buf.init(err);
+                }
+            }
+            DeviceAction::ComputePipelineGetBindGroupLayout(pipeline_id, index, bgl_id) => {
+                let (_, error) = self.compute_pipeline_get_bind_group_layout::<A>(
+                    pipeline_id,
+                    index,
+                    Some(bgl_id),
+                );
+                if let Some(err) = error {
+                    error_buf.init(err);
+                }
+            }
+            DeviceAction::CreatePipelineLayout(id, desc) => {
+                let (_, error) = self.device_create_pipeline_layout::<A>(self_id, &desc, Some(id));
+                if let Some(err) = error {
+                    error_buf.init(err);
+                }
+            }
+            DeviceAction::CreateBindGroup(id, desc) => {
+                let (_, error) = self.device_create_bind_group::<A>(self_id, &desc, Some(id));
+                if let Some(err) = error {
+                    error_buf.init(err);
+                }
+            }
+            DeviceAction::CreateShaderModule(id, desc, code) => {
+                let source = wgc::pipeline::ShaderModuleSource::Wgsl(code);
+                let (_, error) =
+                    self.device_create_shader_module::<A>(self_id, &desc, source, Some(id));
+                if let Some(err) = error {
+                    error_buf.init(err);
+                }
+            }
+            DeviceAction::CreateComputePipeline(id, desc, implicit) => {
+                let implicit_ids = implicit
+                    .as_ref()
+                    .map(|imp| wgc::device::ImplicitPipelineIds {
+                        root_id: Some(imp.pipeline),
+                        group_ids: &imp.bind_groups,
+                    });
+                let (_, error) = self.device_create_compute_pipeline::<A>(
+                    self_id,
+                    &desc,
+                    Some(id),
+                    implicit_ids,
+                );
+                if let Some(err) = error {
+                    error_buf.init(err);
+                }
+            }
+            DeviceAction::CreateRenderPipeline(id, desc, implicit) => {
+                let implicit_ids = implicit
+                    .as_ref()
+                    .map(|imp| wgc::device::ImplicitPipelineIds {
+                        root_id: Some(imp.pipeline),
+                        group_ids: &imp.bind_groups,
+                    });
+                let (_, error) =
+                    self.device_create_render_pipeline::<A>(self_id, &desc, Some(id), implicit_ids);
+                if let Some(err) = error {
+                    error_buf.init(err);
+                }
+            }
+            DeviceAction::CreateRenderBundle(id, encoder, desc) => {
+                let (_, error) = self.render_bundle_encoder_finish::<A>(encoder, &desc, Some(id));
+                if let Some(err) = error {
+                    error_buf.init(err);
+                }
+            }
+            DeviceAction::CreateRenderBundleError(buffer_id, label) => {
+                self.create_render_bundle_error::<A>(Some(buffer_id), label);
+            }
+            DeviceAction::CreateCommandEncoder(id, desc) => {
+                let (_, error) = self.device_create_command_encoder::<A>(self_id, &desc, Some(id));
+                if let Some(err) = error {
+                    error_buf.init(err);
+                }
+            }
+            DeviceAction::Error { message, r#type } => {
+                error_buf.init(ErrMsg {
+                    message: &message,
+                    r#type,
+                });
+            }
+        }
+    }
+
+    fn texture_action<A: wgc::hal_api::HalApi>(
+        &self,
+        self_id: id::TextureId,
+        action: TextureAction,
+        mut error_buf: ErrorBuffer,
+    ) {
+        match action {
+            TextureAction::CreateView(id, desc) => {
+                let (_, error) = self.texture_create_view::<A>(self_id, &desc, Some(id));
+                if let Some(err) = error {
+                    error_buf.init(err);
+                }
+            }
+        }
+    }
+
+    fn command_encoder_action<A: wgc::hal_api::HalApi>(
+        &self,
+        self_id: id::CommandEncoderId,
+        action: CommandEncoderAction,
+        mut error_buf: ErrorBuffer,
+    ) {
+        match action {
+            CommandEncoderAction::CopyBufferToBuffer {
+                src,
+                src_offset,
+                dst,
+                dst_offset,
+                size,
+            } => {
+                if let Err(err) = self.command_encoder_copy_buffer_to_buffer::<A>(
+                    self_id, src, src_offset, dst, dst_offset, size,
+                ) {
+                    error_buf.init(err);
+                }
+            }
+            CommandEncoderAction::CopyBufferToTexture { src, dst, size } => {
+                if let Err(err) =
+                    self.command_encoder_copy_buffer_to_texture::<A>(self_id, &src, &dst, &size)
+                {
+                    error_buf.init(err);
+                }
+            }
+            CommandEncoderAction::CopyTextureToBuffer { src, dst, size } => {
+                if let Err(err) =
+                    self.command_encoder_copy_texture_to_buffer::<A>(self_id, &src, &dst, &size)
+                {
+                    error_buf.init(err);
+                }
+            }
+            CommandEncoderAction::CopyTextureToTexture { src, dst, size } => {
+                if let Err(err) =
+                    self.command_encoder_copy_texture_to_texture::<A>(self_id, &src, &dst, &size)
+                {
+                    error_buf.init(err);
+                }
+            }
+            CommandEncoderAction::RunComputePass {
+                base,
+                timestamp_writes,
+            } => {
+                if let Err(err) = self.command_encoder_run_compute_pass_impl::<A>(
+                    self_id,
+                    base.as_ref(),
+                    timestamp_writes.as_ref(),
+                ) {
+                    error_buf.init(err);
+                }
+            }
+            CommandEncoderAction::WriteTimestamp {
+                query_set_id,
+                query_index,
+            } => {
+                if let Err(err) =
+                    self.command_encoder_write_timestamp::<A>(self_id, query_set_id, query_index)
+                {
+                    error_buf.init(err);
+                }
+            }
+            CommandEncoderAction::ResolveQuerySet {
+                query_set_id,
+                start_query,
+                query_count,
+                destination,
+                destination_offset,
+            } => {
+                if let Err(err) = self.command_encoder_resolve_query_set::<A>(
+                    self_id,
+                    query_set_id,
+                    start_query,
+                    query_count,
+                    destination,
+                    destination_offset,
+                ) {
+                    error_buf.init(err);
+                }
+            }
+            CommandEncoderAction::RunRenderPass {
+                base,
+                target_colors,
+                target_depth_stencil,
+                timestamp_writes,
+                occlusion_query_set_id,
+            } => {
+                if let Err(err) = self.command_encoder_run_render_pass_impl::<A>(
+                    self_id,
+                    base.as_ref(),
+                    &target_colors,
+                    target_depth_stencil.as_ref(),
+                    timestamp_writes.as_ref(),
+                    occlusion_query_set_id,
+                ) {
+                    error_buf.init(err);
+                }
+            }
+            CommandEncoderAction::ClearBuffer { dst, offset, size } => {
+                if let Err(err) = self.command_encoder_clear_buffer::<A>(self_id, dst, offset, size)
+                {
+                    error_buf.init(err);
+                }
+            }
+            CommandEncoderAction::ClearTexture {
+                dst,
+                ref subresource_range,
+            } => {
+                if let Err(err) =
+                    self.command_encoder_clear_texture::<A>(self_id, dst, subresource_range)
+                {
+                    error_buf.init(err);
+                }
+            }
+            CommandEncoderAction::PushDebugGroup(marker) => {
+                if let Err(err) = self.command_encoder_push_debug_group::<A>(self_id, &marker) {
+                    error_buf.init(err);
+                }
+            }
+            CommandEncoderAction::PopDebugGroup => {
+                if let Err(err) = self.command_encoder_pop_debug_group::<A>(self_id) {
+                    error_buf.init(err);
+                }
+            }
+            CommandEncoderAction::InsertDebugMarker(marker) => {
+                if let Err(err) = self.command_encoder_insert_debug_marker::<A>(self_id, &marker) {
+                    error_buf.init(err);
+                }
+            }
+        }
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wgpu_server_device_action(
+    global: &Global,
+    self_id: id::DeviceId,
+    byte_buf: &ByteBuf,
+    error_buf: ErrorBuffer,
+) {
+    let action = bincode::deserialize(byte_buf.as_slice()).unwrap();
+    gfx_select!(self_id => global.device_action(self_id, action, error_buf));
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wgpu_server_texture_action(
+    global: &Global,
+    self_id: id::TextureId,
+    byte_buf: &ByteBuf,
+    error_buf: ErrorBuffer,
+) {
+    let action = bincode::deserialize(byte_buf.as_slice()).unwrap();
+    gfx_select!(self_id => global.texture_action(self_id, action, error_buf));
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wgpu_server_command_encoder_action(
+    global: &Global,
+    self_id: id::CommandEncoderId,
+    byte_buf: &ByteBuf,
+    error_buf: ErrorBuffer,
+) {
+    let action = bincode::deserialize(byte_buf.as_slice()).unwrap();
+    gfx_select!(self_id => global.command_encoder_action(self_id, action, error_buf));
+}
+
+#[no_mangle]
+pub extern "C" fn wgpu_server_device_create_encoder(
+    global: &Global,
+    self_id: id::DeviceId,
+    desc: &wgt::CommandEncoderDescriptor<Option<&nsACString>>,
+    new_id: id::CommandEncoderId,
+    mut error_buf: ErrorBuffer,
+) {
+    let utf8_label = desc.label.map(|utf16| utf16.to_string());
+    let label = utf8_label.as_ref().map(|s| Cow::from(&s[..]));
+
+    let desc = desc.map_label(|_| label);
+    let (_, error) =
+        gfx_select!(self_id => global.device_create_command_encoder(self_id, &desc, Some(new_id)));
+    if let Some(err) = error {
+        error_buf.init(err);
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn wgpu_server_encoder_finish(
+    global: &Global,
+    self_id: id::CommandEncoderId,
+    desc: &wgt::CommandBufferDescriptor<Option<&nsACString>>,
+    mut error_buf: ErrorBuffer,
+) {
+    let label = wgpu_string(desc.label);
+    let desc = desc.map_label(|_| label);
+    let (_, error) = gfx_select!(self_id => global.command_encoder_finish(self_id, &desc));
+    if let Some(err) = error {
+        error_buf.init(err);
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn wgpu_server_encoder_drop(global: &Global, self_id: id::CommandEncoderId) {
+    gfx_select!(self_id => global.command_encoder_drop(self_id));
+}
+
+#[no_mangle]
+pub extern "C" fn wgpu_server_render_bundle_drop(global: &Global, self_id: id::RenderBundleId) {
+    gfx_select!(self_id => global.render_bundle_drop(self_id));
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wgpu_server_encoder_copy_texture_to_buffer(
+    global: &Global,
+    self_id: id::CommandEncoderId,
+    source: &wgc::command::ImageCopyTexture,
+    dst_buffer: wgc::id::BufferId,
+    dst_layout: &crate::ImageDataLayout,
+    size: &wgt::Extent3d,
+    mut error_buf: ErrorBuffer,
+) {
+    let destination = wgc::command::ImageCopyBuffer {
+        buffer: dst_buffer,
+        layout: dst_layout.into_wgt(),
+    };
+    if let Err(err) = gfx_select!(self_id => global.command_encoder_copy_texture_to_buffer(self_id, source, &destination, size))
+    {
+        error_buf.init(err);
+    }
+}
+
+/// # Safety
+///
+/// This function is unsafe as there is no guarantee that the given pointer is
+/// valid for `command_buffer_id_length` elements.
+#[no_mangle]
+pub unsafe extern "C" fn wgpu_server_queue_submit(
+    global: &Global,
+    self_id: id::QueueId,
+    command_buffer_ids: *const id::CommandBufferId,
+    command_buffer_id_length: usize,
+    mut error_buf: ErrorBuffer,
+) -> u64 {
+    let command_buffers = slice::from_raw_parts(command_buffer_ids, command_buffer_id_length);
+    let result = gfx_select!(self_id => global.queue_submit(self_id, command_buffers));
+
+    match result {
+        Err(err) => {
+            error_buf.init(err);
+            return 0;
+        }
+        Ok(wrapped_index) => wrapped_index.index,
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wgpu_server_on_submitted_work_done(
+    global: &Global,
+    self_id: id::QueueId,
+    callback: wgc::device::queue::SubmittedWorkDoneClosureC,
+) {
+    gfx_select!(self_id => global.queue_on_submitted_work_done(self_id, wgc::device::queue::SubmittedWorkDoneClosure::from_c(callback))).unwrap();
+}
+
+/// # Safety
+///
+/// This function is unsafe as there is no guarantee that the given pointer is
+/// valid for `data_length` elements.
+#[no_mangle]
+pub unsafe extern "C" fn wgpu_server_queue_write_action(
+    global: &Global,
+    self_id: id::QueueId,
+    byte_buf: &ByteBuf,
+    data: *const u8,
+    data_length: usize,
+    mut error_buf: ErrorBuffer,
+) {
+    let action: QueueWriteAction = bincode::deserialize(byte_buf.as_slice()).unwrap();
+    let data = slice::from_raw_parts(data, data_length);
+    let result = match action {
+        QueueWriteAction::Buffer { dst, offset } => {
+            gfx_select!(self_id => global.queue_write_buffer(self_id, dst, offset, data))
+        }
+        QueueWriteAction::Texture { dst, layout, size } => {
+            gfx_select!(self_id => global.queue_write_texture(self_id, &dst, data, &layout, &size))
+        }
+    };
+    if let Err(err) = result {
+        error_buf.init(err);
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn wgpu_server_bind_group_layout_drop(
+    global: &Global,
+    self_id: id::BindGroupLayoutId,
+) {
+    gfx_select!(self_id => global.bind_group_layout_drop(self_id));
+}
+
+#[no_mangle]
+pub extern "C" fn wgpu_server_pipeline_layout_drop(global: &Global, self_id: id::PipelineLayoutId) {
+    gfx_select!(self_id => global.pipeline_layout_drop(self_id));
+}
+
+#[no_mangle]
+pub extern "C" fn wgpu_server_bind_group_drop(global: &Global, self_id: id::BindGroupId) {
+    gfx_select!(self_id => global.bind_group_drop(self_id));
+}
+
+#[no_mangle]
+pub extern "C" fn wgpu_server_shader_module_drop(global: &Global, self_id: id::ShaderModuleId) {
+    gfx_select!(self_id => global.shader_module_drop(self_id));
+}
+
+#[no_mangle]
+pub extern "C" fn wgpu_server_compute_pipeline_drop(
+    global: &Global,
+    self_id: id::ComputePipelineId,
+) {
+    gfx_select!(self_id => global.compute_pipeline_drop(self_id));
+}
+
+#[no_mangle]
+pub extern "C" fn wgpu_server_render_pipeline_drop(global: &Global, self_id: id::RenderPipelineId) {
+    gfx_select!(self_id => global.render_pipeline_drop(self_id));
+}
+
+#[no_mangle]
+pub extern "C" fn wgpu_server_texture_destroy(global: &Global, self_id: id::TextureId) {
+    let _ = gfx_select!(self_id => global.texture_destroy(self_id));
+}
+
+#[no_mangle]
+pub extern "C" fn wgpu_server_texture_drop(global: &Global, self_id: id::TextureId) {
+    gfx_select!(self_id => global.texture_drop(self_id, false));
+}
+
+#[no_mangle]
+pub extern "C" fn wgpu_server_texture_view_drop(global: &Global, self_id: id::TextureViewId) {
+    gfx_select!(self_id => global.texture_view_drop(self_id, false)).unwrap();
+}
+
+#[no_mangle]
+pub extern "C" fn wgpu_server_sampler_drop(global: &Global, self_id: id::SamplerId) {
+    gfx_select!(self_id => global.sampler_drop(self_id));
+}
+
+#[no_mangle]
+pub extern "C" fn wgpu_server_compute_pipeline_get_bind_group_layout(
+    global: &Global,
+    self_id: id::ComputePipelineId,
+    index: u32,
+    assign_id: id::BindGroupLayoutId,
+    mut error_buf: ErrorBuffer,
+) {
+    let (_, error) = gfx_select!(self_id => global.compute_pipeline_get_bind_group_layout(self_id, index, Some(assign_id)));
+    if let Some(err) = error {
+        error_buf.init(err);
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn wgpu_server_render_pipeline_get_bind_group_layout(
+    global: &Global,
+    self_id: id::RenderPipelineId,
+    index: u32,
+    assign_id: id::BindGroupLayoutId,
+    mut error_buf: ErrorBuffer,
+) {
+    let (_, error) = gfx_select!(self_id => global.render_pipeline_get_bind_group_layout(self_id, index, Some(assign_id)));
+    if let Some(err) = error {
+        error_buf.init(err);
+    }
+}
+
+/// Encode the freeing of the selected ID into a byte buf.
+#[no_mangle]
+pub extern "C" fn wgpu_server_adapter_free(id: id::AdapterId, drop_byte_buf: &mut ByteBuf) {
+    *drop_byte_buf = DropAction::Adapter(id).to_byte_buf();
+}
+#[no_mangle]
+pub extern "C" fn wgpu_server_device_free(id: id::DeviceId, drop_byte_buf: &mut ByteBuf) {
+    *drop_byte_buf = DropAction::Device(id).to_byte_buf();
+}
+#[no_mangle]
+pub extern "C" fn wgpu_server_shader_module_free(
+    id: id::ShaderModuleId,
+    drop_byte_buf: &mut ByteBuf,
+) {
+    *drop_byte_buf = DropAction::ShaderModule(id).to_byte_buf();
+}
+#[no_mangle]
+pub extern "C" fn wgpu_server_pipeline_layout_free(
+    id: id::PipelineLayoutId,
+    drop_byte_buf: &mut ByteBuf,
+) {
+    *drop_byte_buf = DropAction::PipelineLayout(id).to_byte_buf();
+}
+#[no_mangle]
+pub extern "C" fn wgpu_server_bind_group_layout_free(
+    id: id::BindGroupLayoutId,
+    drop_byte_buf: &mut ByteBuf,
+) {
+    *drop_byte_buf = DropAction::BindGroupLayout(id).to_byte_buf();
+}
+#[no_mangle]
+pub extern "C" fn wgpu_server_bind_group_free(id: id::BindGroupId, drop_byte_buf: &mut ByteBuf) {
+    *drop_byte_buf = DropAction::BindGroup(id).to_byte_buf();
+}
+#[no_mangle]
+pub extern "C" fn wgpu_server_command_buffer_free(
+    id: id::CommandBufferId,
+    drop_byte_buf: &mut ByteBuf,
+) {
+    *drop_byte_buf = DropAction::CommandBuffer(id).to_byte_buf();
+}
+#[no_mangle]
+pub extern "C" fn wgpu_server_render_bundle_free(
+    id: id::RenderBundleId,
+    drop_byte_buf: &mut ByteBuf,
+) {
+    *drop_byte_buf = DropAction::RenderBundle(id).to_byte_buf();
+}
+#[no_mangle]
+pub extern "C" fn wgpu_server_render_pipeline_free(
+    id: id::RenderPipelineId,
+    drop_byte_buf: &mut ByteBuf,
+) {
+    *drop_byte_buf = DropAction::RenderPipeline(id).to_byte_buf();
+}
+#[no_mangle]
+pub extern "C" fn wgpu_server_compute_pipeline_free(
+    id: id::ComputePipelineId,
+    drop_byte_buf: &mut ByteBuf,
+) {
+    *drop_byte_buf = DropAction::ComputePipeline(id).to_byte_buf();
+}
+#[no_mangle]
+pub extern "C" fn wgpu_server_buffer_free(id: id::BufferId, drop_byte_buf: &mut ByteBuf) {
+    *drop_byte_buf = DropAction::Buffer(id).to_byte_buf();
+}
+#[no_mangle]
+pub extern "C" fn wgpu_server_texture_free(id: id::TextureId, drop_byte_buf: &mut ByteBuf) {
+    *drop_byte_buf = DropAction::Texture(id).to_byte_buf();
+}
+#[no_mangle]
+pub extern "C" fn wgpu_server_texture_view_free(
+    id: id::TextureViewId,
+    drop_byte_buf: &mut ByteBuf,
+) {
+    *drop_byte_buf = DropAction::TextureView(id).to_byte_buf();
+}
+#[no_mangle]
+pub extern "C" fn wgpu_server_sampler_free(id: id::SamplerId, drop_byte_buf: &mut ByteBuf) {
+    *drop_byte_buf = DropAction::Sampler(id).to_byte_buf();
+}