diff --git a/player/src/lib.rs b/player/src/lib.rs
index f39e8df3a..5d52748bf 100644
--- a/player/src/lib.rs
+++ b/player/src/lib.rs
@@ -12,7 +12,7 @@
 
 use wgc::device::trace;
 
-use std::{borrow::Cow, ffi::CString, fmt::Debug, fs, marker::PhantomData, path::Path, ptr};
+use std::{borrow::Cow, fmt::Debug, fs, marker::PhantomData, path::Path};
 
 #[macro_export]
 macro_rules! gfx_select {
@@ -31,24 +31,6 @@ macro_rules! gfx_select {
     };
 }
 
-struct Label(Option<CString>);
-impl Label {
-    fn new(text: &str) -> Self {
-        Self(if text.is_empty() {
-            None
-        } else {
-            Some(CString::new(text).expect("invalid label"))
-        })
-    }
-
-    fn as_ptr(&self) -> *const std::os::raw::c_char {
-        match self.0 {
-            Some(ref c_string) => c_string.as_ptr(),
-            None => ptr::null(),
-        }
-    }
-}
-
 #[derive(Debug)]
 pub struct IdentityPassThrough<I>(PhantomData<I>);
 
@@ -135,7 +117,7 @@ impl GlobalPlay for wgc::hub::Global<IdentityPassThroughFactory> {
                 }
             }
         }
-        self.command_encoder_finish::<B>(encoder, &wgt::CommandBufferDescriptor { todo: 0 })
+        self.command_encoder_finish::<B>(encoder, &wgt::CommandBufferDescriptor { label: None })
             .unwrap()
     }
 
@@ -154,19 +136,15 @@ impl GlobalPlay for wgc::hub::Global<IdentityPassThroughFactory> {
                 panic!("Unexpected SwapChain action: winit feature is not enabled")
             }
             A::CreateBuffer(id, desc) => {
-                let label = Label::new(&desc.label);
                 self.device_maintain_ids::<B>(device).unwrap();
-                self.device_create_buffer::<B>(device, &desc.map_label(|_| label.as_ptr()), id)
-                    .unwrap();
+                self.device_create_buffer::<B>(device, &desc, id).unwrap();
             }
             A::DestroyBuffer(id) => {
                 self.buffer_drop::<B>(id, true);
             }
             A::CreateTexture(id, desc) => {
-                let label = Label::new(&desc.label);
                 self.device_maintain_ids::<B>(device).unwrap();
-                self.device_create_texture::<B>(device, &desc.map_label(|_| label.as_ptr()), id)
-                    .unwrap();
+                self.device_create_texture::<B>(device, &desc, id).unwrap();
             }
             A::DestroyTexture(id) => {
                 self.texture_drop::<B>(id);
@@ -176,23 +154,15 @@ impl GlobalPlay for wgc::hub::Global<IdentityPassThroughFactory> {
                 parent_id,
                 desc,
             } => {
-                let label = desc.as_ref().map_or(Label(None), |d| Label::new(&d.label));
                 self.device_maintain_ids::<B>(device).unwrap();
-                self.texture_create_view::<B>(
-                    parent_id,
-                    desc.map(|d| d.map_label(|_| label.as_ptr())).as_ref(),
-                    id,
-                )
-                .unwrap();
+                self.texture_create_view::<B>(parent_id, &desc, id).unwrap();
             }
             A::DestroyTextureView(id) => {
                 self.texture_view_drop::<B>(id).unwrap();
             }
             A::CreateSampler(id, desc) => {
-                let label = Label::new(&desc.label);
                 self.device_maintain_ids::<B>(device).unwrap();
-                self.device_create_sampler::<B>(device, &desc.map_label(|_| label.as_ptr()), id)
-                    .unwrap();
+                self.device_create_sampler::<B>(device, &desc, id).unwrap();
             }
             A::DestroySampler(id) => {
                 self.sampler_drop::<B>(id);
@@ -263,14 +233,11 @@ impl GlobalPlay for wgc::hub::Global<IdentityPassThroughFactory> {
                 self.render_pipeline_drop::<B>(id);
             }
             A::CreateRenderBundle { id, desc, base } => {
-                let label = Label::new(&desc.label.as_ref().unwrap());
                 let bundle =
                     wgc::command::RenderBundleEncoder::new(&desc, device, Some(base)).unwrap();
                 self.render_bundle_encoder_finish::<B>(
                     bundle,
-                    &wgt::RenderBundleDescriptor {
-                        label: label.as_ptr(),
-                    },
+                    &wgt::RenderBundleDescriptor { label: desc.label },
                     id,
                 )
                 .unwrap();
@@ -309,7 +276,7 @@ impl GlobalPlay for wgc::hub::Global<IdentityPassThroughFactory> {
                 let encoder = self
                     .device_create_command_encoder::<B>(
                         device,
-                        &wgt::CommandEncoderDescriptor { label: ptr::null() },
+                        &wgt::CommandEncoderDescriptor { label: None },
                         comb_manager.alloc(device.backend()),
                     )
                     .unwrap();
diff --git a/player/tests/data/buffer-copy.ron b/player/tests/data/buffer-copy.ron
index e0b606978..d8f598fe9 100644
--- a/player/tests/data/buffer-copy.ron
+++ b/player/tests/data/buffer-copy.ron
@@ -12,7 +12,7 @@
         CreateBuffer(
             Id(0, 1, Empty),
             (
-                label: "",
+                label: Some("dummy"),
                 size: 16,
                 usage: (
                     bits: 41,
diff --git a/wgpu-core/src/binding_model.rs b/wgpu-core/src/binding_model.rs
index acafe3903..3c6841560 100644
--- a/wgpu-core/src/binding_model.rs
+++ b/wgpu-core/src/binding_model.rs
@@ -7,7 +7,7 @@ use crate::{
     id::{BindGroupLayoutId, BufferId, DeviceId, SamplerId, TextureViewId, Valid},
     track::{TrackerSet, DUMMY_SELECTOR},
     validation::{MissingBufferUsageError, MissingTextureUsageError},
-    FastHashMap, LifeGuard, MultiRefCount, RefCount, Stored, MAX_BIND_GROUPS,
+    FastHashMap, Label, LifeGuard, MultiRefCount, RefCount, Stored, MAX_BIND_GROUPS,
 };
 
 use arrayvec::ArrayVec;
@@ -182,7 +182,7 @@ pub(crate) struct BindingTypeMaxCountValidator {
 
 impl BindingTypeMaxCountValidator {
     pub(crate) fn add_binding(&mut self, binding: &wgt::BindGroupLayoutEntry) {
-        let count = binding.count.unwrap_or(1);
+        let count = binding.count.map_or(1, |count| count.get());
         match binding.ty {
             wgt::BindingType::UniformBuffer { dynamic, .. } => {
                 self.uniform_buffers.add(binding.visibility, count);
@@ -261,6 +261,42 @@ impl BindingTypeMaxCountValidator {
     }
 }
 
+/// Bindable resource and the slot to bind it to.
+#[derive(Clone, Debug)]
+#[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
+pub struct BindGroupEntry<'a> {
+    /// Slot for which binding provides resource. Corresponds to an entry of the same
+    /// binding index in the [`BindGroupLayoutDescriptor`].
+    pub binding: u32,
+    /// Resource to attach to the binding
+    pub resource: BindingResource<'a>,
+}
+
+/// Describes a group of bindings and the resources to be bound.
+#[derive(Clone, Debug)]
+#[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
+pub struct BindGroupDescriptor<'a> {
+    /// Debug label of the bind group. This will show up in graphics debuggers for easy identification.
+    pub label: Label<'a>,
+    /// The [`BindGroupLayout`] that corresponds to this bind group.
+    pub layout: BindGroupLayoutId,
+    /// The resources to bind to this bind group.
+    pub entries: Cow<'a, [BindGroupEntry<'a>]>,
+}
+
+/// Describes a [`BindGroupLayout`].
+#[derive(Clone, Debug)]
+#[cfg_attr(feature = "trace", derive(serde::Serialize))]
+#[cfg_attr(feature = "replay", derive(serde::Deserialize))]
+pub struct BindGroupLayoutDescriptor<'a> {
+    /// Debug label of the bind group layout. This will show up in graphics debuggers for easy identification.
+    pub label: Label<'a>,
+    /// Array of entries in this BindGroupLayout
+    pub entries: Cow<'a, [wgt::BindGroupLayoutEntry]>,
+}
+
 pub(crate) type BindEntryMap = FastHashMap<u32, wgt::BindGroupLayoutEntry>;
 
 #[derive(Debug)]
@@ -335,6 +371,26 @@ pub enum PushConstantUploadError {
     Unaligned(u32),
 }
 
+/// Describes a pipeline layout.
+///
+/// A `PipelineLayoutDescriptor` can be used to create a pipeline layout.
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
+pub struct PipelineLayoutDescriptor<'a> {
+    /// Debug label of the pipeine layout. This will show up in graphics debuggers for easy identification.
+    pub label: Label<'a>,
+    /// Bind groups that this pipeline uses. The first entry will provide all the bindings for
+    /// "set = 0", second entry will provide all the bindings for "set = 1" etc.
+    pub bind_group_layouts: Cow<'a, [BindGroupLayoutId]>,
+    /// Set of push constant ranges this pipeline uses. Each shader stage that uses push constants
+    /// must define the range in push constant memory that corresponds to its single `layout(push_constant)`
+    /// uniform block.
+    ///
+    /// If this array is non-empty, the [`Features::PUSH_CONSTANTS`] must be enabled.
+    pub push_constant_ranges: Cow<'a, [wgt::PushConstantRange]>,
+}
+
 #[derive(Debug)]
 pub struct PipelineLayout<B: hal::Backend> {
     pub(crate) raw: B::PipelineLayout,
@@ -446,11 +502,6 @@ pub enum BindingResource<'a> {
     TextureViewArray(Cow<'a, [TextureViewId]>),
 }
 
-pub type BindGroupEntry<'a> = wgt::BindGroupEntry<BindingResource<'a>>;
-
-pub type BindGroupDescriptor<'a> =
-    wgt::BindGroupDescriptor<'a, BindGroupLayoutId, BindGroupEntry<'a>>;
-
 #[derive(Clone, Debug, Error)]
 pub enum BindError {
     #[error("number of dynamic offsets ({actual}) doesn't match the number of dynamic bindings in the bind group layout ({expected})")]
diff --git a/wgpu-core/src/command/bundle.rs b/wgpu-core/src/command/bundle.rs
index 4279ffdba..4947cdc49 100644
--- a/wgpu-core/src/command/bundle.rs
+++ b/wgpu-core/src/command/bundle.rs
@@ -41,8 +41,7 @@ use crate::{
     command::{BasePass, DrawError, RenderCommand, RenderCommandError},
     conv,
     device::{
-        AttachmentData, DeviceError, Label, RenderPassContext, MAX_VERTEX_BUFFERS,
-        SHADER_STAGE_COUNT,
+        AttachmentData, DeviceError, RenderPassContext, MAX_VERTEX_BUFFERS, SHADER_STAGE_COUNT,
     },
     hub::{GfxBackend, Global, GlobalIdentityHandlerFactory, Input, Storage, Token},
     id,
@@ -50,12 +49,35 @@ use crate::{
     span,
     track::TrackerSet,
     validation::check_buffer_usage,
-    LifeGuard, RefCount, Stored, MAX_BIND_GROUPS,
+    Label, LifeGuard, RefCount, Stored, MAX_BIND_GROUPS,
 };
 use arrayvec::ArrayVec;
-use std::{borrow::Borrow, iter, marker::PhantomData, ops::Range};
+use std::{
+    borrow::{Borrow, Cow},
+    iter,
+    marker::PhantomData,
+    ops::Range,
+};
 use thiserror::Error;
 
+/// Describes a [`RenderBundleEncoder`].
+#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "trace", derive(serde::Serialize))]
+#[cfg_attr(feature = "replay", derive(serde::Deserialize))]
+pub struct RenderBundleEncoderDescriptor<'a> {
+    /// Debug label of the render bundle encoder. This will show up in graphics debuggers for easy identification.
+    pub label: Label<'a>,
+    /// The formats of the color attachments that this render bundle is capable to rendering to. This
+    /// must match the formats of the color attachments in the renderpass this render bundle is executed in.
+    pub color_formats: Cow<'a, [wgt::TextureFormat]>,
+    /// The formats of the depth attachment that this render bundle is capable to rendering to. This
+    /// must match the formats of the depth attachments in the renderpass this render bundle is executed in.
+    pub depth_stencil_format: Option<wgt::TextureFormat>,
+    /// Sample count this render bundle is capable of rendering to. This must match the pipelines and
+    /// the renderpasses it is used in.
+    pub sample_count: u32,
+}
+
 #[derive(Debug)]
 #[cfg_attr(feature = "serial-pass", derive(serde::Deserialize, serde::Serialize))]
 pub struct RenderBundleEncoder {
@@ -66,7 +88,7 @@ pub struct RenderBundleEncoder {
 
 impl RenderBundleEncoder {
     pub fn new(
-        desc: &wgt::RenderBundleEncoderDescriptor,
+        desc: &RenderBundleEncoderDescriptor,
         parent_id: id::DeviceId,
         base: Option<BasePass<RenderCommand>>,
     ) -> Result<Self, CreateRenderBundleError> {
@@ -103,6 +125,8 @@ pub enum CreateRenderBundleError {
     InvalidSampleCount(u32),
 }
 
+pub type RenderBundleDescriptor<'a> = wgt::RenderBundleDescriptor<Label<'a>>;
+
 //Note: here, `RenderBundle` is just wrapping a raw stream of render commands.
 // The plan is to back it by an actual Vulkan secondary buffer, D3D12 Bundle,
 // or Metal indirect command buffer.
@@ -613,7 +637,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
     pub fn render_bundle_encoder_finish<B: GfxBackend>(
         &self,
         bundle_encoder: RenderBundleEncoder,
-        desc: &wgt::RenderBundleDescriptor<Label>,
+        desc: &RenderBundleDescriptor,
         id_in: Input<G, id::RenderBundleId>,
     ) -> Result<id::RenderBundleId, RenderBundleError> {
         span!(_guard, INFO, "RenderBundleEncoder::finish");
@@ -908,9 +932,10 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
                 use crate::device::trace;
                 let (bundle_guard, _) = hub.render_bundles.read(&mut token);
                 let bundle = &bundle_guard[id];
+                let label = desc.label.as_ref().map(|l| l.as_ref());
                 trace.lock().add(trace::Action::CreateRenderBundle {
                     id: id.0,
-                    desc: trace::new_render_bundle_encoder_descriptor(desc.label, &bundle.context),
+                    desc: trace::new_render_bundle_encoder_descriptor(label, &bundle.context),
                     base: BasePass::from_ref(bundle.base.as_ref()),
                 });
             }
diff --git a/wgpu-core/src/command/mod.rs b/wgpu-core/src/command/mod.rs
index 303c9d8b3..14b199332 100644
--- a/wgpu-core/src/command/mod.rs
+++ b/wgpu-core/src/command/mod.rs
@@ -25,7 +25,7 @@ use crate::{
     resource::{Buffer, Texture},
     span,
     track::TrackerSet,
-    PrivateFeatures, Stored,
+    Label, PrivateFeatures, Stored,
 };
 
 use hal::command::CommandBuffer as _;
@@ -168,7 +168,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
     pub fn command_encoder_finish<B: GfxBackend>(
         &self,
         encoder_id: id::CommandEncoderId,
-        _desc: &wgt::CommandBufferDescriptor,
+        _desc: &wgt::CommandBufferDescriptor<Label>,
     ) -> Result<id::CommandBufferId, CommandEncoderError> {
         span!(_guard, INFO, "CommandEncoder::finish");
 
diff --git a/wgpu-core/src/command/render.rs b/wgpu-core/src/command/render.rs
index 5126c8c8b..55726acf5 100644
--- a/wgpu-core/src/command/render.rs
+++ b/wgpu-core/src/command/render.rs
@@ -37,7 +37,14 @@ use serde::Deserialize;
 #[cfg(any(feature = "serial-pass", feature = "trace"))]
 use serde::Serialize;
 
-use std::{borrow::Borrow, collections::hash_map::Entry, fmt, iter, ops::Range, str};
+use std::{
+    borrow::{Borrow, Cow},
+    collections::hash_map::Entry,
+    fmt, iter,
+    num::NonZeroU32,
+    ops::Range,
+    str,
+};
 
 /// Operation to perform to the output attachment at the start of a renderpass.
 #[repr(C)]
@@ -65,7 +72,7 @@ pub enum StoreOp {
 
 /// Describes an individual channel within a render pass, such as color, depth, or stencil.
 #[repr(C)]
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq)]
 #[cfg_attr(any(feature = "serial-pass", feature = "trace"), derive(Serialize))]
 #[cfg_attr(any(feature = "serial-pass", feature = "replay"), derive(Deserialize))]
 pub struct PassChannel<V> {
@@ -83,7 +90,7 @@ pub struct PassChannel<V> {
 
 /// Describes a color attachment to a render pass.
 #[repr(C)]
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq)]
 #[cfg_attr(any(feature = "serial-pass", feature = "trace"), derive(Serialize))]
 #[cfg_attr(any(feature = "serial-pass", feature = "replay"), derive(Deserialize))]
 pub struct ColorAttachmentDescriptor {
@@ -97,7 +104,7 @@ pub struct ColorAttachmentDescriptor {
 
 /// Describes a depth/stencil attachment to a render pass.
 #[repr(C)]
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq)]
 #[cfg_attr(any(feature = "serial-pass", feature = "trace"), derive(Serialize))]
 #[cfg_attr(any(feature = "serial-pass", feature = "replay"), derive(Deserialize))]
 pub struct DepthStencilAttachmentDescriptor {
@@ -109,27 +116,32 @@ pub struct DepthStencilAttachmentDescriptor {
     pub stencil: PassChannel<u32>,
 }
 
-fn is_depth_stencil_read_only(
-    desc: &DepthStencilAttachmentDescriptor,
-    aspects: hal::format::Aspects,
-) -> Result<bool, RenderPassError> {
-    if aspects.contains(hal::format::Aspects::DEPTH) && !desc.depth.read_only {
-        return Ok(false);
+impl DepthStencilAttachmentDescriptor {
+    fn is_read_only(&self, aspects: hal::format::Aspects) -> Result<bool, RenderPassError> {
+        if aspects.contains(hal::format::Aspects::DEPTH) && !self.depth.read_only {
+            return Ok(false);
+        }
+        if (self.depth.load_op, self.depth.store_op) != (LoadOp::Load, StoreOp::Store) {
+            return Err(RenderPassError::InvalidDepthOps);
+        }
+        if aspects.contains(hal::format::Aspects::STENCIL) && !self.stencil.read_only {
+            return Ok(false);
+        }
+        if (self.stencil.load_op, self.stencil.store_op) != (LoadOp::Load, StoreOp::Store) {
+            return Err(RenderPassError::InvalidStencilOps);
+        }
+        Ok(true)
     }
-    if (desc.depth.load_op, desc.depth.store_op) != (LoadOp::Load, StoreOp::Store) {
-        return Err(RenderPassError::InvalidDepthOps);
-    }
-    if aspects.contains(hal::format::Aspects::STENCIL) && !desc.stencil.read_only {
-        return Ok(false);
-    }
-    if (desc.stencil.load_op, desc.stencil.store_op) != (LoadOp::Load, StoreOp::Store) {
-        return Err(RenderPassError::InvalidStencilOps);
-    }
-    Ok(true)
 }
 
-pub type RenderPassDescriptor<'a> =
-    wgt::RenderPassDescriptor<'a, ColorAttachmentDescriptor, &'a DepthStencilAttachmentDescriptor>;
+/// Describes the attachments of a render pass.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct RenderPassDescriptor<'a> {
+    /// The color attachments of the render pass.
+    pub color_attachments: Cow<'a, [ColorAttachmentDescriptor]>,
+    /// The depth and stencil attachment of the render pass, if any.
+    pub depth_stencil_attachment: Option<&'a DepthStencilAttachmentDescriptor>,
+}
 
 #[derive(Clone, Copy, Debug, Default)]
 #[cfg_attr(any(feature = "serial-pass", feature = "trace"), derive(Serialize))]
@@ -198,7 +210,7 @@ pub enum RenderCommand {
         buffer_id: id::BufferId,
         offset: BufferAddress,
         /// Count of `None` represents a non-multi call.
-        count: Option<u32>,
+        count: Option<NonZeroU32>,
         indexed: bool,
     },
     MultiDrawIndirectCount {
@@ -425,7 +437,7 @@ pub enum RenderPassError {
     #[error("indirect draw with offset {offset}{} uses bytes {begin_offset}..{end_offset} which overruns indirect buffer of size {buffer_size}", count.map_or_else(String::new, |v| format!(" and count {}", v)))]
     IndirectBufferOverrun {
         offset: u64,
-        count: Option<u32>,
+        count: Option<NonZeroU32>,
         begin_offset: u64,
         end_offset: u64,
         buffer_size: u64,
@@ -604,7 +616,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
                         let previous_use = base_trackers
                             .textures
                             .query(source_id.value, view.range.clone());
-                        let new_use = if is_depth_stencil_read_only(at, view.range.aspects)? {
+                        let new_use = if at.is_read_only(view.range.aspects)? {
                             is_ds_read_only = true;
                             TextureUse::ATTACHMENT_READ
                         } else {
@@ -1414,7 +1426,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
                         .unwrap();
                     check_buffer_usage(buffer.usage, BufferUsage::INDIRECT)?;
 
-                    let actual_count = count.unwrap_or(1);
+                    let actual_count = count.map_or(1, |c| c.get());
 
                     let begin_offset = offset;
                     let end_offset = offset + stride * actual_count as u64;
@@ -1622,7 +1634,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
 pub mod render_ffi {
     use super::{super::Rect, RenderCommand, RenderPass};
     use crate::{id, span, RawString};
-    use std::{convert::TryInto, ffi, slice};
+    use std::{convert::TryInto, ffi, num::NonZeroU32, slice};
     use wgt::{BufferAddress, BufferSize, Color, DynamicOffset};
 
     /// # Safety
@@ -1840,7 +1852,7 @@ pub mod render_ffi {
         pass.base.commands.push(RenderCommand::MultiDrawIndirect {
             buffer_id,
             offset,
-            count: Some(count),
+            count: NonZeroU32::new(count),
             indexed: false,
         });
     }
@@ -1856,7 +1868,7 @@ pub mod render_ffi {
         pass.base.commands.push(RenderCommand::MultiDrawIndirect {
             buffer_id,
             offset,
-            count: Some(count),
+            count: NonZeroU32::new(count),
             indexed: true,
         });
     }
diff --git a/wgpu-core/src/conv.rs b/wgpu-core/src/conv.rs
index d9dc72444..f16eb86f5 100644
--- a/wgpu-core/src/conv.rs
+++ b/wgpu-core/src/conv.rs
@@ -244,35 +244,26 @@ pub fn map_depth_stencil_state_descriptor(
     hal::pso::DepthStencilDesc {
         depth: if desc.depth_write_enabled || desc.depth_compare != wgt::CompareFunction::Always {
             Some(hal::pso::DepthTest {
-                fun: map_compare_function(desc.depth_compare)
-                    .expect("DepthStencilStateDescriptor has undefined compare function"),
+                fun: map_compare_function(desc.depth_compare),
                 write: desc.depth_write_enabled,
             })
         } else {
             None
         },
         depth_bounds: false, // TODO
-        stencil: if desc.stencil_read_mask != !0
-            || desc.stencil_write_mask != !0
-            || desc.stencil_front != wgt::StencilStateFaceDescriptor::IGNORE
-            || desc.stencil_back != wgt::StencilStateFaceDescriptor::IGNORE
-        {
-            Some(hal::pso::StencilTest {
-                faces: hal::pso::Sided {
-                    front: map_stencil_face(&desc.stencil_front),
-                    back: map_stencil_face(&desc.stencil_back),
-                },
-                read_masks: hal::pso::State::Static(hal::pso::Sided::new(desc.stencil_read_mask)),
-                write_masks: hal::pso::State::Static(hal::pso::Sided::new(desc.stencil_write_mask)),
-                reference_values: if desc.needs_stencil_reference() {
-                    hal::pso::State::Dynamic
-                } else {
-                    hal::pso::State::Static(hal::pso::Sided::new(0))
-                },
-            })
-        } else {
-            None
-        },
+        stencil: desc.stencil.as_ref().map(|stencil| hal::pso::StencilTest {
+            faces: hal::pso::Sided {
+                front: map_stencil_face(&stencil.front),
+                back: map_stencil_face(&stencil.back),
+            },
+            read_masks: hal::pso::State::Static(hal::pso::Sided::new(stencil.read_mask)),
+            write_masks: hal::pso::State::Static(hal::pso::Sided::new(stencil.write_mask)),
+            reference_values: if stencil.needs_ref_value() {
+                hal::pso::State::Dynamic
+            } else {
+                hal::pso::State::Static(hal::pso::Sided::new(0))
+            },
+        }),
     }
 }
 
@@ -280,29 +271,25 @@ fn map_stencil_face(
     stencil_state_face_desc: &wgt::StencilStateFaceDescriptor,
 ) -> hal::pso::StencilFace {
     hal::pso::StencilFace {
-        fun: map_compare_function(stencil_state_face_desc.compare)
-            .expect("StencilStateFaceDescriptor has undefined compare function"),
+        fun: map_compare_function(stencil_state_face_desc.compare),
         op_fail: map_stencil_operation(stencil_state_face_desc.fail_op),
         op_depth_fail: map_stencil_operation(stencil_state_face_desc.depth_fail_op),
         op_pass: map_stencil_operation(stencil_state_face_desc.pass_op),
     }
 }
 
-pub fn map_compare_function(
-    compare_function: wgt::CompareFunction,
-) -> Option<hal::pso::Comparison> {
+pub fn map_compare_function(compare_function: wgt::CompareFunction) -> hal::pso::Comparison {
     use hal::pso::Comparison as H;
     use wgt::CompareFunction as Cf;
     match compare_function {
-        Cf::Undefined => None,
-        Cf::Never => Some(H::Never),
-        Cf::Less => Some(H::Less),
-        Cf::Equal => Some(H::Equal),
-        Cf::LessEqual => Some(H::LessEqual),
-        Cf::Greater => Some(H::Greater),
-        Cf::NotEqual => Some(H::NotEqual),
-        Cf::GreaterEqual => Some(H::GreaterEqual),
-        Cf::Always => Some(H::Always),
+        Cf::Never => H::Never,
+        Cf::Less => H::Less,
+        Cf::Equal => H::Equal,
+        Cf::LessEqual => H::LessEqual,
+        Cf::Greater => H::Greater,
+        Cf::NotEqual => H::NotEqual,
+        Cf::GreaterEqual => H::GreaterEqual,
+        Cf::Always => H::Always,
     }
 }
 
diff --git a/wgpu-core/src/device/mod.rs b/wgpu-core/src/device/mod.rs
index 3302c79a9..5b92aa7e8 100644
--- a/wgpu-core/src/device/mod.rs
+++ b/wgpu-core/src/device/mod.rs
@@ -12,7 +12,7 @@ use crate::{
     id, pipeline, resource, span, swap_chain,
     track::{BufferState, TextureState, TrackerSet},
     validation::{self, check_buffer_usage, check_texture_usage},
-    FastHashMap, LifeGuard, MultiRefCount, PrivateFeatures, Stored, SubmissionIndex,
+    FastHashMap, Label, LifeGuard, MultiRefCount, PrivateFeatures, Stored, SubmissionIndex,
     MAX_BIND_GROUPS,
 };
 
@@ -30,8 +30,8 @@ use thiserror::Error;
 use wgt::{BufferAddress, BufferSize, InputStepMode, TextureDimension, TextureFormat};
 
 use std::{
-    borrow::Cow, collections::hash_map::Entry, ffi, iter, marker::PhantomData, mem, ops::Range,
-    ptr, sync::atomic::Ordering,
+    borrow::Cow, collections::hash_map::Entry, iter, marker::PhantomData, mem, ops::Range, ptr,
+    sync::atomic::Ordering,
 };
 
 mod life;
@@ -43,18 +43,6 @@ use smallvec::SmallVec;
 #[cfg(feature = "trace")]
 use trace::{Action, Trace};
 
-pub type Label = *const std::os::raw::c_char;
-#[cfg(feature = "trace")]
-fn own_label(label: &Label) -> String {
-    if label.is_null() {
-        String::new()
-    } else {
-        unsafe { ffi::CStr::from_ptr(*label) }
-            .to_string_lossy()
-            .to_string()
-    }
-}
-
 pub const MAX_COLOR_TARGETS: usize = 4;
 pub const MAX_MIP_LEVELS: u32 = 16;
 pub const MAX_VERTEX_BUFFERS: usize = 16;
@@ -394,7 +382,7 @@ impl<B: GfxBackend> Device<B> {
     fn create_buffer(
         &self,
         self_id: id::DeviceId,
-        desc: &wgt::BufferDescriptor<Label>,
+        desc: &resource::BufferDescriptor,
         memory_kind: gfx_memory::Kind,
     ) -> Result<resource::Buffer<B>, resource::CreateBufferError> {
         debug_assert_eq!(self_id.backend(), B::VARIANT);
@@ -428,19 +416,14 @@ impl<B: GfxBackend> Device<B> {
             }
         };
 
-        let mut buffer = unsafe {
-            self.raw
-                .create_buffer(desc.size.max(1), usage)
-                .map_err(|err| match err {
-                    hal::buffer::CreationError::OutOfMemory(_) => DeviceError::OutOfMemory,
-                    _ => panic!("failed to create buffer: {}", err),
-                })?
-        };
-        if !desc.label.is_null() {
-            unsafe {
-                let label = ffi::CStr::from_ptr(desc.label).to_string_lossy();
-                self.raw.set_buffer_name(&mut buffer, &label)
-            };
+        let mut buffer = unsafe { self.raw.create_buffer(desc.size.max(1), usage) }.map_err(
+            |err| match err {
+                hal::buffer::CreationError::OutOfMemory(_) => DeviceError::OutOfMemory,
+                _ => panic!("failed to create buffer: {}", err),
+            },
+        )?;
+        if let Some(ref label) = desc.label {
+            unsafe { self.raw.set_buffer_name(&mut buffer, label) };
         }
 
         let requirements = unsafe { self.raw.get_buffer_requirements(&buffer) };
@@ -474,7 +457,7 @@ impl<B: GfxBackend> Device<B> {
     fn create_texture(
         &self,
         self_id: id::DeviceId,
-        desc: &wgt::TextureDescriptor<Label>,
+        desc: &resource::TextureDescriptor,
     ) -> Result<resource::Texture<B>, resource::CreateTextureError> {
         debug_assert_eq!(self_id.backend(), B::VARIANT);
 
@@ -527,9 +510,8 @@ impl<B: GfxBackend> Device<B> {
                     hal::image::CreationError::OutOfMemory(_) => DeviceError::OutOfMemory,
                     _ => panic!("failed to create texture: {}", err),
                 })?;
-            if !desc.label.is_null() {
-                let label = ffi::CStr::from_ptr(desc.label).to_string_lossy();
-                self.raw.set_image_name(&mut image, &label);
+            if let Some(ref label) = desc.label {
+                self.raw.set_image_name(&mut image, label);
             }
             image
         };
@@ -638,10 +620,7 @@ impl<B: GfxBackend> Device<B> {
     ) -> Result<binding_model::BindGroupLayout<B>, binding_model::CreateBindGroupLayoutError> {
         // Validate the count parameter
         for binding in entry_map.values() {
-            if let Some(count) = binding.count {
-                if count == 0 {
-                    return Err(binding_model::CreateBindGroupLayoutError::ZeroCount);
-                }
+            if binding.count.is_some() {
                 match binding.ty {
                     wgt::BindingType::SampledTexture { .. } => {
                         if !self
@@ -665,7 +644,7 @@ impl<B: GfxBackend> Device<B> {
                 ty: conv::map_binding_type(entry),
                 count: entry
                     .count
-                    .map_or(1, |v| v as hal::pso::DescriptorArrayIndex), //TODO: consolidate
+                    .map_or(1, |v| v.get() as hal::pso::DescriptorArrayIndex), //TODO: consolidate
                 stage_flags: conv::map_shader_stage_flags(entry.visibility),
                 immutable_samplers: false, // TODO
             })
@@ -703,7 +682,7 @@ impl<B: GfxBackend> Device<B> {
             desc_counts: raw_bindings.iter().cloned().collect(),
             dynamic_count: entry_map
                 .values()
-                .filter(|b| b.has_dynamic_offset())
+                .filter(|b| b.ty.has_dynamic_offset())
                 .count(),
             count_validator,
             entries: entry_map,
@@ -713,7 +692,7 @@ impl<B: GfxBackend> Device<B> {
     fn create_pipeline_layout(
         &self,
         self_id: id::DeviceId,
-        desc: &wgt::PipelineLayoutDescriptor<id::BindGroupLayoutId>,
+        desc: &binding_model::PipelineLayoutDescriptor,
         bgl_guard: &Storage<binding_model::BindGroupLayout<B>, id::BindGroupLayoutId>,
     ) -> Result<binding_model::PipelineLayout<B>, CreatePipelineLayoutError> {
         let bind_group_layouts_count = desc.bind_group_layouts.len();
@@ -790,12 +769,20 @@ impl<B: GfxBackend> Device<B> {
             .iter()
             .map(|pc| (conv::map_shader_stage_flags(pc.stages), pc.range.clone()));
 
+        let raw = unsafe {
+            let raw_layout = self
+                .raw
+                .create_pipeline_layout(descriptor_set_layouts, push_constants)
+                .or(Err(DeviceError::OutOfMemory))?;
+            if let Some(_) = desc.label {
+                //TODO-0.6: needs gfx changes published
+                //self.raw.set_pipeline_layout_name(&mut raw_layout, label);
+            }
+            raw_layout
+        };
+
         Ok(binding_model::PipelineLayout {
-            raw: unsafe {
-                self.raw
-                    .create_pipeline_layout(descriptor_set_layouts, push_constants)
-                    .or(Err(DeviceError::OutOfMemory))?
-            },
+            raw,
             device_id: Stored {
                 value: id::Valid(self_id),
                 ref_count: self.life_guard.add_ref(),
@@ -956,7 +943,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
     pub fn device_create_buffer<B: GfxBackend>(
         &self,
         device_id: id::DeviceId,
-        desc: &wgt::BufferDescriptor<Label>,
+        desc: &resource::BufferDescriptor,
         id_in: Input<G, id::BufferId>,
     ) -> Result<id::BufferId, resource::CreateBufferError> {
         span!(_guard, INFO, "Device::create_buffer");
@@ -1000,7 +987,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
             let mut stage = device.create_buffer(
                 device_id,
                 &wgt::BufferDescriptor {
-                    label: b"<init_buffer>\0".as_ptr() as *const _,
+                    label: Some(Cow::Borrowed("<init_buffer>")),
                     size: desc.size,
                     usage: wgt::BufferUsage::MAP_WRITE | wgt::BufferUsage::COPY_SRC,
                     mapped_at_creation: false,
@@ -1025,7 +1012,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         #[cfg(feature = "trace")]
         match device.trace {
             Some(ref trace) => {
-                let mut desc = desc.map_label(own_label);
+                let mut desc = desc.clone();
                 let mapped_at_creation = mem::replace(&mut desc.mapped_at_creation, false);
                 if mapped_at_creation && !desc.usage.contains(wgt::BufferUsage::MAP_WRITE) {
                     desc.usage |= wgt::BufferUsage::COPY_DST;
@@ -1222,7 +1209,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
     pub fn device_create_texture<B: GfxBackend>(
         &self,
         device_id: id::DeviceId,
-        desc: &wgt::TextureDescriptor<Label>,
+        desc: &resource::TextureDescriptor,
         id_in: Input<G, id::TextureId>,
     ) -> Result<id::TextureId, resource::CreateTextureError> {
         span!(_guard, INFO, "Device::create_texture");
@@ -1241,10 +1228,9 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         let id = hub.textures.register_identity(id_in, texture, &mut token);
         #[cfg(feature = "trace")]
         match device.trace {
-            Some(ref trace) => trace.lock().add(trace::Action::CreateTexture(
-                id.0,
-                desc.map_label(own_label),
-            )),
+            Some(ref trace) => trace
+                .lock()
+                .add(trace::Action::CreateTexture(id.0, desc.clone())),
             None => (),
         };
 
@@ -1306,7 +1292,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
     pub fn texture_create_view<B: GfxBackend>(
         &self,
         texture_id: id::TextureId,
-        desc: Option<&wgt::TextureViewDescriptor<Label>>,
+        desc: &resource::TextureViewDescriptor,
         id_in: Input<G, id::TextureViewId>,
     ) -> Result<id::TextureViewId, resource::CreateTextureViewError> {
         span!(_guard, INFO, "Texture::create_view");
@@ -1321,62 +1307,57 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
             .map_err(|_| resource::CreateTextureViewError::InvalidTexture)?;
         let device = &device_guard[texture.device_id.value];
 
-        let (format, view_kind, range) = match desc {
-            Some(desc) => {
-                let kind = conv::map_texture_view_dimension(desc.dimension);
-                let required_level_count =
-                    desc.base_mip_level + desc.level_count.map_or(1, |count| count.get());
-                let required_layer_count =
-                    desc.base_array_layer + desc.array_layer_count.map_or(1, |count| count.get());
-                let level_end = texture.full_range.levels.end;
-                let layer_end = texture.full_range.layers.end;
-                if required_level_count > level_end as u32 {
-                    return Err(resource::CreateTextureViewError::InvalidMipLevelCount {
-                        requested: required_level_count,
-                        total: level_end,
-                    });
-                }
-                if required_layer_count > layer_end as u32 {
-                    return Err(resource::CreateTextureViewError::InvalidArrayLayerCount {
-                        requested: required_layer_count,
-                        total: layer_end,
-                    });
-                };
-                let end_level = desc
-                    .level_count
-                    .map_or(level_end, |_| required_level_count as u8);
-                let end_layer = desc
-                    .array_layer_count
-                    .map_or(layer_end, |_| required_layer_count as u16);
-                let aspects = match desc.aspect {
-                    wgt::TextureAspect::All => texture.full_range.aspects,
-                    wgt::TextureAspect::DepthOnly => hal::format::Aspects::DEPTH,
-                    wgt::TextureAspect::StencilOnly => hal::format::Aspects::STENCIL,
-                };
-                if !texture.full_range.aspects.contains(aspects) {
-                    return Err(resource::CreateTextureViewError::InvalidAspect {
-                        requested: aspects,
-                        total: texture.full_range.aspects,
-                    });
-                }
+        let view_kind = match desc.dimension {
+            Some(dim) => conv::map_texture_view_dimension(dim),
+            None => match texture.kind {
+                hal::image::Kind::D1(_, 1) => hal::image::ViewKind::D1,
+                hal::image::Kind::D1(..) => hal::image::ViewKind::D1Array,
+                hal::image::Kind::D2(_, _, 1, _) => hal::image::ViewKind::D2,
+                hal::image::Kind::D2(..) => hal::image::ViewKind::D2Array,
+                hal::image::Kind::D3(..) => hal::image::ViewKind::D3,
+            },
+        };
+        let required_level_count =
+            desc.base_mip_level + desc.level_count.map_or(1, |count| count.get());
+        let required_layer_count =
+            desc.base_array_layer + desc.array_layer_count.map_or(1, |count| count.get());
+        let level_end = texture.full_range.levels.end;
+        let layer_end = texture.full_range.layers.end;
+        if required_level_count > level_end as u32 {
+            return Err(resource::CreateTextureViewError::InvalidMipLevelCount {
+                requested: required_level_count,
+                total: level_end,
+            });
+        }
+        if required_layer_count > layer_end as u32 {
+            return Err(resource::CreateTextureViewError::InvalidArrayLayerCount {
+                requested: required_layer_count,
+                total: layer_end,
+            });
+        };
+        let end_level = desc
+            .level_count
+            .map_or(level_end, |_| required_level_count as u8);
+        let end_layer = desc
+            .array_layer_count
+            .map_or(layer_end, |_| required_layer_count as u16);
+        let aspects = match desc.aspect {
+            wgt::TextureAspect::All => texture.full_range.aspects,
+            wgt::TextureAspect::DepthOnly => hal::format::Aspects::DEPTH,
+            wgt::TextureAspect::StencilOnly => hal::format::Aspects::STENCIL,
+        };
+        if !texture.full_range.aspects.contains(aspects) {
+            return Err(resource::CreateTextureViewError::InvalidAspect {
+                requested: aspects,
+                total: texture.full_range.aspects,
+            });
+        }
 
-                let range = hal::image::SubresourceRange {
-                    aspects,
-                    levels: desc.base_mip_level as u8..end_level,
-                    layers: desc.base_array_layer as u16..end_layer,
-                };
-                (desc.format, kind, range)
-            }
-            None => {
-                let kind = match texture.kind {
-                    hal::image::Kind::D1(_, 1) => hal::image::ViewKind::D1,
-                    hal::image::Kind::D1(..) => hal::image::ViewKind::D1Array,
-                    hal::image::Kind::D2(_, _, 1, _) => hal::image::ViewKind::D2,
-                    hal::image::Kind::D2(..) => hal::image::ViewKind::D2Array,
-                    hal::image::Kind::D3(..) => hal::image::ViewKind::D3,
-                };
-                (texture.format, kind, texture.full_range.clone())
-            }
+        let format = desc.format.unwrap_or(texture.format);
+        let range = hal::image::SubresourceRange {
+            aspects,
+            levels: desc.base_mip_level as u8..end_level,
+            layers: desc.base_array_layer as u16..end_layer,
         };
 
         let raw = unsafe {
@@ -1414,7 +1395,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
             Some(ref trace) => trace.lock().add(trace::Action::CreateTextureView {
                 id: id.0,
                 parent_id: texture_id,
-                desc: desc.map(|d| d.map_label(own_label)),
+                desc: desc.clone(),
             }),
             None => (),
         };
@@ -1482,7 +1463,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
     pub fn device_create_sampler<B: GfxBackend>(
         &self,
         device_id: id::DeviceId,
-        desc: &wgt::SamplerDescriptor<Label>,
+        desc: &resource::SamplerDescriptor,
         id_in: Input<G, id::SamplerId>,
     ) -> Result<id::SamplerId, resource::CreateSamplerError> {
         span!(_guard, INFO, "Device::create_sampler");
@@ -1495,6 +1476,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
             .map_err(|_| DeviceError::Invalid)?;
 
         let actual_clamp = if let Some(clamp) = desc.anisotropy_clamp {
+            let clamp = clamp.get();
             let valid_clamp = clamp <= MAX_ANISOTROPY && conv::is_power_of_two(clamp as u32);
             if !valid_clamp {
                 return Err(resource::CreateSamplerError::InvalidClamp(clamp));
@@ -1513,13 +1495,13 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
             mag_filter: conv::map_filter(desc.mag_filter),
             mip_filter: conv::map_filter(desc.mipmap_filter),
             wrap_mode: (
-                conv::map_wrap(desc.address_mode_u),
-                conv::map_wrap(desc.address_mode_v),
-                conv::map_wrap(desc.address_mode_w),
+                conv::map_wrap(desc.address_modes[0]),
+                conv::map_wrap(desc.address_modes[1]),
+                conv::map_wrap(desc.address_modes[2]),
             ),
             lod_bias: hal::image::Lod(0.0),
             lod_range: hal::image::Lod(desc.lod_min_clamp)..hal::image::Lod(desc.lod_max_clamp),
-            comparison: desc.compare.and_then(conv::map_compare_function),
+            comparison: desc.compare.map(conv::map_compare_function),
             border: hal::image::PackedColor(0),
             normalized: true,
             anisotropy_clamp: actual_clamp,
@@ -1549,10 +1531,9 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         let id = hub.samplers.register_identity(id_in, sampler, &mut token);
         #[cfg(feature = "trace")]
         match device.trace {
-            Some(ref trace) => trace.lock().add(trace::Action::CreateSampler(
-                id.0,
-                desc.map_label(own_label),
-            )),
+            Some(ref trace) => trace
+                .lock()
+                .add(trace::Action::CreateSampler(id.0, desc.clone())),
             None => (),
         };
 
@@ -1603,7 +1584,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
     pub fn device_create_bind_group_layout<B: GfxBackend>(
         &self,
         device_id: id::DeviceId,
-        desc: &wgt::BindGroupLayoutDescriptor,
+        desc: &binding_model::BindGroupLayoutDescriptor,
         id_in: Input<G, id::BindGroupLayoutId>,
     ) -> Result<id::BindGroupLayoutId, binding_model::CreateBindGroupLayoutError> {
         span!(_guard, INFO, "Device::create_bind_group_layout");
@@ -1695,7 +1676,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
     pub fn device_create_pipeline_layout<B: GfxBackend>(
         &self,
         device_id: id::DeviceId,
-        desc: &wgt::PipelineLayoutDescriptor<id::BindGroupLayoutId>,
+        desc: &binding_model::PipelineLayoutDescriptor,
         id_in: Input<G, id::PipelineLayoutId>,
     ) -> Result<id::PipelineLayoutId, CreatePipelineLayoutError> {
         span!(_guard, INFO, "Device::create_pipeline_layout");
@@ -1810,7 +1791,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
                     Some(dedup_id) => dedup_id,
                     None => {
                         #[cfg(feature = "trace")]
-                        let bgl_desc = wgt::BindGroupLayoutDescriptor {
+                        let bgl_desc = binding_model::BindGroupLayoutDescriptor {
                             label: None,
                             entries: if device.trace.is_some() {
                                 Cow::Owned(map.values().cloned().collect())
@@ -1837,7 +1818,8 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
             derived_group_layout_ids.push(processed_id);
         }
 
-        let layout_desc = wgt::PipelineLayoutDescriptor {
+        let layout_desc = binding_model::PipelineLayoutDescriptor {
+            label: None,
             bind_group_layouts: Cow::Borrowed(&derived_group_layout_ids),
             push_constant_ranges: Cow::Borrowed(&[]), //TODO?
         };
@@ -2113,7 +2095,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
                         }
 
                         if let Some(count) = decl.count {
-                            let count = count as usize;
+                            let count = count.get() as usize;
                             let num_bindings = bindings_array.len();
                             if count != num_bindings {
                                 return Err(CreateBindGroupError::BindingArrayLengthMismatch {
@@ -2433,11 +2415,10 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
 
         unsafe {
             let raw_command_buffer = command_buffer.raw.last_mut().unwrap();
-            if !desc.label.is_null() {
-                let label = ffi::CStr::from_ptr(desc.label).to_string_lossy();
+            if let Some(ref label) = desc.label {
                 device
                     .raw
-                    .set_command_buffer_name(raw_command_buffer, &label);
+                    .set_command_buffer_name(raw_command_buffer, label);
             }
             raw_command_buffer.begin_primary(hal::command::CommandBufferFlags::ONE_TIME_SUBMIT);
         }
@@ -2491,7 +2472,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
     pub fn device_create_render_bundle_encoder(
         &self,
         device_id: id::DeviceId,
-        desc: &wgt::RenderBundleEncoderDescriptor,
+        desc: &command::RenderBundleEncoderDescriptor,
     ) -> Result<id::RenderBundleEncoderId, command::CreateRenderBundleError> {
         span!(_guard, INFO, "Device::create_render_bundle_encoder");
         let encoder = command::RenderBundleEncoder::new(desc, device_id, None);
@@ -2933,7 +2914,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
             }
         }
         if let Some(ds) = depth_stencil_state.as_ref() {
-            if ds.needs_stencil_reference() {
+            if ds.stencil.as_ref().map_or(false, |s| s.needs_ref_value()) {
                 flags |= pipeline::PipelineFlags::STENCIL_REFERENCE;
             }
             if !ds.is_read_only() {
@@ -2966,7 +2947,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         match device.trace {
             Some(ref trace) => trace.lock().add(trace::Action::CreateRenderPipeline(
                 id.0,
-                wgt::RenderPipelineDescriptor {
+                pipeline::RenderPipelineDescriptor {
                     layout: Some(layout_id),
                     ..desc.clone()
                 },
@@ -3185,7 +3166,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         match device.trace {
             Some(ref trace) => trace.lock().add(trace::Action::CreateComputePipeline(
                 id.0,
-                wgt::ComputePipelineDescriptor {
+                pipeline::ComputePipelineDescriptor {
                     layout: Some(layout_id),
                     ..desc.clone()
                 },
diff --git a/wgpu-core/src/device/trace.rs b/wgpu-core/src/device/trace.rs
index 9d80e7ad7..273178a07 100644
--- a/wgpu-core/src/device/trace.rs
+++ b/wgpu-core/src/device/trace.rs
@@ -5,7 +5,7 @@
 use crate::id;
 #[cfg(feature = "trace")]
 use std::io::Write as _;
-use std::ops::Range;
+use std::{borrow::Cow, ops::Range};
 
 //TODO: consider a readable Id that doesn't include the backend
 
@@ -14,13 +14,13 @@ type FileName = String;
 pub const FILE_NAME: &str = "trace.ron";
 
 #[cfg(feature = "trace")]
-pub(crate) fn new_render_bundle_encoder_descriptor(
-    label: super::Label,
-    context: &super::RenderPassContext,
-) -> wgt::RenderBundleEncoderDescriptor {
-    wgt::RenderBundleEncoderDescriptor {
-        label: Some(super::own_label(&label).into()),
-        color_formats: context.attachments.colors.to_vec().into(),
+pub(crate) fn new_render_bundle_encoder_descriptor<'a>(
+    label: Option<&'a str>,
+    context: &'a super::RenderPassContext,
+) -> crate::command::RenderBundleEncoderDescriptor<'a> {
+    crate::command::RenderBundleEncoderDescriptor {
+        label: label.map(Cow::Borrowed),
+        color_formats: Cow::Borrowed(&context.attachments.colors),
         depth_stencil_format: context.attachments.depth_stencil,
         sample_count: context.sample_count as u32,
     }
@@ -34,17 +34,17 @@ pub enum Action<'a> {
         desc: wgt::DeviceDescriptor,
         backend: wgt::Backend,
     },
-    CreateBuffer(id::BufferId, wgt::BufferDescriptor<String>),
+    CreateBuffer(id::BufferId, crate::resource::BufferDescriptor<'a>),
     DestroyBuffer(id::BufferId),
-    CreateTexture(id::TextureId, wgt::TextureDescriptor<String>),
+    CreateTexture(id::TextureId, crate::resource::TextureDescriptor<'a>),
     DestroyTexture(id::TextureId),
     CreateTextureView {
         id: id::TextureViewId,
         parent_id: id::TextureId,
-        desc: Option<wgt::TextureViewDescriptor<String>>,
+        desc: crate::resource::TextureViewDescriptor<'a>,
     },
     DestroyTextureView(id::TextureViewId),
-    CreateSampler(id::SamplerId, wgt::SamplerDescriptor<String>),
+    CreateSampler(id::SamplerId, crate::resource::SamplerDescriptor<'a>),
     DestroySampler(id::SamplerId),
     CreateSwapChain(id::SwapChainId, wgt::SwapChainDescriptor),
     GetSwapChainTexture {
@@ -52,20 +52,19 @@ pub enum Action<'a> {
         parent_id: id::SwapChainId,
     },
     PresentSwapChain(id::SwapChainId),
-    CreateBindGroupLayout(id::BindGroupLayoutId, wgt::BindGroupLayoutDescriptor<'a>),
+    CreateBindGroupLayout(
+        id::BindGroupLayoutId,
+        crate::binding_model::BindGroupLayoutDescriptor<'a>,
+    ),
     DestroyBindGroupLayout(id::BindGroupLayoutId),
     CreatePipelineLayout(
         id::PipelineLayoutId,
-        wgt::PipelineLayoutDescriptor<'a, id::BindGroupLayoutId>,
+        crate::binding_model::PipelineLayoutDescriptor<'a>,
     ),
     DestroyPipelineLayout(id::PipelineLayoutId),
     CreateBindGroup(
         id::BindGroupId,
-        wgt::BindGroupDescriptor<
-            'a,
-            id::BindGroupLayoutId,
-            wgt::BindGroupEntry<crate::binding_model::BindingResource<'a>>,
-        >,
+        crate::binding_model::BindGroupDescriptor<'a>,
     ),
     DestroyBindGroup(id::BindGroupId),
     CreateShaderModule {
@@ -75,24 +74,17 @@ pub enum Action<'a> {
     DestroyShaderModule(id::ShaderModuleId),
     CreateComputePipeline(
         id::ComputePipelineId,
-        wgt::ComputePipelineDescriptor<
-            id::PipelineLayoutId,
-            wgt::ProgrammableStageDescriptor<'a, id::ShaderModuleId>,
-        >,
+        crate::pipeline::ComputePipelineDescriptor<'a>,
     ),
     DestroyComputePipeline(id::ComputePipelineId),
     CreateRenderPipeline(
         id::RenderPipelineId,
-        wgt::RenderPipelineDescriptor<
-            'a,
-            id::PipelineLayoutId,
-            wgt::ProgrammableStageDescriptor<'a, id::ShaderModuleId>,
-        >,
+        crate::pipeline::RenderPipelineDescriptor<'a>,
     ),
     DestroyRenderPipeline(id::RenderPipelineId),
     CreateRenderBundle {
         id: id::RenderBundleId,
-        desc: wgt::RenderBundleEncoderDescriptor<'a>,
+        desc: crate::command::RenderBundleEncoderDescriptor<'a>,
         base: crate::command::BasePass<crate::command::RenderCommand>,
     },
     DestroyRenderBundle(id::RenderBundleId),
diff --git a/wgpu-core/src/lib.rs b/wgpu-core/src/lib.rs
index 46a40289a..7156a3502 100644
--- a/wgpu-core/src/lib.rs
+++ b/wgpu-core/src/lib.rs
@@ -49,7 +49,7 @@ use std::sync::atomic;
 
 use atomic::{AtomicUsize, Ordering};
 
-use std::{os::raw::c_char, ptr};
+use std::{borrow::Cow, os::raw::c_char, ptr};
 
 pub const MAX_BIND_GROUPS: usize = 8;
 
@@ -58,6 +58,7 @@ type Index = u32;
 type Epoch = u32;
 
 pub type RawString = *const c_char;
+pub type Label<'a> = Option<Cow<'a, str>>;
 
 /// Reference count object that is 1:1 with each reference.
 #[derive(Debug)]
diff --git a/wgpu-core/src/pipeline.rs b/wgpu-core/src/pipeline.rs
index b8423f531..a41b2ebac 100644
--- a/wgpu-core/src/pipeline.rs
+++ b/wgpu-core/src/pipeline.rs
@@ -36,7 +36,17 @@ pub enum CreateShaderModuleError {
     Validation(#[from] naga::proc::ValidationError),
 }
 
-pub type ProgrammableStageDescriptor<'a> = wgt::ProgrammableStageDescriptor<'a, ShaderModuleId>;
+/// Describes a programmable pipeline stage.
+#[derive(Clone, Debug)]
+#[cfg_attr(feature = "trace", derive(serde::Serialize))]
+#[cfg_attr(feature = "replay", derive(serde::Deserialize))]
+pub struct ProgrammableStageDescriptor<'a> {
+    /// The compiled shader module for this stage.
+    pub module: ShaderModuleId,
+    /// The name of the entry point in the compiled shader. There must be a function that returns
+    /// void with this name in the shader.
+    pub entry_point: Cow<'a, str>,
+}
 
 /// Number of implicit bind groups derived at pipeline creation.
 pub type ImplicitBindGroupCount = u8;
@@ -53,8 +63,16 @@ pub enum ImplicitLayoutError {
     Pipeline(#[from] CreatePipelineLayoutError),
 }
 
-pub type ComputePipelineDescriptor<'a> =
-    wgt::ComputePipelineDescriptor<PipelineLayoutId, ProgrammableStageDescriptor<'a>>;
+/// Describes a compute pipeline.
+#[derive(Clone, Debug)]
+#[cfg_attr(feature = "trace", derive(serde::Serialize))]
+#[cfg_attr(feature = "replay", derive(serde::Deserialize))]
+pub struct ComputePipelineDescriptor<'a> {
+    /// The layout of bind groups for this pipeline.
+    pub layout: Option<PipelineLayoutId>,
+    /// The compiled compute stage and its entry point.
+    pub compute_stage: ProgrammableStageDescriptor<'a>,
+}
 
 #[derive(Clone, Debug, Error)]
 pub enum CreateComputePipelineError {
@@ -82,8 +100,65 @@ impl<B: hal::Backend> Borrow<RefCount> for ComputePipeline<B> {
     }
 }
 
-pub type RenderPipelineDescriptor<'a> =
-    wgt::RenderPipelineDescriptor<'a, PipelineLayoutId, ProgrammableStageDescriptor<'a>>;
+/// Describes how the vertex buffer is interpreted.
+#[derive(Clone, Debug)]
+#[cfg_attr(feature = "trace", derive(serde::Serialize))]
+#[cfg_attr(feature = "replay", derive(serde::Deserialize))]
+pub struct VertexBufferDescriptor<'a> {
+    /// The stride, in bytes, between elements of this buffer.
+    pub stride: BufferAddress,
+    /// How often this vertex buffer is "stepped" forward.
+    pub step_mode: InputStepMode,
+    /// The list of attributes which comprise a single vertex.
+    pub attributes: Cow<'a, [wgt::VertexAttributeDescriptor]>,
+}
+
+/// Describes vertex input state for a render pipeline.
+#[derive(Clone, Debug)]
+#[cfg_attr(feature = "trace", derive(serde::Serialize))]
+#[cfg_attr(feature = "replay", derive(serde::Deserialize))]
+pub struct VertexStateDescriptor<'a> {
+    /// The format of any index buffers used with this pipeline.
+    pub index_format: IndexFormat,
+    /// The format of any vertex buffers used with this pipeline.
+    pub vertex_buffers: Cow<'a, [VertexBufferDescriptor<'a>]>,
+}
+
+/// Describes a render (graphics) pipeline.
+#[derive(Clone, Debug)]
+#[cfg_attr(feature = "trace", derive(serde::Serialize))]
+#[cfg_attr(feature = "replay", derive(serde::Deserialize))]
+pub struct RenderPipelineDescriptor<'a> {
+    /// The layout of bind groups for this pipeline.
+    pub layout: Option<PipelineLayoutId>,
+    /// The compiled vertex stage and its entry point.
+    pub vertex_stage: ProgrammableStageDescriptor<'a>,
+    /// The compiled fragment stage and its entry point, if any.
+    pub fragment_stage: Option<ProgrammableStageDescriptor<'a>>,
+    /// The rasterization process for this pipeline.
+    pub rasterization_state: Option<wgt::RasterizationStateDescriptor>,
+    /// The primitive topology used to interpret vertices.
+    pub primitive_topology: wgt::PrimitiveTopology,
+    /// The effect of draw calls on the color aspect of the output target.
+    pub color_states: Cow<'a, [wgt::ColorStateDescriptor]>,
+    /// The effect of draw calls on the depth and stencil aspects of the output target, if any.
+    pub depth_stencil_state: Option<wgt::DepthStencilStateDescriptor>,
+    /// The vertex input state for this pipeline.
+    pub vertex_state: VertexStateDescriptor<'a>,
+    /// The number of samples calculated per pixel (for MSAA). For non-multisampled textures,
+    /// this should be `1`
+    pub sample_count: u32,
+    /// Bitmask that restricts the samples of a pixel modified by this pipeline. All samples
+    /// can be enabled using the value `!0`
+    pub sample_mask: u32,
+    /// When enabled, produces another sample mask per pixel based on the alpha output value, that
+    /// is ANDed with the sample_mask and the primitive coverage to restrict the set of samples
+    /// affected by a primitive.
+    ///
+    /// The implicit mask produced for alpha of zero is guaranteed to be zero, and for alpha of one
+    /// is guaranteed to be all 1-s.
+    pub alpha_to_coverage_enabled: bool,
+}
 
 #[derive(Clone, Debug, Error)]
 pub enum CreateRenderPipelineError {
diff --git a/wgpu-core/src/resource.rs b/wgpu-core/src/resource.rs
index 392c2f6a3..491fe1ec0 100644
--- a/wgpu-core/src/resource.rs
+++ b/wgpu-core/src/resource.rs
@@ -7,14 +7,17 @@ use crate::{
     id::{DeviceId, SwapChainId, TextureId},
     track::DUMMY_SELECTOR,
     validation::MissingBufferUsageError,
-    LifeGuard, RefCount, Stored,
+    Label, LifeGuard, RefCount, Stored,
 };
 
 use gfx_memory::MemoryBlock;
 use thiserror::Error;
-use wgt::{BufferAddress, BufferUsage, TextureFormat, TextureUsage};
 
-use std::{borrow::Borrow, ptr::NonNull};
+use std::{
+    borrow::Borrow,
+    num::{NonZeroU32, NonZeroU8},
+    ptr::NonNull,
+};
 
 bitflags::bitflags! {
     /// The internal enum mirrored from `BufferUsage`. The values don't have to match!
@@ -155,13 +158,15 @@ pub(crate) struct BufferPendingMapping {
     pub parent_ref_count: RefCount,
 }
 
+pub type BufferDescriptor<'a> = wgt::BufferDescriptor<Label<'a>>;
+
 #[derive(Debug)]
 pub struct Buffer<B: hal::Backend> {
     pub(crate) raw: B::Buffer,
     pub(crate) device_id: Stored<DeviceId>,
-    pub(crate) usage: BufferUsage,
+    pub(crate) usage: wgt::BufferUsage,
     pub(crate) memory: MemoryBlock<B>,
-    pub(crate) size: BufferAddress,
+    pub(crate) size: wgt::BufferAddress,
     pub(crate) full_range: (),
     pub(crate) sync_mapped_writes: Option<hal::memory::Segment>,
     pub(crate) life_guard: LifeGuard,
@@ -177,7 +182,7 @@ pub enum CreateBufferError {
     #[error("buffers that are mapped at creation have to be aligned to `COPY_BUFFER_ALIGNMENT`")]
     UnalignedSize,
     #[error("`MAP` usage can only be combined with the opposite `COPY`, requested {0:?}")]
-    UsageMismatch(BufferUsage),
+    UsageMismatch(wgt::BufferUsage),
 }
 
 impl<B: hal::Backend> Borrow<RefCount> for Buffer<B> {
@@ -192,14 +197,16 @@ impl<B: hal::Backend> Borrow<()> for Buffer<B> {
     }
 }
 
+pub type TextureDescriptor<'a> = wgt::TextureDescriptor<Label<'a>>;
+
 #[derive(Debug)]
 pub struct Texture<B: hal::Backend> {
     pub(crate) raw: B::Image,
     pub(crate) device_id: Stored<DeviceId>,
-    pub(crate) usage: TextureUsage,
+    pub(crate) usage: wgt::TextureUsage,
     pub(crate) dimension: wgt::TextureDimension,
     pub(crate) kind: hal::image::Kind,
-    pub(crate) format: TextureFormat,
+    pub(crate) format: wgt::TextureFormat,
     pub(crate) full_range: hal::image::SubresourceRange,
     pub(crate) memory: MemoryBlock<B>,
     pub(crate) life_guard: LifeGuard,
@@ -226,7 +233,7 @@ pub enum CreateTextureError {
     #[error("texture descriptor mip level count ({0}) must be less than `MAX_MIP_LEVELS`")]
     InvalidMipLevelCount(u32),
     #[error("Feature {0:?} must be enabled to create a texture of type {1:?}")]
-    MissingFeature(wgt::Features, TextureFormat),
+    MissingFeature(wgt::Features, wgt::TextureFormat),
 }
 
 impl<B: hal::Backend> Borrow<RefCount> for Texture<B> {
@@ -241,6 +248,35 @@ impl<B: hal::Backend> Borrow<hal::image::SubresourceRange> for Texture<B> {
     }
 }
 
+/// Describes a [`TextureView`].
+#[derive(Clone, Debug, Default, PartialEq)]
+#[cfg_attr(feature = "trace", derive(serde::Serialize))]
+#[cfg_attr(feature = "replay", derive(serde::Deserialize))]
+pub struct TextureViewDescriptor<'a> {
+    /// Debug label of the texture view. This will show up in graphics debuggers for easy identification.
+    pub label: Label<'a>,
+    /// Format of the texture view, or `None` for the same format as the texture itself.
+    /// At this time, it must be the same the underlying format of the texture.
+    pub format: Option<wgt::TextureFormat>,
+    /// The dimension of the texture view. For 1D textures, this must be `1D`. For 2D textures it must be one of
+    /// `D2`, `D2Array`, `Cube`, and `CubeArray`. For 3D textures it must be `3D`
+    pub dimension: Option<wgt::TextureViewDimension>,
+    /// Aspect of the texture. Color textures must be [`TextureAspect::All`].
+    pub aspect: wgt::TextureAspect,
+    /// Base mip level.
+    pub base_mip_level: u32,
+    /// Mip level count.
+    /// If `Some(count)`, `base_mip_level + count` must be less or equal to underlying texture mip count.
+    /// If `None`, considered to include the rest of the mipmap levels, but at least 1 in total.
+    pub level_count: Option<NonZeroU32>,
+    /// Base array layer.
+    pub base_array_layer: u32,
+    /// Layer count.
+    /// If `Some(count)`, `base_array_layer + count` must be less or equal to the underlying array count.
+    /// If `None`, considered to include the rest of the array layers, but at least 1 in total.
+    pub array_layer_count: Option<NonZeroU32>,
+}
+
 #[derive(Debug)]
 pub(crate) enum TextureViewInner<B: hal::Backend> {
     Native {
@@ -257,7 +293,7 @@ pub(crate) enum TextureViewInner<B: hal::Backend> {
 pub struct TextureView<B: hal::Backend> {
     pub(crate) inner: TextureViewInner<B>,
     //TODO: store device_id for quick access?
-    pub(crate) format: TextureFormat,
+    pub(crate) format: wgt::TextureFormat,
     pub(crate) extent: hal::image::Extent,
     pub(crate) samples: hal::image::NumSamples,
     pub(crate) range: hal::image::SubresourceRange,
@@ -301,6 +337,47 @@ impl<B: hal::Backend> Borrow<()> for TextureView<B> {
     }
 }
 
+/// Describes a [`Sampler`]
+#[derive(Clone, Debug, PartialEq)]
+#[cfg_attr(feature = "trace", derive(serde::Serialize))]
+#[cfg_attr(feature = "replay", derive(serde::Deserialize))]
+pub struct SamplerDescriptor<'a> {
+    /// Debug label of the sampler. This will show up in graphics debuggers for easy identification.
+    pub label: Label<'a>,
+    /// How to deal with out of bounds accesses in the u (i.e. x) direction
+    pub address_modes: [wgt::AddressMode; 3],
+    /// How to filter the texture when it needs to be magnified (made larger)
+    pub mag_filter: wgt::FilterMode,
+    /// How to filter the texture when it needs to be minified (made smaller)
+    pub min_filter: wgt::FilterMode,
+    /// How to filter between mip map levels
+    pub mipmap_filter: wgt::FilterMode,
+    /// Minimum level of detail (i.e. mip level) to use
+    pub lod_min_clamp: f32,
+    /// Maximum level of detail (i.e. mip level) to use
+    pub lod_max_clamp: f32,
+    /// If this is enabled, this is a comparison sampler using the given comparison function.
+    pub compare: Option<wgt::CompareFunction>,
+    /// Valid values: 1, 2, 4, 8, and 16.
+    pub anisotropy_clamp: Option<NonZeroU8>,
+}
+
+impl Default for SamplerDescriptor<'_> {
+    fn default() -> Self {
+        Self {
+            label: None,
+            address_modes: Default::default(),
+            mag_filter: Default::default(),
+            min_filter: Default::default(),
+            mipmap_filter: Default::default(),
+            lod_min_clamp: 0.0,
+            lod_max_clamp: std::f32::MAX,
+            compare: None,
+            anisotropy_clamp: None,
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct Sampler<B: hal::Backend> {
     pub(crate) raw: B::Sampler,
diff --git a/wgpu-types/src/into_cow.rs b/wgpu-types/src/into_cow.rs
deleted file mode 100644
index b9704aa03..000000000
--- a/wgpu-types/src/into_cow.rs
+++ /dev/null
@@ -1,45 +0,0 @@
-use std::borrow::Cow;
-
-/// Implements conversion into a cow.
-pub trait IntoCow<'c, CowType: ?Sized + ToOwned> {
-    fn into_cow(self) -> Cow<'c, CowType>;
-}
-
-impl<'c, T: Clone> IntoCow<'c, [T]> for &'c [T] {
-    fn into_cow(self) -> Cow<'c, [T]> {
-        Cow::Borrowed(self)
-    }
-}
-
-impl<'c> IntoCow<'c, str> for &'c str {
-    fn into_cow(self) -> Cow<'c, str> {
-        Cow::Borrowed(self)
-    }
-}
-
-impl<T: Clone> IntoCow<'static, [T]> for Vec<T> {
-    fn into_cow(self) -> Cow<'static, [T]> {
-        Cow::Owned(self)
-    }
-}
-
-impl IntoCow<'static, str> for String {
-    fn into_cow(self) -> Cow<'static, str> {
-        Cow::Owned(self)
-    }
-}
-
-macro_rules! into_cow_array {
-    ($($number:literal),*) => {$(
-        impl<'c, T: Clone> IntoCow<'c, [T]> for &'c [T; $number] {
-            fn into_cow(self) -> Cow<'c, [T]> {
-                Cow::Borrowed(&self[..])
-            }
-        }
-    )*};
-}
-
-into_cow_array!(
-    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
-    26, 27, 28, 29, 30, 31, 32
-);
diff --git a/wgpu-types/src/lib.rs b/wgpu-types/src/lib.rs
index aab171ae0..57511f362 100644
--- a/wgpu-types/src/lib.rs
+++ b/wgpu-types/src/lib.rs
@@ -10,15 +10,18 @@
 
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
-use std::{borrow::Cow, num::NonZeroU32, ops::Range};
-
-pub use into_cow::IntoCow;
-mod into_cow;
+use std::{num::NonZeroU32, ops::Range};
 
 /// Integral type used for buffer offsets.
 pub type BufferAddress = u64;
 /// Integral type used for buffer slice sizes.
 pub type BufferSize = std::num::NonZeroU64;
+/// Index for binding a group.
+pub type BindGroupIndex = u8;
+/// Integral type used for binding locations in shaders.
+pub type ShaderLocation = u32;
+/// Integral type used for dynamic bind group offsets.
+pub type DynamicOffset = u32;
 
 /// Buffer-Texture copies must have [`bytes_per_row`] aligned to this number.
 ///
@@ -122,22 +125,6 @@ pub struct RequestAdapterOptions<S> {
     pub compatible_surface: Option<S>,
 }
 
-impl<S> RequestAdapterOptions<S> {
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    pub fn power_preference(&mut self, preference: PowerPreference) -> &mut Self {
-        self.power_preference = preference;
-        self
-    }
-
-    pub fn compatible_surface(&mut self, surface: S) -> &mut Self {
-        self.compatible_surface = Some(surface);
-        self
-    }
-}
-
 impl<S> Default for RequestAdapterOptions<S> {
     fn default() -> Self {
         Self {
@@ -382,27 +369,6 @@ pub struct DeviceDescriptor {
     pub shader_validation: bool,
 }
 
-impl DeviceDescriptor {
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    pub fn features(&mut self, features: Features) -> &mut Self {
-        self.features = features;
-        self
-    }
-
-    pub fn limits(&mut self, limits: Limits) -> &mut Self {
-        self.limits = limits;
-        self
-    }
-
-    pub fn shader_validation(&mut self) -> &mut Self {
-        self.shader_validation = true;
-        self
-    }
-}
-
 bitflags::bitflags! {
     /// Describes the shader stages that a binding will be visible from.
     ///
@@ -412,13 +378,13 @@ bitflags::bitflags! {
     #[repr(transparent)]
     #[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
     pub struct ShaderStage: u32 {
-        /// Binding is not visible from any shader stage
+        /// Binding is not visible from any shader stage.
         const NONE = 0;
-        /// Binding is visible from the vertex shader of a render pipeline
+        /// Binding is visible from the vertex shader of a render pipeline.
         const VERTEX = 1;
-        /// Binding is visible from the fragment shader of a render pipeline
+        /// Binding is visible from the fragment shader of a render pipeline.
         const FRAGMENT = 2;
-        /// Binding is visible from the compute shader of a compute pipeline
+        /// Binding is visible from the compute shader of a compute pipeline.
         const COMPUTE = 4;
     }
 }
@@ -518,23 +484,6 @@ impl BlendDescriptor {
     }
 }
 
-impl BlendDescriptor {
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    pub fn factors(&mut self, src_factor: BlendFactor, dst_factor: BlendFactor) -> &mut Self {
-        self.src_factor = src_factor;
-        self.dst_factor = dst_factor;
-        self
-    }
-
-    pub fn operation(&mut self, operation: BlendOperation) -> &mut Self {
-        self.operation = operation;
-        self
-    }
-}
-
 impl Default for BlendDescriptor {
     fn default() -> Self {
         BlendDescriptor::REPLACE
@@ -558,32 +507,6 @@ pub struct ColorStateDescriptor {
     pub write_mask: ColorWrite,
 }
 
-impl ColorStateDescriptor {
-    pub fn new(format: TextureFormat) -> Self {
-        Self {
-            format,
-            alpha_blend: BlendDescriptor::default(),
-            color_blend: BlendDescriptor::default(),
-            write_mask: ColorWrite::default(),
-        }
-    }
-
-    pub fn alpha_blend(&mut self, blend: BlendDescriptor) -> &mut Self {
-        self.alpha_blend = blend;
-        self
-    }
-
-    pub fn color_blend(&mut self, blend: BlendDescriptor) -> &mut Self {
-        self.color_blend = blend;
-        self
-    }
-
-    pub fn write_mask(&mut self, mask: ColorWrite) -> &mut Self {
-        self.write_mask = mask;
-        self
-    }
-}
-
 /// Primitive type the input mesh is composed of.
 #[repr(C)]
 #[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
@@ -669,34 +592,6 @@ pub struct RasterizationStateDescriptor {
     pub depth_bias_clamp: f32,
 }
 
-impl RasterizationStateDescriptor {
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    pub fn front_face(&mut self, front_face: FrontFace) -> &mut Self {
-        self.front_face = front_face;
-        self
-    }
-
-    pub fn cull_mode(&mut self, cull_mode: CullMode) -> &mut Self {
-        self.cull_mode = cull_mode;
-        self
-    }
-
-    pub fn clamp_depth(&mut self) -> &mut Self {
-        self.clamp_depth = true;
-        self
-    }
-
-    pub fn depth_bias(&mut self, bias: i32, slope_scale: f32, clamp: f32) -> &mut Self {
-        self.depth_bias = bias;
-        self.depth_bias_slope_scale = slope_scale;
-        self.depth_bias_clamp = clamp;
-        self
-    }
-}
-
 /// Underlying texture data format.
 ///
 /// If there is a conversion in the format (such as srgb -> linear), The conversion listed is for
@@ -921,6 +816,30 @@ impl Default for ColorWrite {
     }
 }
 
+#[repr(C)]
+#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "trace", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
+pub struct StencilStateDescriptor {
+    /// Front face mode.
+    pub front: StencilStateFaceDescriptor,
+    /// Back face mode.
+    pub back: StencilStateFaceDescriptor,
+    /// Stencil values are AND'd with this mask when reading and writing from the stencil buffer. Only low 8 bits are used.
+    pub read_mask: u32,
+    /// Stencil values are AND'd with this mask when writing to the stencil buffer. Only low 8 bits are used.
+    pub write_mask: u32,
+}
+
+impl StencilStateDescriptor {
+    pub fn needs_ref_value(&self) -> bool {
+        !self.front.compare.is_trivial() || !self.back.compare.is_trivial()
+    }
+    pub fn is_read_only(&self) -> bool {
+        self.write_mask == 0
+    }
+}
+
 /// Describes the depth/stencil state in a render pipeline.
 #[repr(C)]
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
@@ -934,55 +853,16 @@ pub struct DepthStencilStateDescriptor {
     pub depth_write_enabled: bool,
     /// Comparison function used to compare depth values in the depth test.
     pub depth_compare: CompareFunction,
-    /// Stencil state used for front faces.
-    pub stencil_front: StencilStateFaceDescriptor,
-    /// Stencil state used for back faces.
-    pub stencil_back: StencilStateFaceDescriptor,
-    /// Stencil values are AND'd with this mask when reading and writing from the stencil buffer. Only low 8 bits are used.
-    pub stencil_read_mask: u32,
-    /// Stencil values are AND'd with this mask when writing to the stencil buffer. Only low 8 bits are used.
-    pub stencil_write_mask: u32,
+    pub stencil: Option<StencilStateDescriptor>,
 }
 
 impl DepthStencilStateDescriptor {
-    pub fn new(format: TextureFormat, depth_compare: CompareFunction) -> Self {
-        Self {
-            format,
-            depth_write_enabled: false,
-            depth_compare,
-            stencil_front: StencilStateFaceDescriptor::default(),
-            stencil_back: StencilStateFaceDescriptor::default(),
-            stencil_read_mask: 0,
-            stencil_write_mask: 0,
-        }
-    }
-
-    pub fn depth_write(&mut self) -> &mut Self {
-        self.depth_write_enabled = true;
-        self
-    }
-
-    pub fn stencil_front(&mut self, stencil: StencilStateFaceDescriptor) -> &mut Self {
-        self.stencil_front = stencil;
-        self
-    }
-
-    pub fn stencil_back(&mut self, stencil: StencilStateFaceDescriptor) -> &mut Self {
-        self.stencil_back = stencil;
-        self
-    }
-
-    pub fn stencil_masks(&mut self, read: u32, write: u32) -> &mut Self {
-        self.stencil_read_mask = read;
-        self.stencil_write_mask = write;
-        self
-    }
-
-    pub fn needs_stencil_reference(&self) -> bool {
-        !self.stencil_front.compare.is_trivial() || !self.stencil_back.compare.is_trivial()
-    }
     pub fn is_read_only(&self) -> bool {
-        !self.depth_write_enabled && self.stencil_write_mask == 0
+        !self.depth_write_enabled
+            && self
+                .stencil
+                .as_ref()
+                .map_or(true, StencilStateDescriptor::is_read_only)
     }
 }
 
@@ -1073,8 +953,6 @@ impl Default for StencilStateFaceDescriptor {
 #[cfg_attr(feature = "trace", derive(Serialize))]
 #[cfg_attr(feature = "replay", derive(Deserialize))]
 pub enum CompareFunction {
-    /// Invalid value, do not use
-    Undefined = 0,
     /// Function never passes
     Never = 1,
     /// Function passes if new value less than existing value
@@ -1102,9 +980,6 @@ impl CompareFunction {
     }
 }
 
-/// Integral type used for binding locations in shaders.
-pub type ShaderLocation = u32;
-
 /// Rate that determines when vertex data is advanced.
 #[repr(C)]
 #[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
@@ -1133,58 +1008,6 @@ pub struct VertexAttributeDescriptor {
     pub shader_location: ShaderLocation,
 }
 
-/// Describes how the vertex buffer is interpreted.
-#[derive(Clone, Debug, Hash, Eq, PartialEq)]
-#[cfg_attr(feature = "trace", derive(serde::Serialize))]
-#[cfg_attr(feature = "replay", derive(serde::Deserialize))]
-pub struct VertexBufferDescriptor<'a> {
-    /// The stride, in bytes, between elements of this buffer.
-    pub stride: BufferAddress,
-    /// How often this vertex buffer is "stepped" forward.
-    pub step_mode: InputStepMode,
-    /// The list of attributes which comprise a single vertex.
-    pub attributes: Cow<'a, [VertexAttributeDescriptor]>,
-}
-
-impl<'a> VertexBufferDescriptor<'a> {
-    pub fn new(
-        stride: BufferAddress,
-        step_mode: InputStepMode,
-        attributes: impl IntoCow<'a, [VertexAttributeDescriptor]>,
-    ) -> Self {
-        Self {
-            stride,
-            step_mode,
-            attributes: attributes.into_cow(),
-        }
-    }
-}
-
-/// Describes vertex input state for a render pipeline.
-#[derive(Clone, Debug, Hash, Eq, PartialEq)]
-#[cfg_attr(feature = "trace", derive(serde::Serialize))]
-#[cfg_attr(feature = "replay", derive(serde::Deserialize))]
-pub struct VertexStateDescriptor<'a> {
-    /// The format of any index buffers used with this pipeline.
-    pub index_format: IndexFormat,
-    /// The format of any vertex buffers used with this pipeline.
-    pub vertex_buffers: Cow<'a, [VertexBufferDescriptor<'a>]>,
-}
-
-impl<'a> VertexStateDescriptor<'a> {
-    pub fn new(vertex_buffers: impl IntoCow<'a, [VertexBufferDescriptor<'a>]>) -> Self {
-        Self {
-            index_format: IndexFormat::default(),
-            vertex_buffers: vertex_buffers.into_cow(),
-        }
-    }
-
-    pub fn index_format(&mut self, format: IndexFormat) -> &mut Self {
-        self.index_format = format;
-        self
-    }
-}
-
 /// Vertex Format for a Vertex Attribute (input).
 #[repr(C)]
 #[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
@@ -1355,27 +1178,6 @@ impl<L> BufferDescriptor<L> {
     }
 }
 
-impl<'a> BufferDescriptor<Option<Cow<'a, str>>> {
-    pub fn new(usage: BufferUsage, size: BufferAddress) -> Self {
-        BufferDescriptor {
-            label: None,
-            size,
-            usage,
-            mapped_at_creation: false,
-        }
-    }
-
-    pub fn label(&mut self, label: impl IntoCow<'a, str>) -> &mut Self {
-        self.label = Some(label.into_cow());
-        self
-    }
-
-    pub fn mapped_at_creation(&mut self) -> &mut Self {
-        self.mapped_at_creation = true;
-        self
-    }
-}
-
 /// Describes a [`CommandEncoder`].
 #[repr(C)]
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
@@ -1392,26 +1194,12 @@ impl<L> CommandEncoderDescriptor<L> {
     }
 }
 
-impl<'a> CommandEncoderDescriptor<Option<Cow<'a, str>>> {
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    pub fn label(&mut self, label: impl IntoCow<'a, str>) -> &mut Self {
-        self.label = Some(label.into_cow());
-        self
-    }
-}
-
-impl<'a> Default for CommandEncoderDescriptor<Option<Cow<'a, str>>> {
+impl<T> Default for CommandEncoderDescriptor<Option<T>> {
     fn default() -> Self {
         Self { label: None }
     }
 }
 
-/// Integral type used for dynamic bind group offsets.
-pub type DynamicOffset = u32;
-
 /// Behavior of the presentation engine based on frame rate.
 #[repr(C)]
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
@@ -1478,33 +1266,6 @@ pub struct SwapChainDescriptor {
     pub present_mode: PresentMode,
 }
 
-impl SwapChainDescriptor {
-    pub fn new(width: u32, height: u32) -> Self {
-        Self {
-            usage: TextureUsage::OUTPUT_ATTACHMENT,
-            format: TextureFormat::Bgra8UnormSrgb,
-            width,
-            height,
-            present_mode: PresentMode::Fifo,
-        }
-    }
-
-    pub fn usage(&mut self, usage: TextureUsage) -> &mut Self {
-        self.usage = usage;
-        self
-    }
-
-    pub fn format(&mut self, format: TextureFormat) -> &mut Self {
-        self.format = format;
-        self
-    }
-
-    pub fn present_mode(&mut self, present_mode: PresentMode) -> &mut Self {
-        self.present_mode = present_mode;
-        self
-    }
-}
-
 /// Status of the recieved swapchain image.
 #[repr(C)]
 #[derive(Debug)]
@@ -1516,29 +1277,6 @@ pub enum SwapChainStatus {
     Lost,
 }
 
-/// Describes the attachments of a render pass.
-#[derive(Clone, Debug, Default, PartialEq)]
-pub struct RenderPassDescriptor<'a, C: Clone, D> {
-    /// The color attachments of the render pass.
-    pub color_attachments: Cow<'a, [C]>,
-    /// The depth and stencil attachment of the render pass, if any.
-    pub depth_stencil_attachment: Option<D>,
-}
-
-impl<'a, C: Clone, D> RenderPassDescriptor<'a, C, D> {
-    pub fn new(color_attachments: impl IntoCow<'a, [C]>) -> Self {
-        Self {
-            color_attachments: color_attachments.into_cow(),
-            depth_stencil_attachment: None,
-        }
-    }
-
-    pub fn depth_stencil_attachment(&mut self, attachment: D) -> &mut Self {
-        self.depth_stencil_attachment = Some(attachment);
-        self
-    }
-}
-
 /// RGBA double precision color.
 ///
 /// This is not to be used as a generic color type, only for specific wgpu interfaces.
@@ -1637,6 +1375,16 @@ pub struct Extent3d {
     pub depth: u32,
 }
 
+impl Default for Extent3d {
+    fn default() -> Self {
+        Extent3d {
+            width: 1,
+            height: 1,
+            depth: 1,
+        }
+    }
+}
+
 /// Describes a [`Texture`].
 #[repr(C)]
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
@@ -1674,42 +1422,6 @@ impl<L> TextureDescriptor<L> {
     }
 }
 
-/// Texture descriptor builder methods
-impl<'a> TextureDescriptor<Option<Cow<'a, str>>> {
-    pub fn new(
-        size: Extent3d,
-        dimension: TextureDimension,
-        format: TextureFormat,
-        usage: TextureUsage,
-    ) -> Self {
-        Self {
-            label: None,
-            size,
-            mip_level_count: 1,
-            sample_count: 1,
-            dimension,
-            format,
-            usage,
-        }
-    }
-
-    pub fn label(&mut self, label: impl IntoCow<'a, str>) -> &mut Self {
-        self.label = Some(label.into_cow());
-        self
-    }
-
-    pub fn mip_level_count(&mut self, count: u32) -> &mut Self {
-        // TODO: validate this size is sane
-        self.mip_level_count = count;
-        self
-    }
-
-    pub fn sample_count(&mut self, count: u32) -> &mut Self {
-        self.sample_count = count;
-        self
-    }
-}
-
 /// Kind of data the texture holds.
 #[repr(C)]
 #[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
@@ -1730,95 +1442,6 @@ impl Default for TextureAspect {
     }
 }
 
-/// Describes a [`TextureView`].
-#[repr(C)]
-#[derive(Clone, Debug, PartialEq)]
-#[cfg_attr(feature = "trace", derive(Serialize))]
-#[cfg_attr(feature = "replay", derive(Deserialize))]
-pub struct TextureViewDescriptor<L> {
-    /// Debug label of the texture view. This will show up in graphics debuggers for easy identification.
-    pub label: L,
-    /// Format of the texture view. At this time, it must be the same as the underlying format of the texture.
-    pub format: TextureFormat,
-    /// The dimension of the texture view. For 1D textures, this must be `1D`. For 2D textures it must be one of
-    /// `D2`, `D2Array`, `Cube`, and `CubeArray`. For 3D textures it must be `3D`
-    pub dimension: TextureViewDimension,
-    /// Aspect of the texture. Color textures must be [`TextureAspect::All`].
-    pub aspect: TextureAspect,
-    /// Base mip level.
-    pub base_mip_level: u32,
-    /// Mip level count.
-    /// If `Some(count)`, `base_mip_level + count` must be less or equal to underlying texture mip count.
-    /// If `None`, considered to include the rest of the mipmap levels, but at least 1 in total.
-    pub level_count: Option<NonZeroU32>,
-    /// Base array layer.
-    pub base_array_layer: u32,
-    /// Layer count.
-    /// If `Some(count)`, `base_array_layer + count` must be less or equal to the underlying array count.
-    /// If `None`, considered to include the rest of the array layers, but at least 1 in total.
-    pub array_layer_count: Option<NonZeroU32>,
-}
-
-impl<'a> TextureViewDescriptor<Option<Cow<'a, str>>> {
-    pub fn new(format: TextureFormat, dimension: TextureViewDimension) -> Self {
-        Self {
-            label: None,
-            format,
-            dimension,
-            aspect: TextureAspect::default(),
-            base_mip_level: 0,
-            level_count: None,
-            base_array_layer: 0,
-            array_layer_count: None,
-        }
-    }
-
-    pub fn label(&mut self, label: impl IntoCow<'a, str>) -> &mut Self {
-        self.label = Some(label.into_cow());
-        self
-    }
-}
-
-impl<L> TextureViewDescriptor<L> {
-    pub fn aspect(&mut self, aspect: TextureAspect) -> &mut Self {
-        self.aspect = aspect;
-        self
-    }
-
-    pub fn base_mip_level(&mut self, base_mip_level: u32) -> &mut Self {
-        self.base_mip_level = base_mip_level;
-        self
-    }
-
-    pub fn level_count(&mut self, level_count: u32) -> &mut Self {
-        self.level_count = Some(NonZeroU32::new(level_count).unwrap());
-        self
-    }
-
-    pub fn base_array_layer(&mut self, base_array_layer: u32) -> &mut Self {
-        self.base_array_layer = base_array_layer;
-        self
-    }
-
-    pub fn array_layer_count(&mut self, array_layer_count: u32) -> &mut Self {
-        self.array_layer_count = Some(NonZeroU32::new(array_layer_count).unwrap());
-        self
-    }
-
-    pub fn map_label<K>(&self, fun: impl FnOnce(&L) -> K) -> TextureViewDescriptor<K> {
-        TextureViewDescriptor {
-            label: fun(&self.label),
-            format: self.format,
-            dimension: self.dimension,
-            aspect: self.aspect,
-            base_mip_level: self.base_mip_level,
-            level_count: self.level_count,
-            base_array_layer: self.base_array_layer,
-            array_layer_count: self.array_layer_count,
-        }
-    }
-}
-
 /// How edges should be handled in texture addressing.
 #[repr(C)]
 #[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
@@ -1870,199 +1493,6 @@ impl Default for FilterMode {
     }
 }
 
-/// Describes a [`Sampler`]
-#[derive(Clone, Debug, PartialEq)]
-#[cfg_attr(feature = "trace", derive(Serialize))]
-#[cfg_attr(feature = "replay", derive(Deserialize))]
-pub struct SamplerDescriptor<L> {
-    /// Debug label of the sampler. This will show up in graphics debuggers for easy identification.
-    pub label: L,
-    /// How to deal with out of bounds accesses in the u (i.e. x) direction
-    pub address_mode_u: AddressMode,
-    /// How to deal with out of bounds accesses in the v (i.e. y) direction
-    pub address_mode_v: AddressMode,
-    /// How to deal with out of bounds accesses in the w (i.e. z) direction
-    pub address_mode_w: AddressMode,
-    /// How to filter the texture when it needs to be magnified (made larger)
-    pub mag_filter: FilterMode,
-    /// How to filter the texture when it needs to be minified (made smaller)
-    pub min_filter: FilterMode,
-    /// How to filter between mip map levels
-    pub mipmap_filter: FilterMode,
-    /// Minimum level of detail (i.e. mip level) to use
-    pub lod_min_clamp: f32,
-    /// Maximum level of detail (i.e. mip level) to use
-    pub lod_max_clamp: f32,
-    /// If this is enabled, this is a comparison sampler using the given comparison function.
-    pub compare: Option<CompareFunction>,
-    /// Valid values: 1, 2, 4, 8, and 16.
-    pub anisotropy_clamp: Option<u8>,
-}
-
-impl<L: Default> Default for SamplerDescriptor<L> {
-    fn default() -> Self {
-        Self {
-            label: Default::default(),
-            address_mode_u: Default::default(),
-            address_mode_v: Default::default(),
-            address_mode_w: Default::default(),
-            mag_filter: Default::default(),
-            min_filter: Default::default(),
-            mipmap_filter: Default::default(),
-            lod_min_clamp: 0.0,
-            lod_max_clamp: std::f32::MAX,
-            compare: Default::default(),
-            anisotropy_clamp: Default::default(),
-        }
-    }
-}
-
-impl<L: Default> SamplerDescriptor<L> {
-    pub fn new() -> Self {
-        Self::default()
-    }
-}
-
-impl<L> SamplerDescriptor<L> {
-    pub fn address_mode_u(&mut self, mode: AddressMode) -> &mut Self {
-        self.address_mode_u = mode;
-        self
-    }
-
-    pub fn address_mode_v(&mut self, mode: AddressMode) -> &mut Self {
-        self.address_mode_v = mode;
-        self
-    }
-
-    pub fn address_mode_w(&mut self, mode: AddressMode) -> &mut Self {
-        self.address_mode_w = mode;
-        self
-    }
-
-    pub fn mag_filter(&mut self, mode: FilterMode) -> &mut Self {
-        self.mag_filter = mode;
-        self
-    }
-
-    pub fn min_filter(&mut self, mode: FilterMode) -> &mut Self {
-        self.min_filter = mode;
-        self
-    }
-
-    pub fn lod_min_clamp(&mut self, clamp: f32) -> &mut Self {
-        self.lod_min_clamp = clamp;
-        self
-    }
-
-    pub fn lod_max_clamp(&mut self, clamp: f32) -> &mut Self {
-        self.lod_max_clamp = clamp;
-        self
-    }
-
-    pub fn compare(&mut self, fun: CompareFunction) -> &mut Self {
-        self.compare = Some(fun);
-        self
-    }
-
-    pub fn anisotropy_clamp(&mut self, clamp: u8) -> &mut Self {
-        //TODO check if value is sensible
-        self.anisotropy_clamp = Some(clamp);
-        self
-    }
-
-    pub fn map_label<K>(&self, fun: impl FnOnce(&L) -> K) -> SamplerDescriptor<K> {
-        SamplerDescriptor {
-            label: fun(&self.label),
-            address_mode_u: self.address_mode_u,
-            address_mode_v: self.address_mode_v,
-            address_mode_w: self.address_mode_w,
-            mag_filter: self.mag_filter,
-            min_filter: self.min_filter,
-            mipmap_filter: self.mipmap_filter,
-            lod_min_clamp: self.lod_min_clamp,
-            lod_max_clamp: self.lod_max_clamp,
-            compare: self.compare,
-            anisotropy_clamp: self.anisotropy_clamp,
-        }
-    }
-}
-
-/// Bindable resource and the slot to bind it to.
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
-#[cfg_attr(feature = "trace", derive(Serialize))]
-#[cfg_attr(feature = "replay", derive(Deserialize))]
-pub struct BindGroupEntry<R> {
-    /// Slot for which binding provides resource. Corresponds to an entry of the same
-    /// binding index in the [`BindGroupLayoutDescriptor`].
-    pub binding: u32,
-    /// Resource to attach to the binding
-    pub resource: R,
-}
-
-impl<R> BindGroupEntry<R> {
-    pub fn new(binding: u32, resource: R) -> Self {
-        Self { binding, resource }
-    }
-}
-
-/// Describes a group of bindings and the resources to be bound.
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
-#[cfg_attr(feature = "trace", derive(Serialize))]
-#[cfg_attr(feature = "replay", derive(Deserialize))]
-pub struct BindGroupDescriptor<'a, L, B: Clone> {
-    /// Debug label of the bind group. This will show up in graphics debuggers for easy identification.
-    pub label: Option<Cow<'a, str>>,
-    /// The [`BindGroupLayout`] that corresponds to this bind group.
-    pub layout: L,
-    /// The resources to bind to this bind group.
-    pub entries: Cow<'a, [B]>,
-}
-
-impl<'a, L, B: Clone> BindGroupDescriptor<'a, L, B> {
-    pub fn new(layout: L, entries: impl IntoCow<'a, [B]>) -> Self {
-        Self {
-            label: None,
-            layout,
-            entries: entries.into_cow(),
-        }
-    }
-
-    pub fn label(&mut self, label: impl IntoCow<'a, str>) -> &mut Self {
-        self.label = Some(label.into_cow());
-        self
-    }
-}
-
-/// Describes a pipeline layout.
-///
-/// A `PipelineLayoutDescriptor` can be used to create a pipeline layout.
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
-#[cfg_attr(feature = "trace", derive(Serialize))]
-#[cfg_attr(feature = "replay", derive(Deserialize))]
-pub struct PipelineLayoutDescriptor<'a, B: Clone> {
-    /// Bind groups that this pipeline uses. The first entry will provide all the bindings for
-    /// "set = 0", second entry will provide all the bindings for "set = 1" etc.
-    pub bind_group_layouts: Cow<'a, [B]>,
-    /// Set of push constant ranges this pipeline uses. Each shader stage that uses push constants
-    /// must define the range in push constant memory that corresponds to its single `layout(push_constant)`
-    /// uniform block.
-    ///
-    /// If this array is non-empty, the [`Features::PUSH_CONSTANTS`] must be enabled.
-    pub push_constant_ranges: Cow<'a, [PushConstantRange]>,
-}
-
-impl<'a, B: Clone> PipelineLayoutDescriptor<'a, B> {
-    pub fn new(
-        bind_group_layouts: impl IntoCow<'a, [B]>,
-        push_constant_ranges: impl IntoCow<'a, [PushConstantRange]>,
-    ) -> Self {
-        Self {
-            bind_group_layouts: bind_group_layouts.into_cow(),
-            push_constant_ranges: push_constant_ranges.into_cow(),
-        }
-    }
-}
-
 /// A range of push constant memory to pass to a shader stage.
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 #[cfg_attr(feature = "trace", derive(Serialize))]
@@ -2076,210 +1506,21 @@ pub struct PushConstantRange {
     pub range: Range<u32>,
 }
 
-impl PushConstantRange {
-    pub fn new(stages: ShaderStage, range: Range<u32>) -> Self {
-        Self { stages, range }
-    }
-}
-
-/// Describes a programmable pipeline stage.
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
-#[cfg_attr(feature = "trace", derive(serde::Serialize))]
-#[cfg_attr(feature = "replay", derive(serde::Deserialize))]
-pub struct ProgrammableStageDescriptor<'a, M> {
-    /// The compiled shader module for this stage.
-    pub module: M,
-    /// The name of the entry point in the compiled shader. There must be a function that returns
-    /// void with this name in the shader.
-    pub entry_point: Cow<'a, str>,
-}
-
-impl<'a, M> ProgrammableStageDescriptor<'a, M> {
-    pub fn new(module: M, entry_point: impl IntoCow<'a, str>) -> Self {
-        Self {
-            module,
-            entry_point: entry_point.into_cow(),
-        }
-    }
-}
-
-/// Describes a render (graphics) pipeline.
-#[derive(Clone, Debug)]
-#[cfg_attr(feature = "trace", derive(serde::Serialize))]
-#[cfg_attr(feature = "replay", derive(serde::Deserialize))]
-pub struct RenderPipelineDescriptor<'a, L, D> {
-    /// The layout of bind groups for this pipeline.
-    pub layout: Option<L>,
-    /// The compiled vertex stage and its entry point.
-    pub vertex_stage: D,
-    /// The compiled fragment stage and its entry point, if any.
-    pub fragment_stage: Option<D>,
-    /// The rasterization process for this pipeline.
-    pub rasterization_state: Option<RasterizationStateDescriptor>,
-    /// The primitive topology used to interpret vertices.
-    pub primitive_topology: PrimitiveTopology,
-    /// The effect of draw calls on the color aspect of the output target.
-    pub color_states: Cow<'a, [ColorStateDescriptor]>,
-    /// The effect of draw calls on the depth and stencil aspects of the output target, if any.
-    pub depth_stencil_state: Option<DepthStencilStateDescriptor>,
-    /// The vertex input state for this pipeline.
-    pub vertex_state: VertexStateDescriptor<'a>,
-    /// The number of samples calculated per pixel (for MSAA). For non-multisampled textures,
-    /// this should be `1`
-    pub sample_count: u32,
-    /// Bitmask that restricts the samples of a pixel modified by this pipeline. All samples
-    /// can be enabled using the value `!0`
-    pub sample_mask: u32,
-    /// When enabled, produces another sample mask per pixel based on the alpha output value, that
-    /// is ANDed with the sample_mask and the primitive coverage to restrict the set of samples
-    /// affected by a primitive.
-    ///
-    /// The implicit mask produced for alpha of zero is guaranteed to be zero, and for alpha of one
-    /// is guaranteed to be all 1-s.
-    pub alpha_to_coverage_enabled: bool,
-}
-
-impl<'a, L, D> RenderPipelineDescriptor<'a, L, D> {
-    pub fn new(
-        vertex_stage: D,
-        primitive_topology: PrimitiveTopology,
-        color_states: impl IntoCow<'a, [ColorStateDescriptor]>,
-        vertex_state: VertexStateDescriptor<'a>,
-    ) -> Self {
-        Self {
-            layout: None,
-            vertex_stage,
-            fragment_stage: None,
-            rasterization_state: None,
-            primitive_topology,
-            color_states: color_states.into_cow(),
-            depth_stencil_state: None,
-            vertex_state,
-            sample_count: 1,
-            sample_mask: !0,
-            alpha_to_coverage_enabled: false,
-        }
-    }
-
-    pub fn layout(&mut self, layout: L) -> &mut Self {
-        self.layout = Some(layout);
-        self
-    }
-
-    pub fn fragment_stage(&mut self, stage: D) -> &mut Self {
-        self.fragment_stage = Some(stage);
-        self
-    }
-
-    pub fn rasterization_state(&mut self, state: RasterizationStateDescriptor) -> &mut Self {
-        self.rasterization_state = Some(state);
-        self
-    }
-
-    pub fn depth_stencil_state(&mut self, state: DepthStencilStateDescriptor) -> &mut Self {
-        self.depth_stencil_state = Some(state);
-        self
-    }
-
-    pub fn sample_count(&mut self, count: u32) -> &mut Self {
-        self.sample_count = count;
-        self
-    }
-
-    pub fn sample_mask(&mut self, mask: u32) -> &mut Self {
-        self.sample_mask = mask;
-        self
-    }
-
-    pub fn alpha_to_coverage(&mut self) -> &mut Self {
-        self.alpha_to_coverage_enabled = true;
-        self
-    }
-}
-
-/// Describes a compute pipeline.
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
-#[cfg_attr(feature = "trace", derive(serde::Serialize))]
-#[cfg_attr(feature = "replay", derive(serde::Deserialize))]
-pub struct ComputePipelineDescriptor<L, D> {
-    /// The layout of bind groups for this pipeline.
-    pub layout: Option<L>,
-    /// The compiled compute stage and its entry point.
-    pub compute_stage: D,
-}
-
-impl<L, D> ComputePipelineDescriptor<L, D> {
-    pub fn new(compute_stage: D) -> Self {
-        Self {
-            layout: None,
-            compute_stage,
-        }
-    }
-
-    pub fn layout(&mut self, layout: L) -> &mut Self {
-        self.layout = Some(layout);
-        self
-    }
-}
-
 /// Describes a [`CommandBuffer`].
 #[repr(C)]
 #[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
 #[cfg_attr(feature = "trace", derive(Serialize))]
 #[cfg_attr(feature = "replay", derive(Deserialize))]
-pub struct CommandBufferDescriptor {
-    /// Set this member to zero
-    pub todo: u32,
+pub struct CommandBufferDescriptor<L> {
+    pub label: L,
 }
 
-impl CommandBufferDescriptor {
-    pub fn new() -> Self {
-        Self::default()
-    }
-}
-
-/// Describes a [`RenderBundleEncoder`].
-#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
-#[cfg_attr(feature = "trace", derive(serde::Serialize))]
-#[cfg_attr(feature = "replay", derive(serde::Deserialize))]
-pub struct RenderBundleEncoderDescriptor<'a> {
-    /// Debug label of the render bundle encoder. This will show up in graphics debuggers for easy identification.
-    pub label: Option<Cow<'a, str>>,
-    /// The formats of the color attachments that this render bundle is capable to rendering to. This
-    /// must match the formats of the color attachments in the renderpass this render bundle is executed in.
-    pub color_formats: Cow<'a, [TextureFormat]>,
-    /// The formats of the depth attachment that this render bundle is capable to rendering to. This
-    /// must match the formats of the depth attachments in the renderpass this render bundle is executed in.
-    pub depth_stencil_format: Option<TextureFormat>,
-    /// Sample count this render bundle is capable of rendering to. This must match the pipelines and
-    /// the renderpasses it is used in.
-    pub sample_count: u32,
-}
-
-impl<'a> RenderBundleEncoderDescriptor<'a> {
-    pub fn new(color_formats: impl IntoCow<'a, [TextureFormat]>) -> Self {
-        Self {
-            label: None,
-            color_formats: color_formats.into_cow(),
-            depth_stencil_format: None,
-            sample_count: 1,
+impl<L> CommandBufferDescriptor<L> {
+    pub fn map_label<K>(&self, fun: impl FnOnce(&L) -> K) -> CommandBufferDescriptor<K> {
+        CommandBufferDescriptor {
+            label: fun(&self.label),
         }
     }
-
-    pub fn label(&mut self, label: impl IntoCow<'a, str>) -> &mut Self {
-        self.label = Some(label.into_cow());
-        self
-    }
-
-    pub fn depth_stencil_format(&mut self, format: TextureFormat) -> &mut Self {
-        self.depth_stencil_format = Some(format);
-        self
-    }
-
-    pub fn sample_count(&mut self, count: u32) -> &mut Self {
-        self.sample_count = count;
-        self
-    }
 }
 
 /// Describes a [`RenderBundle`].
@@ -2300,18 +1541,7 @@ impl<L> RenderBundleDescriptor<L> {
     }
 }
 
-impl<'a> RenderBundleDescriptor<Option<Cow<'a, str>>> {
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    pub fn label(&mut self, label: impl IntoCow<'a, str>) -> &mut Self {
-        self.label = Some(label.into_cow());
-        self
-    }
-}
-
-impl<'a> Default for RenderBundleDescriptor<Option<Cow<'a, str>>> {
+impl<T> Default for RenderBundleDescriptor<Option<T>> {
     fn default() -> Self {
         Self { label: None }
     }
@@ -2396,7 +1626,7 @@ impl From<TextureFormat> for TextureComponentType {
 
 /// Layout of a texture in a buffer's memory.
 #[repr(C)]
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Default)]
 #[cfg_attr(feature = "trace", derive(serde::Serialize))]
 #[cfg_attr(feature = "replay", derive(serde::Deserialize))]
 pub struct TextureDataLayout {
@@ -2418,26 +1648,6 @@ pub struct TextureDataLayout {
     pub rows_per_image: u32,
 }
 
-impl TextureDataLayout {
-    pub fn new(bytes_per_row: u32) -> Self {
-        Self {
-            offset: 0,
-            bytes_per_row,
-            rows_per_image: 0,
-        }
-    }
-
-    pub fn offset(&mut self, offset: BufferAddress) -> &mut Self {
-        self.offset = offset;
-        self
-    }
-
-    pub fn rows_per_image(&mut self, rows_per_image: u32) -> &mut Self {
-        self.rows_per_image = rows_per_image;
-        self
-    }
-}
-
 /// Specific type of a binding.
 ///
 /// WebGPU spec: https://gpuweb.github.io/gpuweb/#dictdef-gpubindgrouplayoutentry
@@ -2545,6 +1755,16 @@ pub enum BindingType {
     },
 }
 
+impl BindingType {
+    pub fn has_dynamic_offset(&self) -> bool {
+        match *self {
+            BindingType::UniformBuffer { dynamic, .. }
+            | BindingType::StorageBuffer { dynamic, .. } => dynamic,
+            _ => false,
+        }
+    }
+}
+
 /// Describes a single binding inside a bind group.
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 #[cfg_attr(feature = "trace", derive(Serialize))]
@@ -2562,57 +1782,7 @@ pub struct BindGroupLayoutEntry {
     /// If this value is Some and `ty` is `BindingType::SampledTexture`, [`Capabilities::SAMPLED_TEXTURE_BINDING_ARRAY`] must be supported.
     ///
     /// If this value is Some and `ty` is any other variant, bind group creation will fail.
-    pub count: Option<u32>,
-}
-
-impl BindGroupLayoutEntry {
-    pub fn new(binding: u32, visibility: ShaderStage, ty: BindingType) -> Self {
-        Self {
-            binding,
-            visibility,
-            ty,
-            count: None,
-        }
-    }
-
-    pub fn count(&mut self, count: u32) -> &mut Self {
-        self.count = Some(count);
-        self
-    }
-
-    pub fn has_dynamic_offset(&self) -> bool {
-        match self.ty {
-            BindingType::UniformBuffer { dynamic, .. }
-            | BindingType::StorageBuffer { dynamic, .. } => dynamic,
-            _ => false,
-        }
-    }
-}
-
-/// Describes a [`BindGroupLayout`].
-#[derive(Clone, Debug)]
-#[cfg_attr(feature = "trace", derive(serde::Serialize))]
-#[cfg_attr(feature = "replay", derive(serde::Deserialize))]
-pub struct BindGroupLayoutDescriptor<'a> {
-    /// Debug label of the bind group layout. This will show up in graphics debuggers for easy identification.
-    pub label: Option<Cow<'a, str>>,
-
-    /// Array of entries in this BindGroupLayout
-    pub entries: Cow<'a, [BindGroupLayoutEntry]>,
-}
-
-impl<'a> BindGroupLayoutDescriptor<'a> {
-    pub fn new(entries: impl IntoCow<'a, [BindGroupLayoutEntry]>) -> Self {
-        Self {
-            label: None,
-            entries: entries.into_cow(),
-        }
-    }
-
-    pub fn label(&mut self, label: impl IntoCow<'a, str>) -> &mut Self {
-        self.label = Some(label.into_cow());
-        self
-    }
+    pub count: Option<NonZeroU32>,
 }
 
 /// View of a buffer which can be used to copy to/from a texture.
@@ -2626,12 +1796,6 @@ pub struct BufferCopyView<B> {
     pub layout: TextureDataLayout,
 }
 
-impl<B> BufferCopyView<B> {
-    pub fn new(buffer: B, layout: TextureDataLayout) -> Self {
-        Self { buffer, layout }
-    }
-}
-
 /// View of a texture which can be used to copy to/from a buffer/texture.
 #[derive(Clone, Debug)]
 #[cfg_attr(feature = "trace", derive(serde::Serialize))]
@@ -2644,18 +1808,3 @@ pub struct TextureCopyView<T> {
     /// The base texel of the texture in the selected `mip_level`.
     pub origin: Origin3d,
 }
-
-impl<T> TextureCopyView<T> {
-    pub fn new(texture: T) -> Self {
-        Self {
-            texture,
-            origin: Origin3d::default(),
-            mip_level: 1,
-        }
-    }
-
-    pub fn mip_level(&mut self, level: u32) -> &mut Self {
-        self.mip_level = level;
-        self
-    }
-}