Adding upstream version 110.0.1.upstream/110.0.1upstream

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

86 files changed, 8594 insertions, 0 deletions

diff --git a/dom/webgpu/Adapter.cpp b/dom/webgpu/Adapter.cpp
new file mode 100644
index 0000000000..ef857b70e8
--- /dev/null
+++ b/dom/webgpu/Adapter.cpp
@@ -0,0 +1,134 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/dom/WebGPUBinding.h"
+#include "Adapter.h"
+
+#include "Device.h"
+#include "Instance.h"
+#include "SupportedFeatures.h"
+#include "SupportedLimits.h"
+#include "ipc/WebGPUChild.h"
+#include "mozilla/dom/Promise.h"
+#include "mozilla/webgpu/ffi/wgpu.h"
+
+namespace mozilla::webgpu {
+
+GPU_IMPL_CYCLE_COLLECTION(Adapter, mParent, mBridge, mFeatures, mLimits)
+GPU_IMPL_JS_WRAP(Adapter)
+
+Maybe<uint32_t> Adapter::MakeFeatureBits(
+    const dom::Sequence<dom::GPUFeatureName>& aFeatures) {
+  uint32_t bits = 0;
+  for (const auto& feature : aFeatures) {
+    if (feature == dom::GPUFeatureName::Depth_clip_control) {
+      bits |= WGPUFeatures_DEPTH_CLIP_CONTROL;
+    } else if (feature == dom::GPUFeatureName::Texture_compression_bc) {
+      bits |= WGPUFeatures_TEXTURE_COMPRESSION_BC;
+    } else if (feature == dom::GPUFeatureName::Indirect_first_instance) {
+      bits |= WGPUFeatures_INDIRECT_FIRST_INSTANCE;
+    } else {
+      NS_WARNING(
+          nsPrintfCString("Requested feature bit '%d' is not recognized.",
+                          static_cast<int>(feature))
+              .get());
+      return Nothing();
+    }
+  }
+  return Some(bits);
+}
+
+Adapter::Adapter(Instance* const aParent, WebGPUChild* const aBridge,
+                 const ffi::WGPUAdapterInformation& aInfo)
+    : ChildOf(aParent),
+      mBridge(aBridge),
+      mId(aInfo.id),
+      mFeatures(new SupportedFeatures(this)),
+      mLimits(
+          new SupportedLimits(this, MakeUnique<ffi::WGPULimits>(aInfo.limits))),
+      mIsFallbackAdapter(aInfo.ty == ffi::WGPUDeviceType_Cpu) {
+  ErrorResult result;  // TODO: should this come from outside
+  // This list needs to match `AdapterRequestDevice`
+  if (aInfo.features & WGPUFeatures_DEPTH_CLIP_CONTROL) {
+    dom::GPUSupportedFeatures_Binding::SetlikeHelpers::Add(
+        mFeatures, u"depth-clip-control"_ns, result);
+  }
+  if (aInfo.features & WGPUFeatures_TEXTURE_COMPRESSION_BC) {
+    dom::GPUSupportedFeatures_Binding::SetlikeHelpers::Add(
+        mFeatures, u"texture-compression-bc"_ns, result);
+  }
+  if (aInfo.features & WGPUFeatures_INDIRECT_FIRST_INSTANCE) {
+    dom::GPUSupportedFeatures_Binding::SetlikeHelpers::Add(
+        mFeatures, u"indirect-first-instance"_ns, result);
+  }
+}
+
+Adapter::~Adapter() { Cleanup(); }
+
+void Adapter::Cleanup() {
+  if (mValid && mBridge && mBridge->CanSend()) {
+    mValid = false;
+    mBridge->SendAdapterDestroy(mId);
+  }
+}
+
+const RefPtr<SupportedFeatures>& Adapter::Features() const { return mFeatures; }
+const RefPtr<SupportedLimits>& Adapter::Limits() const { return mLimits; }
+
+already_AddRefed<dom::Promise> Adapter::RequestDevice(
+    const dom::GPUDeviceDescriptor& aDesc, ErrorResult& aRv) {
+  RefPtr<dom::Promise> promise = dom::Promise::Create(GetParentObject(), aRv);
+  if (NS_WARN_IF(aRv.Failed())) {
+    return nullptr;
+  }
+
+  if (!mBridge->CanSend()) {
+    promise->MaybeRejectWithInvalidStateError(
+        "WebGPUChild cannot send, must recreate Adapter");
+    return promise.forget();
+  }
+
+  ffi::WGPULimits limits = {};
+  auto request = mBridge->AdapterRequestDevice(mId, aDesc, &limits);
+  if (request) {
+    RefPtr<Device> device =
+        new Device(this, request->mId, MakeUnique<ffi::WGPULimits>(limits));
+    // copy over the features
+    for (const auto& feature : aDesc.mRequiredFeatures) {
+      NS_ConvertASCIItoUTF16 string(
+          dom::GPUFeatureNameValues::GetString(feature));
+      dom::GPUSupportedFeatures_Binding::SetlikeHelpers::Add(device->mFeatures,
+                                                             string, aRv);
+    }
+
+    request->mPromise->Then(
+        GetCurrentSerialEventTarget(), __func__,
+        [promise, device](bool aSuccess) {
+          if (aSuccess) {
+            promise->MaybeResolve(device);
+          } else {
+            // In this path, request->mId has an error entry in the wgpu
+            // registry, so let Device::~Device clean things up on both the
+            // child and parent side.
+            promise->MaybeRejectWithInvalidStateError(
+                "Unable to fulfill requested features and limits");
+          }
+        },
+        [promise, device](const ipc::ResponseRejectReason& aReason) {
+          // We can't be sure how far along the WebGPUParent got in handling
+          // our AdapterRequestDevice message, but we can't communicate with it,
+          // so clear up our client state for this Device without trying to
+          // communicate with the parent about it.
+          device->CleanupUnregisteredInParent();
+          promise->MaybeRejectWithNotSupportedError("IPC error");
+        });
+  } else {
+    promise->MaybeRejectWithNotSupportedError("Unable to instantiate a Device");
+  }
+
+  return promise.forget();
+}
+
+}  // namespace mozilla::webgpu
diff --git a/dom/webgpu/Adapter.h b/dom/webgpu/Adapter.h
new file mode 100644
index 0000000000..c2477b8c89
--- /dev/null
+++ b/dom/webgpu/Adapter.h
@@ -0,0 +1,73 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef GPU_Adapter_H_
+#define GPU_Adapter_H_
+
+#include "mozilla/AlreadyAddRefed.h"
+#include "mozilla/webgpu/WebGPUTypes.h"
+#include "nsString.h"
+#include "ObjectModel.h"
+
+namespace mozilla {
+class ErrorResult;
+namespace dom {
+class Promise;
+struct GPUDeviceDescriptor;
+struct GPUExtensions;
+struct GPUFeatures;
+enum class GPUFeatureName : uint8_t;
+template <typename T>
+class Sequence;
+}  // namespace dom
+
+namespace webgpu {
+class Device;
+class Instance;
+class SupportedFeatures;
+class SupportedLimits;
+class WebGPUChild;
+namespace ffi {
+struct WGPUAdapterInformation;
+}  // namespace ffi
+
+class Adapter final : public ObjectBase, public ChildOf<Instance> {
+ public:
+  GPU_DECL_CYCLE_COLLECTION(Adapter)
+  GPU_DECL_JS_WRAP(Adapter)
+
+  RefPtr<WebGPUChild> mBridge;
+
+  static Maybe<uint32_t> MakeFeatureBits(
+      const dom::Sequence<dom::GPUFeatureName>& aFeatures);
+
+ private:
+  ~Adapter();
+  void Cleanup();
+
+  const RawId mId;
+  const nsString mName;
+  // Cant have them as `const` right now, since we wouldn't be able
+  // to unlink them in CC unlink.
+  RefPtr<SupportedFeatures> mFeatures;
+  RefPtr<SupportedLimits> mLimits;
+  const bool mIsFallbackAdapter = false;
+
+ public:
+  Adapter(Instance* const aParent, WebGPUChild* const aBridge,
+          const ffi::WGPUAdapterInformation& aInfo);
+  void GetName(nsString& out) const { out = mName; }
+  const RefPtr<SupportedFeatures>& Features() const;
+  const RefPtr<SupportedLimits>& Limits() const;
+  bool IsFallbackAdapter() const { return mIsFallbackAdapter; }
+
+  already_AddRefed<dom::Promise> RequestDevice(
+      const dom::GPUDeviceDescriptor& aDesc, ErrorResult& aRv);
+};
+
+}  // namespace webgpu
+}  // namespace mozilla
+
+#endif  // GPU_Adapter_H_
diff --git a/dom/webgpu/BindGroup.cpp b/dom/webgpu/BindGroup.cpp
new file mode 100644
index 0000000000..d03aaefee9
--- /dev/null
+++ b/dom/webgpu/BindGroup.cpp
@@ -0,0 +1,36 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/dom/WebGPUBinding.h"
+#include "BindGroup.h"
+#include "ipc/WebGPUChild.h"
+
+#include "Device.h"
+
+namespace mozilla::webgpu {
+
+GPU_IMPL_CYCLE_COLLECTION(BindGroup, mParent)
+GPU_IMPL_JS_WRAP(BindGroup)
+
+BindGroup::BindGroup(Device* const aParent, RawId aId)
+    : ChildOf(aParent), mId(aId) {
+  if (!aId) {
+    mValid = false;
+  }
+}
+
+BindGroup::~BindGroup() { Cleanup(); }
+
+void BindGroup::Cleanup() {
+  if (mValid && mParent) {
+    mValid = false;
+    auto bridge = mParent->GetBridge();
+    if (bridge && bridge->IsOpen()) {
+      bridge->SendBindGroupDestroy(mId);
+    }
+  }
+}
+
+}  // namespace mozilla::webgpu
diff --git a/dom/webgpu/BindGroup.h b/dom/webgpu/BindGroup.h
new file mode 100644
index 0000000000..4f67c906f3
--- /dev/null
+++ b/dom/webgpu/BindGroup.h
@@ -0,0 +1,33 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef GPU_BindGroup_H_
+#define GPU_BindGroup_H_
+
+#include "nsWrapperCache.h"
+#include "ObjectModel.h"
+#include "mozilla/webgpu/WebGPUTypes.h"
+
+namespace mozilla::webgpu {
+
+class Device;
+
+class BindGroup final : public ObjectBase, public ChildOf<Device> {
+ public:
+  GPU_DECL_CYCLE_COLLECTION(BindGroup)
+  GPU_DECL_JS_WRAP(BindGroup)
+
+  BindGroup(Device* const aParent, RawId aId);
+
+  const RawId mId;
+
+ private:
+  ~BindGroup();
+  void Cleanup();
+};
+
+}  // namespace mozilla::webgpu
+
+#endif  // GPU_BindGroup_H_
diff --git a/dom/webgpu/BindGroupLayout.cpp b/dom/webgpu/BindGroupLayout.cpp
new file mode 100644
index 0000000000..27ecbd3684
--- /dev/null
+++ b/dom/webgpu/BindGroupLayout.cpp
@@ -0,0 +1,36 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/dom/WebGPUBinding.h"
+#include "BindGroupLayout.h"
+#include "ipc/WebGPUChild.h"
+
+#include "Device.h"
+
+namespace mozilla::webgpu {
+
+GPU_IMPL_CYCLE_COLLECTION(BindGroupLayout, mParent)
+GPU_IMPL_JS_WRAP(BindGroupLayout)
+
+BindGroupLayout::BindGroupLayout(Device* const aParent, RawId aId, bool aOwning)
+    : ChildOf(aParent), mId(aId), mOwning(aOwning) {
+  if (!aId) {
+    mValid = false;
+  }
+}
+
+BindGroupLayout::~BindGroupLayout() { Cleanup(); }
+
+void BindGroupLayout::Cleanup() {
+  if (mValid && mParent) {
+    mValid = false;
+    auto bridge = mParent->GetBridge();
+    if (mOwning && bridge && bridge->IsOpen()) {
+      bridge->SendBindGroupLayoutDestroy(mId);
+    }
+  }
+}
+
+}  // namespace mozilla::webgpu
diff --git a/dom/webgpu/BindGroupLayout.h b/dom/webgpu/BindGroupLayout.h
new file mode 100644
index 0000000000..fcd721ab5f
--- /dev/null
+++ b/dom/webgpu/BindGroupLayout.h
@@ -0,0 +1,34 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef GPU_BindGroupLayout_H_
+#define GPU_BindGroupLayout_H_
+
+#include "nsWrapperCache.h"
+#include "ObjectModel.h"
+#include "mozilla/webgpu/WebGPUTypes.h"
+
+namespace mozilla::webgpu {
+
+class Device;
+
+class BindGroupLayout final : public ObjectBase, public ChildOf<Device> {
+ public:
+  GPU_DECL_CYCLE_COLLECTION(BindGroupLayout)
+  GPU_DECL_JS_WRAP(BindGroupLayout)
+
+  BindGroupLayout(Device* const aParent, RawId aId, bool aOwning);
+
+  const RawId mId;
+  const bool mOwning;
+
+ private:
+  ~BindGroupLayout();
+  void Cleanup();
+};
+
+}  // namespace mozilla::webgpu
+
+#endif  // GPU_BindGroupLayout_H_
diff --git a/dom/webgpu/Buffer.cpp b/dom/webgpu/Buffer.cpp
new file mode 100644
index 0000000000..4222ec9da9
--- /dev/null
+++ b/dom/webgpu/Buffer.cpp
@@ -0,0 +1,335 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/dom/WebGPUBinding.h"
+#include "Buffer.h"
+
+#include "mozilla/dom/Promise.h"
+#include "mozilla/dom/ScriptSettings.h"
+#include "mozilla/HoldDropJSObjects.h"
+#include "mozilla/ipc/Shmem.h"
+#include "ipc/WebGPUChild.h"
+#include "js/ArrayBuffer.h"
+#include "js/RootingAPI.h"
+#include "nsContentUtils.h"
+#include "nsWrapperCache.h"
+#include "Device.h"
+
+namespace mozilla::webgpu {
+
+GPU_IMPL_JS_WRAP(Buffer)
+
+NS_IMPL_CYCLE_COLLECTION_CLASS(Buffer)
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(Buffer)
+  tmp->Drop();
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mParent)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(Buffer)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mParent)
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(Buffer)
+  NS_IMPL_CYCLE_COLLECTION_TRACE_PRESERVED_WRAPPER
+  if (tmp->mMapped) {
+    for (uint32_t i = 0; i < tmp->mMapped->mArrayBuffers.Length(); ++i) {
+      NS_IMPL_CYCLE_COLLECTION_TRACE_JS_MEMBER_CALLBACK(
+          mMapped->mArrayBuffers[i])
+    }
+  }
+NS_IMPL_CYCLE_COLLECTION_TRACE_END
+
+Buffer::Buffer(Device* const aParent, RawId aId, BufferAddress aSize,
+               uint32_t aUsage, ipc::WritableSharedMemoryMapping&& aShmem)
+    : ChildOf(aParent), mId(aId), mSize(aSize), mUsage(aUsage) {
+  mozilla::HoldJSObjects(this);
+  mShmem =
+      std::make_shared<ipc::WritableSharedMemoryMapping>(std::move(aShmem));
+  MOZ_ASSERT(mParent);
+}
+
+Buffer::~Buffer() {
+  Drop();
+  mozilla::DropJSObjects(this);
+}
+
+already_AddRefed<Buffer> Buffer::Create(Device* aDevice, RawId aDeviceId,
+                                        const dom::GPUBufferDescriptor& aDesc,
+                                        ErrorResult& aRv) {
+  if (aDevice->IsLost()) {
+    RefPtr<Buffer> buffer = new Buffer(aDevice, 0, aDesc.mSize, 0,
+                                       ipc::WritableSharedMemoryMapping());
+    return buffer.forget();
+  }
+
+  RefPtr<WebGPUChild> actor = aDevice->GetBridge();
+
+  auto handle = ipc::UnsafeSharedMemoryHandle();
+  auto mapping = ipc::WritableSharedMemoryMapping();
+
+  bool hasMapFlags = aDesc.mUsage & (dom::GPUBufferUsage_Binding::MAP_WRITE |
+                                     dom::GPUBufferUsage_Binding::MAP_READ);
+  if (hasMapFlags || aDesc.mMappedAtCreation) {
+    const auto checked = CheckedInt<size_t>(aDesc.mSize);
+    if (!checked.isValid()) {
+      aRv.ThrowRangeError("Mappable size is too large");
+      return nullptr;
+    }
+    size_t size = checked.value();
+
+    auto maybeShmem = ipc::UnsafeSharedMemoryHandle::CreateAndMap(size);
+
+    if (maybeShmem.isNothing()) {
+      aRv.ThrowAbortError(
+          nsPrintfCString("Unable to allocate shmem of size %" PRIuPTR, size));
+      return nullptr;
+    }
+
+    handle = std::move(maybeShmem.ref().first);
+    mapping = std::move(maybeShmem.ref().second);
+
+    MOZ_RELEASE_ASSERT(mapping.Size() >= size);
+
+    // zero out memory
+    memset(mapping.Bytes().data(), 0, size);
+  }
+
+  RawId id = actor->DeviceCreateBuffer(aDeviceId, aDesc, std::move(handle));
+
+  RefPtr<Buffer> buffer =
+      new Buffer(aDevice, id, aDesc.mSize, aDesc.mUsage, std::move(mapping));
+  if (aDesc.mMappedAtCreation) {
+    // Mapped at creation's raison d'être is write access, since the buffer is
+    // being created and there isn't anything interesting to read in it yet.
+    bool writable = true;
+    buffer->SetMapped(0, aDesc.mSize, writable);
+  }
+
+  return buffer.forget();
+}
+
+void Buffer::Drop() {
+  AbortMapRequest();
+
+  if (mMapped && !mMapped->mArrayBuffers.IsEmpty()) {
+    // The array buffers could live longer than us and our shmem, so make sure
+    // we clear the external buffer bindings.
+    dom::AutoJSAPI jsapi;
+    if (jsapi.Init(GetDevice().GetOwnerGlobal())) {
+      IgnoredErrorResult rv;
+      UnmapArrayBuffers(jsapi.cx(), rv);
+    }
+  }
+  mMapped.reset();
+
+  if (mValid && !GetDevice().IsLost()) {
+    GetDevice().GetBridge()->SendBufferDrop(mId);
+  }
+  mValid = false;
+}
+
+void Buffer::SetMapped(BufferAddress aOffset, BufferAddress aSize,
+                       bool aWritable) {
+  MOZ_ASSERT(!mMapped);
+  MOZ_RELEASE_ASSERT(aOffset <= mSize);
+  MOZ_RELEASE_ASSERT(aSize <= mSize - aOffset);
+
+  mMapped.emplace();
+  mMapped->mWritable = aWritable;
+  mMapped->mOffset = aOffset;
+  mMapped->mSize = aSize;
+}
+
+already_AddRefed<dom::Promise> Buffer::MapAsync(
+    uint32_t aMode, uint64_t aOffset, const dom::Optional<uint64_t>& aSize,
+    ErrorResult& aRv) {
+  RefPtr<dom::Promise> promise = dom::Promise::Create(GetParentObject(), aRv);
+  if (NS_WARN_IF(aRv.Failed())) {
+    return nullptr;
+  }
+
+  if (GetDevice().IsLost()) {
+    promise->MaybeRejectWithOperationError("Device Lost");
+    return promise.forget();
+  }
+
+  if (mMapRequest) {
+    promise->MaybeRejectWithOperationError("Buffer mapping is already pending");
+    return promise.forget();
+  }
+
+  BufferAddress size = 0;
+  if (aSize.WasPassed()) {
+    size = aSize.Value();
+  } else if (aOffset <= mSize) {
+    // Default to passing the reminder of the buffer after the provided offset.
+    size = mSize - aOffset;
+  } else {
+    // The provided offset is larger than the buffer size.
+    // The parent side will handle the error, we can let the requested size be
+    // zero.
+  }
+
+  RefPtr<Buffer> self(this);
+
+  auto mappingPromise =
+      GetDevice().GetBridge()->SendBufferMap(mId, aMode, aOffset, size);
+  MOZ_ASSERT(mappingPromise);
+
+  mMapRequest = promise;
+
+  mappingPromise->Then(
+      GetCurrentSerialEventTarget(), __func__,
+      [promise, self](BufferMapResult&& aResult) {
+        // Unmap might have been called while the result was on the way back.
+        if (promise->State() != dom::Promise::PromiseState::Pending) {
+          return;
+        }
+
+        switch (aResult.type()) {
+          case BufferMapResult::TBufferMapSuccess: {
+            auto& success = aResult.get_BufferMapSuccess();
+            self->mMapRequest = nullptr;
+            self->SetMapped(success.offset(), success.size(),
+                            success.writable());
+            promise->MaybeResolve(0);
+            break;
+          }
+          case BufferMapResult::TBufferMapError: {
+            auto& error = aResult.get_BufferMapError();
+            self->RejectMapRequest(promise, error.message());
+            break;
+          }
+          default: {
+            MOZ_CRASH("unreachable");
+          }
+        }
+      },
+      [promise](const ipc::ResponseRejectReason&) {
+        promise->MaybeRejectWithAbortError("Internal communication error!");
+      });
+
+  return promise.forget();
+}
+
+static void ExternalBufferFreeCallback(void* aContents, void* aUserData) {
+  Unused << aContents;
+  auto shm = static_cast<std::shared_ptr<ipc::WritableSharedMemoryMapping>*>(
+      aUserData);
+  delete shm;
+}
+
+void Buffer::GetMappedRange(JSContext* aCx, uint64_t aOffset,
+                            const dom::Optional<uint64_t>& aSize,
+                            JS::Rooted<JSObject*>* aObject, ErrorResult& aRv) {
+  if (!mMapped) {
+    aRv.ThrowInvalidStateError("Buffer is not mapped");
+    return;
+  }
+
+  const auto checkedOffset = CheckedInt<size_t>(aOffset);
+  const auto checkedSize = aSize.WasPassed()
+                               ? CheckedInt<size_t>(aSize.Value())
+                               : CheckedInt<size_t>(mSize) - aOffset;
+  const auto checkedMinBufferSize = checkedOffset + checkedSize;
+
+  if (!checkedOffset.isValid() || !checkedSize.isValid() ||
+      !checkedMinBufferSize.isValid() || aOffset < mMapped->mOffset ||
+      checkedMinBufferSize.value() > mMapped->mOffset + mMapped->mSize) {
+    aRv.ThrowRangeError("Invalid range");
+    return;
+  }
+
+  auto offset = checkedOffset.value();
+  auto size = checkedSize.value();
+  auto span = mShmem->Bytes().Subspan(offset, size);
+
+  std::shared_ptr<ipc::WritableSharedMemoryMapping>* userData =
+      new std::shared_ptr<ipc::WritableSharedMemoryMapping>(mShmem);
+  auto* const arrayBuffer = JS::NewExternalArrayBuffer(
+      aCx, size, span.data(), &ExternalBufferFreeCallback, userData);
+
+  if (!arrayBuffer) {
+    aRv.NoteJSContextException(aCx);
+    return;
+  }
+
+  aObject->set(arrayBuffer);
+  mMapped->mArrayBuffers.AppendElement(*aObject);
+}
+
+void Buffer::UnmapArrayBuffers(JSContext* aCx, ErrorResult& aRv) {
+  MOZ_ASSERT(mMapped);
+
+  bool detachedArrayBuffers = true;
+  for (const auto& arrayBuffer : mMapped->mArrayBuffers) {
+    JS::Rooted<JSObject*> rooted(aCx, arrayBuffer);
+    if (!JS::DetachArrayBuffer(aCx, rooted)) {
+      detachedArrayBuffers = false;
+    }
+  };
+
+  mMapped->mArrayBuffers.Clear();
+
+  AbortMapRequest();
+
+  if (NS_WARN_IF(!detachedArrayBuffers)) {
+    aRv.NoteJSContextException(aCx);
+    return;
+  }
+}
+
+void Buffer::RejectMapRequest(dom::Promise* aPromise, nsACString& message) {
+  if (mMapRequest == aPromise) {
+    mMapRequest = nullptr;
+  }
+
+  aPromise->MaybeRejectWithOperationError(message);
+}
+
+void Buffer::AbortMapRequest() {
+  if (mMapRequest) {
+    mMapRequest->MaybeRejectWithAbortError("Buffer unmapped");
+  }
+  mMapRequest = nullptr;
+}
+
+void Buffer::Unmap(JSContext* aCx, ErrorResult& aRv) {
+  if (!mMapped) {
+    return;
+  }
+
+  UnmapArrayBuffers(aCx, aRv);
+
+  bool hasMapFlags = mUsage & (dom::GPUBufferUsage_Binding::MAP_WRITE |
+                               dom::GPUBufferUsage_Binding::MAP_READ);
+
+  if (!hasMapFlags) {
+    // We get here if the buffer was mapped at creation without map flags.
+    // It won't be possible to map the buffer again so we can get rid of
+    // our shmem on this side.
+    mShmem = std::make_shared<ipc::WritableSharedMemoryMapping>();
+  }
+
+  if (!GetDevice().IsLost()) {
+    GetDevice().GetBridge()->SendBufferUnmap(GetDevice().mId, mId,
+                                             mMapped->mWritable);
+  }
+
+  mMapped.reset();
+}
+
+void Buffer::Destroy(JSContext* aCx, ErrorResult& aRv) {
+  if (mMapped) {
+    Unmap(aCx, aRv);
+  }
+
+  if (!GetDevice().IsLost()) {
+    GetDevice().GetBridge()->SendBufferDestroy(mId);
+  }
+  // TODO: we don't have to implement it right now, but it's used by the
+  // examples
+}
+
+}  // namespace mozilla::webgpu
diff --git a/dom/webgpu/Buffer.h b/dom/webgpu/Buffer.h
new file mode 100644
index 0000000000..3f77ab8381
--- /dev/null
+++ b/dom/webgpu/Buffer.h
@@ -0,0 +1,90 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef GPU_BUFFER_H_
+#define GPU_BUFFER_H_
+
+#include "js/RootingAPI.h"
+#include "mozilla/dom/Nullable.h"
+#include "mozilla/webgpu/WebGPUTypes.h"
+#include "nsTArray.h"
+#include "ObjectModel.h"
+#include "mozilla/ipc/RawShmem.h"
+#include <memory>
+
+namespace mozilla {
+class ErrorResult;
+
+namespace dom {
+struct GPUBufferDescriptor;
+template <typename T>
+class Optional;
+}  // namespace dom
+
+namespace webgpu {
+
+class Device;
+
+struct MappedInfo {
+  // True if mapping is requested for writing.
+  bool mWritable = false;
+  // Populated by `GetMappedRange`.
+  nsTArray<JS::Heap<JSObject*>> mArrayBuffers;
+  BufferAddress mOffset;
+  BufferAddress mSize;
+  MappedInfo() = default;
+  MappedInfo(const MappedInfo&) = delete;
+};
+
+class Buffer final : public ObjectBase, public ChildOf<Device> {
+ public:
+  NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_NATIVE_CLASS(Buffer)
+  NS_INLINE_DECL_CYCLE_COLLECTING_NATIVE_REFCOUNTING(Buffer)
+  GPU_DECL_JS_WRAP(Buffer)
+
+  static already_AddRefed<Buffer> Create(Device* aDevice, RawId aDeviceId,
+                                         const dom::GPUBufferDescriptor& aDesc,
+                                         ErrorResult& aRv);
+
+  already_AddRefed<dom::Promise> MapAsync(uint32_t aMode, uint64_t aOffset,
+                                          const dom::Optional<uint64_t>& aSize,
+                                          ErrorResult& aRv);
+  void GetMappedRange(JSContext* aCx, uint64_t aOffset,
+                      const dom::Optional<uint64_t>& aSize,
+                      JS::Rooted<JSObject*>* aObject, ErrorResult& aRv);
+  void Unmap(JSContext* aCx, ErrorResult& aRv);
+  void Destroy(JSContext* aCx, ErrorResult& aRv);
+
+  const RawId mId;
+
+ private:
+  Buffer(Device* const aParent, RawId aId, BufferAddress aSize, uint32_t aUsage,
+         ipc::WritableSharedMemoryMapping&& aShmem);
+  virtual ~Buffer();
+  Device& GetDevice() { return *mParent; }
+  void Drop();
+  void UnmapArrayBuffers(JSContext* aCx, ErrorResult& aRv);
+  void RejectMapRequest(dom::Promise* aPromise, nsACString& message);
+  void AbortMapRequest();
+  void SetMapped(BufferAddress aOffset, BufferAddress aSize, bool aWritable);
+
+  // Note: we can't map a buffer with the size that don't fit into `size_t`
+  // (which may be smaller than `BufferAddress`), but general not all buffers
+  // are mapped.
+  const BufferAddress mSize;
+  const uint32_t mUsage;
+  nsString mLabel;
+  // Information about the currently active mapping.
+  Maybe<MappedInfo> mMapped;
+  RefPtr<dom::Promise> mMapRequest;
+  // mShmem does not point to a shared memory segment if the buffer is not
+  // mappable.
+  std::shared_ptr<ipc::WritableSharedMemoryMapping> mShmem;
+};
+
+}  // namespace webgpu
+}  // namespace mozilla
+
+#endif  // GPU_BUFFER_H_
diff --git a/dom/webgpu/CanvasContext.cpp b/dom/webgpu/CanvasContext.cpp
new file mode 100644
index 0000000000..36b538f58f
--- /dev/null
+++ b/dom/webgpu/CanvasContext.cpp
@@ -0,0 +1,230 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/dom/WebGPUBinding.h"
+#include "CanvasContext.h"
+#include "gfxUtils.h"
+#include "LayerUserData.h"
+#include "nsDisplayList.h"
+#include "mozilla/dom/HTMLCanvasElement.h"
+#include "mozilla/gfx/CanvasManagerChild.h"
+#include "mozilla/layers/CanvasRenderer.h"
+#include "mozilla/layers/ImageDataSerializer.h"
+#include "mozilla/layers/LayersSurfaces.h"
+#include "mozilla/layers/RenderRootStateManager.h"
+#include "mozilla/layers/WebRenderCanvasRenderer.h"
+#include "ipc/WebGPUChild.h"
+
+namespace mozilla::webgpu {
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(CanvasContext)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(CanvasContext)
+
+GPU_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_WEAK_PTR(CanvasContext, mTexture,
+                                                mBridge, mCanvasElement,
+                                                mOffscreenCanvas)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(CanvasContext)
+  NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
+  NS_INTERFACE_MAP_ENTRY(nsICanvasRenderingContextInternal)
+  NS_INTERFACE_MAP_ENTRY(nsISupports)
+NS_INTERFACE_MAP_END
+
+CanvasContext::CanvasContext() = default;
+
+CanvasContext::~CanvasContext() {
+  Cleanup();
+  RemovePostRefreshObserver();
+}
+
+void CanvasContext::Cleanup() { Unconfigure(); }
+
+JSObject* CanvasContext::WrapObject(JSContext* aCx,
+                                    JS::Handle<JSObject*> aGivenProto) {
+  return dom::GPUCanvasContext_Binding::Wrap(aCx, this, aGivenProto);
+}
+
+void CanvasContext::Configure(const dom::GPUCanvasConfiguration& aDesc) {
+  Unconfigure();
+
+  // these formats are guaranteed by the spec
+  switch (aDesc.mFormat) {
+    case dom::GPUTextureFormat::Rgba8unorm:
+    case dom::GPUTextureFormat::Rgba8unorm_srgb:
+      mGfxFormat = gfx::SurfaceFormat::R8G8B8A8;
+      break;
+    case dom::GPUTextureFormat::Bgra8unorm:
+    case dom::GPUTextureFormat::Bgra8unorm_srgb:
+      mGfxFormat = gfx::SurfaceFormat::B8G8R8A8;
+      break;
+    default:
+      NS_WARNING("Specified swap chain format is not supported");
+      return;
+  }
+
+  gfx::IntSize actualSize(mWidth, mHeight);
+  mRemoteTextureOwnerId = Some(layers::RemoteTextureOwnerId::GetNext());
+  mTexture = aDesc.mDevice->InitSwapChain(aDesc, *mRemoteTextureOwnerId,
+                                          mGfxFormat, &actualSize);
+  if (!mTexture) {
+    Unconfigure();
+    return;
+  }
+
+  mTexture->mTargetContext = this;
+  mBridge = aDesc.mDevice->GetBridge();
+  mGfxSize = actualSize;
+
+  ForceNewFrame();
+}
+
+void CanvasContext::Unconfigure() {
+  if (mBridge && mBridge->IsOpen() && mRemoteTextureOwnerId.isSome()) {
+    mBridge->SendSwapChainDestroy(*mRemoteTextureOwnerId);
+  }
+  mRemoteTextureOwnerId = Nothing();
+  mBridge = nullptr;
+  mTexture = nullptr;
+  mGfxFormat = gfx::SurfaceFormat::UNKNOWN;
+}
+
+dom::GPUTextureFormat CanvasContext::GetPreferredFormat(Adapter&) const {
+  return dom::GPUTextureFormat::Bgra8unorm;
+}
+
+RefPtr<Texture> CanvasContext::GetCurrentTexture(ErrorResult& aRv) {
+  if (!mTexture) {
+    aRv.ThrowOperationError("Canvas not configured");
+    return nullptr;
+  }
+  return mTexture;
+}
+
+void CanvasContext::MaybeQueueSwapChainPresent() {
+  if (mPendingSwapChainPresent) {
+    return;
+  }
+
+  mPendingSwapChainPresent = true;
+  MOZ_ALWAYS_SUCCEEDS(NS_DispatchToCurrentThread(
+      NewCancelableRunnableMethod("CanvasContext::SwapChainPresent", this,
+                                  &CanvasContext::SwapChainPresent)));
+}
+
+void CanvasContext::SwapChainPresent() {
+  mPendingSwapChainPresent = false;
+  if (!mBridge || !mBridge->IsOpen() || mRemoteTextureOwnerId.isNothing() ||
+      !mTexture) {
+    return;
+  }
+  mLastRemoteTextureId = Some(layers::RemoteTextureId::GetNext());
+  mBridge->SwapChainPresent(mTexture->mId, *mLastRemoteTextureId,
+                            *mRemoteTextureOwnerId);
+}
+
+bool CanvasContext::UpdateWebRenderCanvasData(
+    mozilla::nsDisplayListBuilder* aBuilder, WebRenderCanvasData* aCanvasData) {
+  auto* renderer = aCanvasData->GetCanvasRenderer();
+
+  if (renderer && mRemoteTextureOwnerId.isSome() &&
+      renderer->GetRemoteTextureOwnerIdOfPushCallback() ==
+          mRemoteTextureOwnerId) {
+    return true;
+  }
+
+  renderer = aCanvasData->CreateCanvasRenderer();
+  if (!InitializeCanvasRenderer(aBuilder, renderer)) {
+    // Clear CanvasRenderer of WebRenderCanvasData
+    aCanvasData->ClearCanvasRenderer();
+    return false;
+  }
+  return true;
+}
+
+bool CanvasContext::InitializeCanvasRenderer(
+    nsDisplayListBuilder* aBuilder, layers::CanvasRenderer* aRenderer) {
+  if (mRemoteTextureOwnerId.isNothing()) {
+    return false;
+  }
+
+  layers::CanvasRendererData data;
+  data.mContext = this;
+  data.mSize = mGfxSize;
+  data.mIsOpaque = false;
+  data.mRemoteTextureOwnerIdOfPushCallback = mRemoteTextureOwnerId;
+
+  aRenderer->Initialize(data);
+  aRenderer->SetDirty();
+  return true;
+}
+
+mozilla::UniquePtr<uint8_t[]> CanvasContext::GetImageBuffer(int32_t* aFormat) {
+  gfxAlphaType any;
+  RefPtr<gfx::SourceSurface> snapshot = GetSurfaceSnapshot(&any);
+  if (!snapshot) {
+    *aFormat = 0;
+    return nullptr;
+  }
+
+  RefPtr<gfx::DataSourceSurface> dataSurface = snapshot->GetDataSurface();
+  return gfxUtils::GetImageBuffer(dataSurface, /* aIsAlphaPremultiplied */ true,
+                                  aFormat);
+}
+
+NS_IMETHODIMP CanvasContext::GetInputStream(const char* aMimeType,
+                                            const nsAString& aEncoderOptions,
+                                            nsIInputStream** aStream) {
+  gfxAlphaType any;
+  RefPtr<gfx::SourceSurface> snapshot = GetSurfaceSnapshot(&any);
+  if (!snapshot) {
+    return NS_ERROR_FAILURE;
+  }
+
+  RefPtr<gfx::DataSourceSurface> dataSurface = snapshot->GetDataSurface();
+  return gfxUtils::GetInputStream(dataSurface, /* aIsAlphaPremultiplied */ true,
+                                  aMimeType, aEncoderOptions, aStream);
+}
+
+already_AddRefed<mozilla::gfx::SourceSurface> CanvasContext::GetSurfaceSnapshot(
+    gfxAlphaType* aOutAlphaType) {
+  if (aOutAlphaType) {
+    *aOutAlphaType = gfxAlphaType::Premult;
+  }
+
+  auto* const cm = gfx::CanvasManagerChild::Get();
+  if (!cm) {
+    return nullptr;
+  }
+
+  if (!mBridge || !mBridge->IsOpen() || mRemoteTextureOwnerId.isNothing()) {
+    return nullptr;
+  }
+
+  MOZ_ASSERT(mRemoteTextureOwnerId.isSome());
+  return cm->GetSnapshot(cm->Id(), mBridge->Id(), mRemoteTextureOwnerId,
+                         mGfxFormat, /* aPremultiply */ false,
+                         /* aYFlip */ false);
+}
+
+void CanvasContext::ForceNewFrame() {
+  if (!mCanvasElement && !mOffscreenCanvas) {
+    return;
+  }
+
+  // Force a new frame to be built, which will execute the
+  // `CanvasContextType::WebGPU` switch case in `CreateWebRenderCommands` and
+  // populate the WR user data.
+  if (mCanvasElement) {
+    mCanvasElement->InvalidateCanvas();
+  } else if (mOffscreenCanvas) {
+    dom::OffscreenCanvasDisplayData data;
+    data.mSize = {mWidth, mHeight};
+    data.mIsOpaque = false;
+    data.mOwnerId = mRemoteTextureOwnerId;
+    mOffscreenCanvas->UpdateDisplayData(data);
+  }
+}
+
+}  // namespace mozilla::webgpu
diff --git a/dom/webgpu/CanvasContext.h b/dom/webgpu/CanvasContext.h
new file mode 100644
index 0000000000..60743ec47b
--- /dev/null
+++ b/dom/webgpu/CanvasContext.h
@@ -0,0 +1,109 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef GPU_CanvasContext_H_
+#define GPU_CanvasContext_H_
+
+#include "nsICanvasRenderingContextInternal.h"
+#include "nsWrapperCache.h"
+#include "ObjectModel.h"
+#include "mozilla/layers/LayersTypes.h"
+#include "mozilla/webrender/WebRenderAPI.h"
+
+namespace mozilla {
+namespace dom {
+class Promise;
+struct GPUCanvasConfiguration;
+enum class GPUTextureFormat : uint8_t;
+}  // namespace dom
+namespace webgpu {
+class Adapter;
+class Texture;
+
+class CanvasContext final : public nsICanvasRenderingContextInternal,
+                            public nsWrapperCache {
+ private:
+  virtual ~CanvasContext();
+  void Cleanup();
+
+ public:
+  // nsISupports interface + CC
+  NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+  NS_DECL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(CanvasContext)
+
+  CanvasContext();
+
+  JSObject* WrapObject(JSContext* aCx,
+                       JS::Handle<JSObject*> aGivenProto) override;
+
+ public:  // nsICanvasRenderingContextInternal
+  int32_t GetWidth() override { return mWidth; }
+  int32_t GetHeight() override { return mHeight; }
+
+  NS_IMETHOD SetDimensions(int32_t aWidth, int32_t aHeight) override {
+    mWidth = aWidth;
+    mHeight = aHeight;
+    return NS_OK;
+  }
+  NS_IMETHOD InitializeWithDrawTarget(
+      nsIDocShell* aShell, NotNull<gfx::DrawTarget*> aTarget) override {
+    return NS_OK;
+  }
+
+  bool UpdateWebRenderCanvasData(mozilla::nsDisplayListBuilder* aBuilder,
+                                 WebRenderCanvasData* aCanvasData) override;
+
+  bool InitializeCanvasRenderer(nsDisplayListBuilder* aBuilder,
+                                layers::CanvasRenderer* aRenderer) override;
+  mozilla::UniquePtr<uint8_t[]> GetImageBuffer(int32_t* aFormat) override;
+  NS_IMETHOD GetInputStream(const char* aMimeType,
+                            const nsAString& aEncoderOptions,
+                            nsIInputStream** aStream) override;
+  already_AddRefed<mozilla::gfx::SourceSurface> GetSurfaceSnapshot(
+      gfxAlphaType* aOutAlphaType) override;
+
+  void SetOpaqueValueFromOpaqueAttr(bool aOpaqueAttrValue) override {}
+  bool GetIsOpaque() override { return true; }
+
+  void ResetBitmap() override { Unconfigure(); }
+
+  void MarkContextClean() override {}
+
+  NS_IMETHOD Redraw(const gfxRect& aDirty) override { return NS_OK; }
+
+  void DidRefresh() override {}
+
+  void MarkContextCleanForFrameCapture() override {}
+  Watchable<FrameCaptureState>* GetFrameCaptureState() override {
+    return nullptr;
+  }
+
+ public:
+  void Configure(const dom::GPUCanvasConfiguration& aDesc);
+  void Unconfigure();
+
+  dom::GPUTextureFormat GetPreferredFormat(Adapter& aAdapter) const;
+  RefPtr<Texture> GetCurrentTexture(ErrorResult& aRv);
+  void MaybeQueueSwapChainPresent();
+  void SwapChainPresent();
+  void ForceNewFrame();
+
+ private:
+  uint32_t mWidth = 0, mHeight = 0;
+  bool mPendingSwapChainPresent = false;
+
+  RefPtr<WebGPUChild> mBridge;
+  RefPtr<Texture> mTexture;
+  gfx::SurfaceFormat mGfxFormat = gfx::SurfaceFormat::R8G8B8A8;
+  gfx::IntSize mGfxSize;
+
+  Maybe<layers::RemoteTextureId> mLastRemoteTextureId;
+  Maybe<layers::RemoteTextureOwnerId> mRemoteTextureOwnerId;
+};
+
+}  // namespace webgpu
+}  // namespace mozilla
+
+#endif  // GPU_CanvasContext_H_
diff --git a/dom/webgpu/CommandBuffer.cpp b/dom/webgpu/CommandBuffer.cpp
new file mode 100644
index 0000000000..2ba8fd0420
--- /dev/null
+++ b/dom/webgpu/CommandBuffer.cpp
@@ -0,0 +1,51 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/dom/WebGPUBinding.h"
+#include "CommandBuffer.h"
+#include "ipc/WebGPUChild.h"
+
+#include "mozilla/webgpu/CanvasContext.h"
+#include "Device.h"
+
+namespace mozilla::webgpu {
+
+GPU_IMPL_CYCLE_COLLECTION(CommandBuffer, mParent)
+GPU_IMPL_JS_WRAP(CommandBuffer)
+
+CommandBuffer::CommandBuffer(Device* const aParent, RawId aId,
+                             nsTArray<WeakPtr<CanvasContext>>&& aTargetContexts)
+    : ChildOf(aParent), mId(aId), mTargetContexts(std::move(aTargetContexts)) {
+  if (!aId) {
+    mValid = false;
+  }
+}
+
+CommandBuffer::~CommandBuffer() { Cleanup(); }
+
+void CommandBuffer::Cleanup() {
+  if (mValid && mParent) {
+    mValid = false;
+    auto bridge = mParent->GetBridge();
+    if (bridge && bridge->IsOpen()) {
+      bridge->SendCommandBufferDestroy(mId);
+    }
+  }
+}
+
+Maybe<RawId> CommandBuffer::Commit() {
+  if (!mValid) {
+    return Nothing();
+  }
+  mValid = false;
+  for (const auto& targetContext : mTargetContexts) {
+    if (targetContext) {
+      targetContext->MaybeQueueSwapChainPresent();
+    }
+  }
+  return Some(mId);
+}
+
+}  // namespace mozilla::webgpu
diff --git a/dom/webgpu/CommandBuffer.h b/dom/webgpu/CommandBuffer.h
new file mode 100644
index 0000000000..be525d98f3
--- /dev/null
+++ b/dom/webgpu/CommandBuffer.h
@@ -0,0 +1,40 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef GPU_CommandBuffer_H_
+#define GPU_CommandBuffer_H_
+
+#include "mozilla/WeakPtr.h"
+#include "mozilla/webgpu/WebGPUTypes.h"
+#include "nsWrapperCache.h"
+#include "ObjectModel.h"
+
+namespace mozilla::webgpu {
+
+class CanvasContext;
+class Device;
+
+class CommandBuffer final : public ObjectBase, public ChildOf<Device> {
+ public:
+  GPU_DECL_CYCLE_COLLECTION(CommandBuffer)
+  GPU_DECL_JS_WRAP(CommandBuffer)
+
+  CommandBuffer(Device* const aParent, RawId aId,
+                nsTArray<WeakPtr<CanvasContext>>&& aTargetContexts);
+
+  Maybe<RawId> Commit();
+
+ private:
+  CommandBuffer() = delete;
+  ~CommandBuffer();
+  void Cleanup();
+
+  const RawId mId;
+  const nsTArray<WeakPtr<CanvasContext>> mTargetContexts;
+};
+
+}  // namespace mozilla::webgpu
+
+#endif  // GPU_CommandBuffer_H_
diff --git a/dom/webgpu/CommandEncoder.cpp b/dom/webgpu/CommandEncoder.cpp
new file mode 100644
index 0000000000..fb6d3c07b6
--- /dev/null
+++ b/dom/webgpu/CommandEncoder.cpp
@@ -0,0 +1,252 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/dom/WebGPUBinding.h"
+#include "CommandEncoder.h"
+
+#include "CommandBuffer.h"
+#include "Buffer.h"
+#include "ComputePassEncoder.h"
+#include "Device.h"
+#include "RenderPassEncoder.h"
+#include "mozilla/webgpu/CanvasContext.h"
+#include "mozilla/webgpu/ffi/wgpu.h"
+#include "ipc/WebGPUChild.h"
+
+namespace mozilla::webgpu {
+
+GPU_IMPL_CYCLE_COLLECTION(CommandEncoder, mParent, mBridge)
+GPU_IMPL_JS_WRAP(CommandEncoder)
+
+void CommandEncoder::ConvertTextureDataLayoutToFFI(
+    const dom::GPUImageDataLayout& aLayout,
+    ffi::WGPUImageDataLayout* aLayoutFFI) {
+  *aLayoutFFI = {};
+  aLayoutFFI->offset = aLayout.mOffset;
+  aLayoutFFI->bytes_per_row = aLayout.mBytesPerRow;
+  aLayoutFFI->rows_per_image = aLayout.mRowsPerImage;
+}
+
+void CommandEncoder::ConvertTextureCopyViewToFFI(
+    const dom::GPUImageCopyTexture& aCopy,
+    ffi::WGPUImageCopyTexture* aViewFFI) {
+  *aViewFFI = {};
+  aViewFFI->texture = aCopy.mTexture->mId;
+  aViewFFI->mip_level = aCopy.mMipLevel;
+  if (aCopy.mOrigin.WasPassed()) {
+    const auto& origin = aCopy.mOrigin.Value();
+    if (origin.IsRangeEnforcedUnsignedLongSequence()) {
+      const auto& seq = origin.GetAsRangeEnforcedUnsignedLongSequence();
+      aViewFFI->origin.x = seq.Length() > 0 ? seq[0] : 0;
+      aViewFFI->origin.y = seq.Length() > 1 ? seq[1] : 0;
+      aViewFFI->origin.z = seq.Length() > 2 ? seq[2] : 0;
+    } else if (origin.IsGPUOrigin3DDict()) {
+      const auto& dict = origin.GetAsGPUOrigin3DDict();
+      aViewFFI->origin.x = dict.mX;
+      aViewFFI->origin.y = dict.mY;
+      aViewFFI->origin.z = dict.mZ;
+    } else {
+      MOZ_CRASH("Unexpected origin type");
+    }
+  }
+}
+
+void CommandEncoder::ConvertExtent3DToFFI(const dom::GPUExtent3D& aExtent,
+                                          ffi::WGPUExtent3d* aExtentFFI) {
+  *aExtentFFI = {};
+  if (aExtent.IsRangeEnforcedUnsignedLongSequence()) {
+    const auto& seq = aExtent.GetAsRangeEnforcedUnsignedLongSequence();
+    aExtentFFI->width = seq.Length() > 0 ? seq[0] : 0;
+    aExtentFFI->height = seq.Length() > 1 ? seq[1] : 0;
+    aExtentFFI->depth_or_array_layers = seq.Length() > 2 ? seq[2] : 0;
+  } else if (aExtent.IsGPUExtent3DDict()) {
+    const auto& dict = aExtent.GetAsGPUExtent3DDict();
+    aExtentFFI->width = dict.mWidth;
+    aExtentFFI->height = dict.mHeight;
+    aExtentFFI->depth_or_array_layers = dict.mDepthOrArrayLayers;
+  } else {
+    MOZ_CRASH("Unexptected extent type");
+  }
+}
+
+static ffi::WGPUImageCopyBuffer ConvertBufferCopyView(
+    const dom::GPUImageCopyBuffer& aCopy) {
+  ffi::WGPUImageCopyBuffer view = {};
+  view.buffer = aCopy.mBuffer->mId;
+  CommandEncoder::ConvertTextureDataLayoutToFFI(aCopy, &view.layout);
+  return view;
+}
+
+static ffi::WGPUImageCopyTexture ConvertTextureCopyView(
+    const dom::GPUImageCopyTexture& aCopy) {
+  ffi::WGPUImageCopyTexture view = {};
+  CommandEncoder::ConvertTextureCopyViewToFFI(aCopy, &view);
+  return view;
+}
+
+static ffi::WGPUExtent3d ConvertExtent(const dom::GPUExtent3D& aExtent) {
+  ffi::WGPUExtent3d extent = {};
+  CommandEncoder::ConvertExtent3DToFFI(aExtent, &extent);
+  return extent;
+}
+
+CommandEncoder::CommandEncoder(Device* const aParent,
+                               WebGPUChild* const aBridge, RawId aId)
+    : ChildOf(aParent), mId(aId), mBridge(aBridge) {}
+
+CommandEncoder::~CommandEncoder() { Cleanup(); }
+
+void CommandEncoder::Cleanup() {
+  if (mValid) {
+    mValid = false;
+    if (mBridge->IsOpen()) {
+      mBridge->SendCommandEncoderDestroy(mId);
+    }
+  }
+}
+
+void CommandEncoder::CopyBufferToBuffer(const Buffer& aSource,
+                                        BufferAddress aSourceOffset,
+                                        const Buffer& aDestination,
+                                        BufferAddress aDestinationOffset,
+                                        BufferAddress aSize) {
+  if (mValid && mBridge->IsOpen()) {
+    ipc::ByteBuf bb;
+    ffi::wgpu_command_encoder_copy_buffer_to_buffer(
+        aSource.mId, aSourceOffset, aDestination.mId, aDestinationOffset, aSize,
+        ToFFI(&bb));
+    mBridge->SendCommandEncoderAction(mId, mParent->mId, std::move(bb));
+  }
+}
+
+void CommandEncoder::CopyBufferToTexture(
+    const dom::GPUImageCopyBuffer& aSource,
+    const dom::GPUImageCopyTexture& aDestination,
+    const dom::GPUExtent3D& aCopySize) {
+  if (mValid && mBridge->IsOpen()) {
+    ipc::ByteBuf bb;
+    ffi::wgpu_command_encoder_copy_buffer_to_texture(
+        ConvertBufferCopyView(aSource), ConvertTextureCopyView(aDestination),
+        ConvertExtent(aCopySize), ToFFI(&bb));
+    mBridge->SendCommandEncoderAction(mId, mParent->mId, std::move(bb));
+
+    const auto& targetContext = aDestination.mTexture->mTargetContext;
+    if (targetContext) {
+      mTargetContexts.AppendElement(targetContext);
+    }
+  }
+}
+void CommandEncoder::CopyTextureToBuffer(
+    const dom::GPUImageCopyTexture& aSource,
+    const dom::GPUImageCopyBuffer& aDestination,
+    const dom::GPUExtent3D& aCopySize) {
+  if (mValid && mBridge->IsOpen()) {
+    ipc::ByteBuf bb;
+    ffi::wgpu_command_encoder_copy_texture_to_buffer(
+        ConvertTextureCopyView(aSource), ConvertBufferCopyView(aDestination),
+        ConvertExtent(aCopySize), ToFFI(&bb));
+    mBridge->SendCommandEncoderAction(mId, mParent->mId, std::move(bb));
+  }
+}
+void CommandEncoder::CopyTextureToTexture(
+    const dom::GPUImageCopyTexture& aSource,
+    const dom::GPUImageCopyTexture& aDestination,
+    const dom::GPUExtent3D& aCopySize) {
+  if (mValid && mBridge->IsOpen()) {
+    ipc::ByteBuf bb;
+    ffi::wgpu_command_encoder_copy_texture_to_texture(
+        ConvertTextureCopyView(aSource), ConvertTextureCopyView(aDestination),
+        ConvertExtent(aCopySize), ToFFI(&bb));
+    mBridge->SendCommandEncoderAction(mId, mParent->mId, std::move(bb));
+
+    const auto& targetContext = aDestination.mTexture->mTargetContext;
+    if (targetContext) {
+      mTargetContexts.AppendElement(targetContext);
+    }
+  }
+}
+
+void CommandEncoder::PushDebugGroup(const nsAString& aString) {
+  if (mValid && mBridge->IsOpen()) {
+    ipc::ByteBuf bb;
+    NS_ConvertUTF16toUTF8 marker(aString);
+    ffi::wgpu_command_encoder_push_debug_group(&marker, ToFFI(&bb));
+    mBridge->SendCommandEncoderAction(mId, mParent->mId, std::move(bb));
+  }
+}
+void CommandEncoder::PopDebugGroup() {
+  if (mValid && mBridge->IsOpen()) {
+    ipc::ByteBuf bb;
+    ffi::wgpu_command_encoder_pop_debug_group(ToFFI(&bb));
+    mBridge->SendCommandEncoderAction(mId, mParent->mId, std::move(bb));
+  }
+}
+void CommandEncoder::InsertDebugMarker(const nsAString& aString) {
+  if (mValid && mBridge->IsOpen()) {
+    ipc::ByteBuf bb;
+    NS_ConvertUTF16toUTF8 marker(aString);
+    ffi::wgpu_command_encoder_insert_debug_marker(&marker, ToFFI(&bb));
+    mBridge->SendCommandEncoderAction(mId, mParent->mId, std::move(bb));
+  }
+}
+
+already_AddRefed<ComputePassEncoder> CommandEncoder::BeginComputePass(
+    const dom::GPUComputePassDescriptor& aDesc) {
+  RefPtr<ComputePassEncoder> pass = new ComputePassEncoder(this, aDesc);
+  return pass.forget();
+}
+
+already_AddRefed<RenderPassEncoder> CommandEncoder::BeginRenderPass(
+    const dom::GPURenderPassDescriptor& aDesc) {
+  for (const auto& at : aDesc.mColorAttachments) {
+    auto* targetContext = at.mView->GetTargetContext();
+    if (targetContext) {
+      mTargetContexts.AppendElement(targetContext);
+    }
+    if (at.mResolveTarget.WasPassed()) {
+      targetContext = at.mResolveTarget.Value().GetTargetContext();
+      mTargetContexts.AppendElement(targetContext);
+    }
+  }
+
+  RefPtr<RenderPassEncoder> pass = new RenderPassEncoder(this, aDesc);
+  return pass.forget();
+}
+
+void CommandEncoder::EndComputePass(ffi::WGPUComputePass& aPass,
+                                    ErrorResult& aRv) {
+  if (!mValid || !mBridge->IsOpen()) {
+    return aRv.ThrowInvalidStateError("Command encoder is not valid");
+  }
+
+  ipc::ByteBuf byteBuf;
+  ffi::wgpu_compute_pass_finish(&aPass, ToFFI(&byteBuf));
+  mBridge->SendCommandEncoderAction(mId, mParent->mId, std::move(byteBuf));
+}
+
+void CommandEncoder::EndRenderPass(ffi::WGPURenderPass& aPass,
+                                   ErrorResult& aRv) {
+  if (!mValid || !mBridge->IsOpen()) {
+    return aRv.ThrowInvalidStateError("Command encoder is not valid");
+  }
+
+  ipc::ByteBuf byteBuf;
+  ffi::wgpu_render_pass_finish(&aPass, ToFFI(&byteBuf));
+  mBridge->SendCommandEncoderAction(mId, mParent->mId, std::move(byteBuf));
+}
+
+already_AddRefed<CommandBuffer> CommandEncoder::Finish(
+    const dom::GPUCommandBufferDescriptor& aDesc) {
+  RawId id = 0;
+  if (mValid && mBridge->IsOpen()) {
+    mValid = false;
+    id = mBridge->CommandEncoderFinish(mId, mParent->mId, aDesc);
+  }
+  RefPtr<CommandBuffer> comb =
+      new CommandBuffer(mParent, id, std::move(mTargetContexts));
+  return comb.forget();
+}
+
+}  // namespace mozilla::webgpu
diff --git a/dom/webgpu/CommandEncoder.h b/dom/webgpu/CommandEncoder.h
new file mode 100644
index 0000000000..5de069984e
--- /dev/null
+++ b/dom/webgpu/CommandEncoder.h
@@ -0,0 +1,109 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef GPU_CommandEncoder_H_
+#define GPU_CommandEncoder_H_
+
+#include "mozilla/dom/TypedArray.h"
+#include "mozilla/WeakPtr.h"
+#include "mozilla/webgpu/WebGPUTypes.h"
+#include "nsWrapperCache.h"
+#include "ObjectModel.h"
+
+namespace mozilla {
+class ErrorResult;
+
+namespace dom {
+struct GPUComputePassDescriptor;
+template <typename T>
+class Sequence;
+struct GPUCommandBufferDescriptor;
+class GPUComputePipelineOrGPURenderPipeline;
+class RangeEnforcedUnsignedLongSequenceOrGPUExtent3DDict;
+struct GPUImageCopyBuffer;
+struct GPUImageCopyTexture;
+struct GPUImageBitmapCopyView;
+struct GPUImageDataLayout;
+struct GPURenderPassDescriptor;
+using GPUExtent3D = RangeEnforcedUnsignedLongSequenceOrGPUExtent3DDict;
+}  // namespace dom
+namespace webgpu {
+namespace ffi {
+struct WGPUComputePass;
+struct WGPURenderPass;
+struct WGPUImageDataLayout;
+struct WGPUImageCopyTexture_TextureId;
+struct WGPUExtent3d;
+}  // namespace ffi
+
+class BindGroup;
+class Buffer;
+class CanvasContext;
+class CommandBuffer;
+class ComputePassEncoder;
+class Device;
+class RenderPassEncoder;
+
+class CommandEncoder final : public ObjectBase, public ChildOf<Device> {
+ public:
+  GPU_DECL_CYCLE_COLLECTION(CommandEncoder)
+  GPU_DECL_JS_WRAP(CommandEncoder)
+
+  CommandEncoder(Device* const aParent, WebGPUChild* const aBridge, RawId aId);
+
+  const RawId mId;
+
+  static void ConvertTextureDataLayoutToFFI(
+      const dom::GPUImageDataLayout& aLayout,
+      ffi::WGPUImageDataLayout* aLayoutFFI);
+  static void ConvertTextureCopyViewToFFI(
+      const dom::GPUImageCopyTexture& aCopy,
+      ffi::WGPUImageCopyTexture_TextureId* aViewFFI);
+  static void ConvertExtent3DToFFI(const dom::GPUExtent3D& aExtent,
+                                   ffi::WGPUExtent3d* aExtentFFI);
+
+ private:
+  ~CommandEncoder();
+  void Cleanup();
+
+  RefPtr<WebGPUChild> mBridge;
+  nsTArray<WeakPtr<CanvasContext>> mTargetContexts;
+
+ public:
+  const auto& GetDevice() const { return mParent; };
+
+  void EndComputePass(ffi::WGPUComputePass& aPass, ErrorResult& aRv);
+  void EndRenderPass(ffi::WGPURenderPass& aPass, ErrorResult& aRv);
+
+  void CopyBufferToBuffer(const Buffer& aSource, BufferAddress aSourceOffset,
+                          const Buffer& aDestination,
+                          BufferAddress aDestinationOffset,
+                          BufferAddress aSize);
+  void CopyBufferToTexture(const dom::GPUImageCopyBuffer& aSource,
+                           const dom::GPUImageCopyTexture& aDestination,
+                           const dom::GPUExtent3D& aCopySize);
+  void CopyTextureToBuffer(const dom::GPUImageCopyTexture& aSource,
+                           const dom::GPUImageCopyBuffer& aDestination,
+                           const dom::GPUExtent3D& aCopySize);
+  void CopyTextureToTexture(const dom::GPUImageCopyTexture& aSource,
+                            const dom::GPUImageCopyTexture& aDestination,
+                            const dom::GPUExtent3D& aCopySize);
+
+  void PushDebugGroup(const nsAString& aString);
+  void PopDebugGroup();
+  void InsertDebugMarker(const nsAString& aString);
+
+  already_AddRefed<ComputePassEncoder> BeginComputePass(
+      const dom::GPUComputePassDescriptor& aDesc);
+  already_AddRefed<RenderPassEncoder> BeginRenderPass(
+      const dom::GPURenderPassDescriptor& aDesc);
+  already_AddRefed<CommandBuffer> Finish(
+      const dom::GPUCommandBufferDescriptor& aDesc);
+};
+
+}  // namespace webgpu
+}  // namespace mozilla
+
+#endif  // GPU_CommandEncoder_H_
diff --git a/dom/webgpu/CompilationInfo.cpp b/dom/webgpu/CompilationInfo.cpp
new file mode 100644
index 0000000000..6f8ebf5490
--- /dev/null
+++ b/dom/webgpu/CompilationInfo.cpp
@@ -0,0 +1,34 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "CompilationInfo.h"
+#include "CompilationMessage.h"
+#include "ShaderModule.h"
+#include "mozilla/dom/WebGPUBinding.h"
+
+namespace mozilla::webgpu {
+
+GPU_IMPL_CYCLE_COLLECTION(CompilationInfo, mParent)
+GPU_IMPL_JS_WRAP(CompilationInfo)
+
+CompilationInfo::CompilationInfo(ShaderModule* const aParent)
+    : ChildOf(aParent) {}
+
+void CompilationInfo::SetMessages(
+    nsTArray<mozilla::webgpu::WebGPUCompilationMessage>& aMessages) {
+  for (auto& msg : aMessages) {
+    mMessages.AppendElement(MakeAndAddRef<mozilla::webgpu::CompilationMessage>(
+        this, msg.lineNum, msg.linePos, msg.offset, std::move(msg.message)));
+  }
+}
+
+void CompilationInfo::GetMessages(
+    nsTArray<RefPtr<mozilla::webgpu::CompilationMessage>>& aMessages) {
+  for (auto& msg : mMessages) {
+    aMessages.AppendElement(msg);
+  }
+}
+
+}  // namespace mozilla::webgpu
diff --git a/dom/webgpu/CompilationInfo.h b/dom/webgpu/CompilationInfo.h
new file mode 100644
index 0000000000..38d687cf25
--- /dev/null
+++ b/dom/webgpu/CompilationInfo.h
@@ -0,0 +1,39 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef GPU_CompilationInfo_H_
+#define GPU_CompilationInfo_H_
+
+#include "nsWrapperCache.h"
+#include "ObjectModel.h"
+#include "CompilationMessage.h"
+
+namespace mozilla::webgpu {
+class ShaderModule;
+
+class CompilationInfo final : public nsWrapperCache,
+                              public ChildOf<ShaderModule> {
+ public:
+  GPU_DECL_CYCLE_COLLECTION(CompilationInfo)
+  GPU_DECL_JS_WRAP(CompilationInfo)
+
+  explicit CompilationInfo(ShaderModule* const aParent);
+
+  void SetMessages(
+      nsTArray<mozilla::webgpu::WebGPUCompilationMessage>& aMessages);
+
+  void GetMessages(
+      nsTArray<RefPtr<mozilla::webgpu::CompilationMessage>>& aMessages);
+
+ private:
+  ~CompilationInfo() = default;
+  void Cleanup() {}
+
+  nsTArray<RefPtr<mozilla::webgpu::CompilationMessage>> mMessages;
+};
+
+}  // namespace mozilla::webgpu
+
+#endif  // GPU_CompilationInfo_H_
diff --git a/dom/webgpu/CompilationMessage.cpp b/dom/webgpu/CompilationMessage.cpp
new file mode 100644
index 0000000000..f0df8c1db1
--- /dev/null
+++ b/dom/webgpu/CompilationMessage.cpp
@@ -0,0 +1,24 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "CompilationMessage.h"
+#include "CompilationInfo.h"
+#include "mozilla/dom/WebGPUBinding.h"
+
+namespace mozilla::webgpu {
+
+GPU_IMPL_CYCLE_COLLECTION(CompilationMessage, mParent)
+GPU_IMPL_JS_WRAP(CompilationMessage)
+
+CompilationMessage::CompilationMessage(CompilationInfo* const aParent,
+                                       uint64_t aLineNum, uint64_t aLinePos,
+                                       uint64_t aOffset, nsString&& aMessage)
+    : ChildOf(aParent),
+      mLineNum(aLineNum),
+      mLinePos(aLinePos),
+      mOffset(aOffset),
+      mMessage(std::move(aMessage)) {}
+
+}  // namespace mozilla::webgpu
diff --git a/dom/webgpu/CompilationMessage.h b/dom/webgpu/CompilationMessage.h
new file mode 100644
index 0000000000..685a41f68e
--- /dev/null
+++ b/dom/webgpu/CompilationMessage.h
@@ -0,0 +1,54 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef GPU_CompilationMessage_H_
+#define GPU_CompilationMessage_H_
+
+#include "nsWrapperCache.h"
+#include "ObjectModel.h"
+#include "mozilla/dom/WebGPUBinding.h"
+
+namespace mozilla {
+namespace dom {
+class DOMString;
+}  // namespace dom
+namespace webgpu {
+class CompilationInfo;
+
+class CompilationMessage final : public nsWrapperCache,
+                                 public ChildOf<CompilationInfo> {
+  dom::GPUCompilationMessageType mType = dom::GPUCompilationMessageType::Error;
+  uint64_t mLineNum = 0;
+  uint64_t mLinePos = 0;
+  uint64_t mOffset = 0;
+  uint64_t mLength = 0;
+  nsString mMessage;
+
+ public:
+  GPU_DECL_CYCLE_COLLECTION(CompilationMessage)
+  GPU_DECL_JS_WRAP(CompilationMessage)
+
+  explicit CompilationMessage(CompilationInfo* const aParent, uint64_t aLineNum,
+                              uint64_t aLinePos, uint64_t aOffset,
+                              nsString&& aMessage);
+
+  void GetMessage(dom::DOMString& aMessage) {
+    aMessage.AsAString().Assign(mMessage);
+  }
+  dom::GPUCompilationMessageType Type() const { return mType; }
+  uint64_t LineNum() const { return mLineNum; }
+  uint64_t LinePos() const { return mLinePos; }
+  uint64_t Offset() const { return mOffset; }
+  uint64_t Length() const { return mLength; }
+
+ private:
+  ~CompilationMessage() = default;
+  void Cleanup() {}
+};
+
+}  // namespace webgpu
+}  // namespace mozilla
+
+#endif  // GPU_CompilationMessage_H_
diff --git a/dom/webgpu/ComputePassEncoder.cpp b/dom/webgpu/ComputePassEncoder.cpp
new file mode 100644
index 0000000000..8172874c22
--- /dev/null
+++ b/dom/webgpu/ComputePassEncoder.cpp
@@ -0,0 +1,108 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/dom/WebGPUBinding.h"
+#include "ComputePassEncoder.h"
+#include "BindGroup.h"
+#include "ComputePipeline.h"
+#include "CommandEncoder.h"
+
+#include "mozilla/webgpu/ffi/wgpu.h"
+
+namespace mozilla::webgpu {
+
+GPU_IMPL_CYCLE_COLLECTION(ComputePassEncoder, mParent, mUsedBindGroups,
+                          mUsedPipelines)
+GPU_IMPL_JS_WRAP(ComputePassEncoder)
+
+ffi::WGPUComputePass* ScopedFfiComputeTraits::empty() { return nullptr; }
+
+void ScopedFfiComputeTraits::release(ffi::WGPUComputePass* raw) {
+  if (raw) {
+    ffi::wgpu_compute_pass_destroy(raw);
+  }
+}
+
+ffi::WGPUComputePass* BeginComputePass(
+    RawId aEncoderId, const dom::GPUComputePassDescriptor& aDesc) {
+  ffi::WGPUComputePassDescriptor desc = {};
+
+  webgpu::StringHelper label(aDesc.mLabel);
+  desc.label = label.Get();
+
+  return ffi::wgpu_command_encoder_begin_compute_pass(aEncoderId, &desc);
+}
+
+ComputePassEncoder::ComputePassEncoder(
+    CommandEncoder* const aParent, const dom::GPUComputePassDescriptor& aDesc)
+    : ChildOf(aParent), mPass(BeginComputePass(aParent->mId, aDesc)) {}
+
+ComputePassEncoder::~ComputePassEncoder() {
+  if (mValid) {
+    mValid = false;
+  }
+}
+
+void ComputePassEncoder::SetBindGroup(
+    uint32_t aSlot, const BindGroup& aBindGroup,
+    const dom::Sequence<uint32_t>& aDynamicOffsets) {
+  if (mValid) {
+    mUsedBindGroups.AppendElement(&aBindGroup);
+    ffi::wgpu_compute_pass_set_bind_group(mPass, aSlot, aBindGroup.mId,
+                                          aDynamicOffsets.Elements(),
+                                          aDynamicOffsets.Length());
+  }
+}
+
+void ComputePassEncoder::SetPipeline(const ComputePipeline& aPipeline) {
+  if (mValid) {
+    mUsedPipelines.AppendElement(&aPipeline);
+    ffi::wgpu_compute_pass_set_pipeline(mPass, aPipeline.mId);
+  }
+}
+
+void ComputePassEncoder::DispatchWorkgroups(uint32_t x, uint32_t y,
+                                            uint32_t z) {
+  if (mValid) {
+    ffi::wgpu_compute_pass_dispatch_workgroups(mPass, x, y, z);
+  }
+}
+
+void ComputePassEncoder::DispatchWorkgroupsIndirect(
+    const Buffer& aIndirectBuffer, uint64_t aIndirectOffset) {
+  if (mValid) {
+    ffi::wgpu_compute_pass_dispatch_workgroups_indirect(
+        mPass, aIndirectBuffer.mId, aIndirectOffset);
+  }
+}
+
+void ComputePassEncoder::PushDebugGroup(const nsAString& aString) {
+  if (mValid) {
+    const NS_ConvertUTF16toUTF8 utf8(aString);
+    ffi::wgpu_compute_pass_push_debug_group(mPass, utf8.get(), 0);
+  }
+}
+void ComputePassEncoder::PopDebugGroup() {
+  if (mValid) {
+    ffi::wgpu_compute_pass_pop_debug_group(mPass);
+  }
+}
+void ComputePassEncoder::InsertDebugMarker(const nsAString& aString) {
+  if (mValid) {
+    const NS_ConvertUTF16toUTF8 utf8(aString);
+    ffi::wgpu_compute_pass_insert_debug_marker(mPass, utf8.get(), 0);
+  }
+}
+
+void ComputePassEncoder::EndPass(ErrorResult& aRv) {
+  if (mValid) {
+    mValid = false;
+    auto* pass = mPass.forget();
+    MOZ_ASSERT(pass);
+    mParent->EndComputePass(*pass, aRv);
+  }
+}
+
+}  // namespace mozilla::webgpu
diff --git a/dom/webgpu/ComputePassEncoder.h b/dom/webgpu/ComputePassEncoder.h
new file mode 100644
index 0000000000..6d00cceac6
--- /dev/null
+++ b/dom/webgpu/ComputePassEncoder.h
@@ -0,0 +1,75 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef GPU_ComputePassEncoder_H_
+#define GPU_ComputePassEncoder_H_
+
+#include "mozilla/Scoped.h"
+#include "mozilla/dom/TypedArray.h"
+#include "ObjectModel.h"
+
+namespace mozilla {
+class ErrorResult;
+
+namespace dom {
+struct GPUComputePassDescriptor;
+}
+
+namespace webgpu {
+namespace ffi {
+struct WGPUComputePass;
+}  // namespace ffi
+
+class BindGroup;
+class Buffer;
+class CommandEncoder;
+class ComputePipeline;
+
+struct ScopedFfiComputeTraits {
+  using type = ffi::WGPUComputePass*;
+  static type empty();
+  static void release(type raw);
+};
+
+class ComputePassEncoder final : public ObjectBase,
+                                 public ChildOf<CommandEncoder> {
+ public:
+  GPU_DECL_CYCLE_COLLECTION(ComputePassEncoder)
+  GPU_DECL_JS_WRAP(ComputePassEncoder)
+
+  ComputePassEncoder(CommandEncoder* const aParent,
+                     const dom::GPUComputePassDescriptor& aDesc);
+
+ private:
+  virtual ~ComputePassEncoder();
+  void Cleanup() {}
+
+  Scoped<ScopedFfiComputeTraits> mPass;
+  // keep all the used objects alive while the pass is recorded
+  nsTArray<RefPtr<const BindGroup>> mUsedBindGroups;
+  nsTArray<RefPtr<const ComputePipeline>> mUsedPipelines;
+
+ public:
+  // programmable pass encoder
+  void SetBindGroup(uint32_t aSlot, const BindGroup& aBindGroup,
+                    const dom::Sequence<uint32_t>& aDynamicOffsets);
+  // self
+  void SetPipeline(const ComputePipeline& aPipeline);
+
+  void DispatchWorkgroups(uint32_t x, uint32_t y, uint32_t z);
+  void DispatchWorkgroupsIndirect(const Buffer& aIndirectBuffer,
+                                  uint64_t aIndirectOffset);
+
+  void PushDebugGroup(const nsAString& aString);
+  void PopDebugGroup();
+  void InsertDebugMarker(const nsAString& aString);
+
+  void EndPass(ErrorResult& aRv);
+};
+
+}  // namespace webgpu
+}  // namespace mozilla
+
+#endif  // GPU_ComputePassEncoder_H_
diff --git a/dom/webgpu/ComputePipeline.cpp b/dom/webgpu/ComputePipeline.cpp
new file mode 100644
index 0000000000..53a8031871
--- /dev/null
+++ b/dom/webgpu/ComputePipeline.cpp
@@ -0,0 +1,50 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "ComputePipeline.h"
+
+#include "Device.h"
+#include "ipc/WebGPUChild.h"
+#include "mozilla/dom/WebGPUBinding.h"
+
+namespace mozilla::webgpu {
+
+GPU_IMPL_CYCLE_COLLECTION(ComputePipeline, mParent)
+GPU_IMPL_JS_WRAP(ComputePipeline)
+
+ComputePipeline::ComputePipeline(Device* const aParent, RawId aId,
+                                 RawId aImplicitPipelineLayoutId,
+                                 nsTArray<RawId>&& aImplicitBindGroupLayoutIds)
+    : ChildOf(aParent),
+      mImplicitPipelineLayoutId(aImplicitPipelineLayoutId),
+      mImplicitBindGroupLayoutIds(std::move(aImplicitBindGroupLayoutIds)),
+      mId(aId) {}
+
+ComputePipeline::~ComputePipeline() { Cleanup(); }
+
+void ComputePipeline::Cleanup() {
+  if (mValid && mParent) {
+    mValid = false;
+    auto bridge = mParent->GetBridge();
+    if (bridge && bridge->IsOpen()) {
+      bridge->SendComputePipelineDestroy(mId);
+      if (mImplicitPipelineLayoutId) {
+        bridge->SendImplicitLayoutDestroy(mImplicitPipelineLayoutId,
+                                          mImplicitBindGroupLayoutIds);
+      }
+    }
+  }
+}
+
+already_AddRefed<BindGroupLayout> ComputePipeline::GetBindGroupLayout(
+    uint32_t index) const {
+  const RawId id = index < mImplicitBindGroupLayoutIds.Length()
+                       ? mImplicitBindGroupLayoutIds[index]
+                       : 0;
+  RefPtr<BindGroupLayout> object = new BindGroupLayout(mParent, id, false);
+  return object.forget();
+}
+
+}  // namespace mozilla::webgpu
diff --git a/dom/webgpu/ComputePipeline.h b/dom/webgpu/ComputePipeline.h
new file mode 100644
index 0000000000..5dbd972912
--- /dev/null
+++ b/dom/webgpu/ComputePipeline.h
@@ -0,0 +1,41 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef GPU_ComputePipeline_H_
+#define GPU_ComputePipeline_H_
+
+#include "nsWrapperCache.h"
+#include "ObjectModel.h"
+#include "mozilla/webgpu/WebGPUTypes.h"
+#include "nsTArray.h"
+
+namespace mozilla::webgpu {
+
+class BindGroupLayout;
+class Device;
+
+class ComputePipeline final : public ObjectBase, public ChildOf<Device> {
+  const RawId mImplicitPipelineLayoutId;
+  const nsTArray<RawId> mImplicitBindGroupLayoutIds;
+
+ public:
+  GPU_DECL_CYCLE_COLLECTION(ComputePipeline)
+  GPU_DECL_JS_WRAP(ComputePipeline)
+
+  const RawId mId;
+
+  ComputePipeline(Device* const aParent, RawId aId,
+                  RawId aImplicitPipelineLayoutId,
+                  nsTArray<RawId>&& aImplicitBindGroupLayoutIds);
+  already_AddRefed<BindGroupLayout> GetBindGroupLayout(uint32_t index) const;
+
+ private:
+  ~ComputePipeline();
+  void Cleanup();
+};
+
+}  // namespace mozilla::webgpu
+
+#endif  // GPU_ComputePipeline_H_
diff --git a/dom/webgpu/Device.cpp b/dom/webgpu/Device.cpp
new file mode 100644
index 0000000000..3ae0f7097f
--- /dev/null
+++ b/dom/webgpu/Device.cpp
@@ -0,0 +1,385 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "js/ArrayBuffer.h"
+#include "js/Value.h"
+#include "mozilla/ErrorResult.h"
+#include "mozilla/Logging.h"
+#include "mozilla/dom/Promise.h"
+#include "mozilla/dom/WebGPUBinding.h"
+#include "Device.h"
+#include "CommandEncoder.h"
+#include "BindGroup.h"
+
+#include "Adapter.h"
+#include "Buffer.h"
+#include "ComputePipeline.h"
+#include "DeviceLostInfo.h"
+#include "Queue.h"
+#include "RenderBundleEncoder.h"
+#include "RenderPipeline.h"
+#include "Sampler.h"
+#include "SupportedFeatures.h"
+#include "SupportedLimits.h"
+#include "Texture.h"
+#include "TextureView.h"
+#include "ValidationError.h"
+#include "ipc/WebGPUChild.h"
+
+namespace mozilla::webgpu {
+
+mozilla::LazyLogModule gWebGPULog("WebGPU");
+
+GPU_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_INHERITED(Device, DOMEventTargetHelper,
+                                                 mBridge, mQueue, mFeatures,
+                                                 mLimits, mLostPromise);
+NS_IMPL_ISUPPORTS_CYCLE_COLLECTION_INHERITED_0(Device, DOMEventTargetHelper)
+GPU_IMPL_JS_WRAP(Device)
+
+RefPtr<WebGPUChild> Device::GetBridge() { return mBridge; }
+
+Device::Device(Adapter* const aParent, RawId aId,
+               UniquePtr<ffi::WGPULimits> aRawLimits)
+    : DOMEventTargetHelper(aParent->GetParentObject()),
+      mId(aId),
+      // features are filled in Adapter::RequestDevice
+      mFeatures(new SupportedFeatures(aParent)),
+      mLimits(new SupportedLimits(aParent, std::move(aRawLimits))),
+      mBridge(aParent->mBridge),
+      mQueue(new class Queue(this, aParent->mBridge, aId)) {
+  mBridge->RegisterDevice(this);
+}
+
+Device::~Device() { Cleanup(); }
+
+void Device::Cleanup() {
+  if (!mValid) {
+    return;
+  }
+
+  mValid = false;
+
+  if (mBridge) {
+    mBridge->UnregisterDevice(mId);
+  }
+
+  // Cycle collection may have disconnected the promise object.
+  if (mLostPromise && mLostPromise->PromiseObj() != nullptr) {
+    auto info = MakeRefPtr<DeviceLostInfo>(GetParentObject(),
+                                           dom::GPUDeviceLostReason::Destroyed,
+                                           u"Device destroyed"_ns);
+    mLostPromise->MaybeResolve(info);
+  }
+}
+
+void Device::CleanupUnregisteredInParent() {
+  if (mBridge) {
+    mBridge->FreeUnregisteredInParentDevice(mId);
+  }
+  mValid = false;
+}
+
+bool Device::IsLost() const { return !mBridge || !mBridge->CanSend(); }
+
+// Generate an error on the Device timeline for this device.
+//
+// aMessage is interpreted as UTF-8.
+void Device::GenerateError(const nsCString& aMessage) {
+  if (mBridge->CanSend()) {
+    mBridge->SendGenerateError(mId, aMessage);
+  }
+}
+
+void Device::GetLabel(nsAString& aValue) const { aValue = mLabel; }
+void Device::SetLabel(const nsAString& aLabel) { mLabel = aLabel; }
+
+dom::Promise* Device::GetLost(ErrorResult& aRv) {
+  if (!mLostPromise) {
+    mLostPromise = dom::Promise::Create(GetParentObject(), aRv);
+    if (mLostPromise && !mBridge->CanSend()) {
+      auto info = MakeRefPtr<DeviceLostInfo>(GetParentObject(),
+                                             u"WebGPUChild destroyed"_ns);
+      mLostPromise->MaybeResolve(info);
+    }
+  }
+  return mLostPromise;
+}
+
+already_AddRefed<Buffer> Device::CreateBuffer(
+    const dom::GPUBufferDescriptor& aDesc, ErrorResult& aRv) {
+  return Buffer::Create(this, mId, aDesc, aRv);
+}
+
+already_AddRefed<Texture> Device::CreateTexture(
+    const dom::GPUTextureDescriptor& aDesc) {
+  RawId id = 0;
+  if (mBridge->CanSend()) {
+    id = mBridge->DeviceCreateTexture(mId, aDesc);
+  }
+  RefPtr<Texture> texture = new Texture(this, id, aDesc);
+  return texture.forget();
+}
+
+already_AddRefed<Sampler> Device::CreateSampler(
+    const dom::GPUSamplerDescriptor& aDesc) {
+  RawId id = 0;
+  if (mBridge->CanSend()) {
+    id = mBridge->DeviceCreateSampler(mId, aDesc);
+  }
+  RefPtr<Sampler> sampler = new Sampler(this, id);
+  return sampler.forget();
+}
+
+already_AddRefed<CommandEncoder> Device::CreateCommandEncoder(
+    const dom::GPUCommandEncoderDescriptor& aDesc) {
+  RawId id = 0;
+  if (mBridge->CanSend()) {
+    id = mBridge->DeviceCreateCommandEncoder(mId, aDesc);
+  }
+  RefPtr<CommandEncoder> encoder = new CommandEncoder(this, mBridge, id);
+  return encoder.forget();
+}
+
+already_AddRefed<RenderBundleEncoder> Device::CreateRenderBundleEncoder(
+    const dom::GPURenderBundleEncoderDescriptor& aDesc) {
+  RefPtr<RenderBundleEncoder> encoder =
+      new RenderBundleEncoder(this, mBridge, aDesc);
+  return encoder.forget();
+}
+
+already_AddRefed<BindGroupLayout> Device::CreateBindGroupLayout(
+    const dom::GPUBindGroupLayoutDescriptor& aDesc) {
+  RawId id = 0;
+  if (mBridge->CanSend()) {
+    id = mBridge->DeviceCreateBindGroupLayout(mId, aDesc);
+  }
+  RefPtr<BindGroupLayout> object = new BindGroupLayout(this, id, true);
+  return object.forget();
+}
+already_AddRefed<PipelineLayout> Device::CreatePipelineLayout(
+    const dom::GPUPipelineLayoutDescriptor& aDesc) {
+  RawId id = 0;
+  if (mBridge->CanSend()) {
+    id = mBridge->DeviceCreatePipelineLayout(mId, aDesc);
+  }
+  RefPtr<PipelineLayout> object = new PipelineLayout(this, id);
+  return object.forget();
+}
+already_AddRefed<BindGroup> Device::CreateBindGroup(
+    const dom::GPUBindGroupDescriptor& aDesc) {
+  RawId id = 0;
+  if (mBridge->CanSend()) {
+    id = mBridge->DeviceCreateBindGroup(mId, aDesc);
+  }
+  RefPtr<BindGroup> object = new BindGroup(this, id);
+  return object.forget();
+}
+
+already_AddRefed<ShaderModule> Device::CreateShaderModule(
+    JSContext* aCx, const dom::GPUShaderModuleDescriptor& aDesc) {
+  Unused << aCx;
+
+  if (!mBridge->CanSend()) {
+    return nullptr;
+  }
+
+  ErrorResult err;
+  RefPtr<dom::Promise> promise = dom::Promise::Create(GetParentObject(), err);
+  if (NS_WARN_IF(err.Failed())) {
+    return nullptr;
+  }
+
+  return mBridge->DeviceCreateShaderModule(this, aDesc, promise);
+}
+
+already_AddRefed<ComputePipeline> Device::CreateComputePipeline(
+    const dom::GPUComputePipelineDescriptor& aDesc) {
+  PipelineCreationContext context = {mId};
+  RawId id = 0;
+  if (mBridge->CanSend()) {
+    id = mBridge->DeviceCreateComputePipeline(&context, aDesc);
+  }
+  RefPtr<ComputePipeline> object =
+      new ComputePipeline(this, id, context.mImplicitPipelineLayoutId,
+                          std::move(context.mImplicitBindGroupLayoutIds));
+  return object.forget();
+}
+
+already_AddRefed<RenderPipeline> Device::CreateRenderPipeline(
+    const dom::GPURenderPipelineDescriptor& aDesc) {
+  PipelineCreationContext context = {mId};
+  RawId id = 0;
+  if (mBridge->CanSend()) {
+    id = mBridge->DeviceCreateRenderPipeline(&context, aDesc);
+  }
+  RefPtr<RenderPipeline> object =
+      new RenderPipeline(this, id, context.mImplicitPipelineLayoutId,
+                         std::move(context.mImplicitBindGroupLayoutIds));
+  return object.forget();
+}
+
+already_AddRefed<dom::Promise> Device::CreateComputePipelineAsync(
+    const dom::GPUComputePipelineDescriptor& aDesc, ErrorResult& aRv) {
+  RefPtr<dom::Promise> promise = dom::Promise::Create(GetParentObject(), aRv);
+  if (NS_WARN_IF(aRv.Failed())) {
+    return nullptr;
+  }
+
+  if (!mBridge->CanSend()) {
+    promise->MaybeRejectWithOperationError("Internal communication error");
+    return promise.forget();
+  }
+
+  std::shared_ptr<PipelineCreationContext> context(
+      new PipelineCreationContext());
+  context->mParentId = mId;
+  mBridge->DeviceCreateComputePipelineAsync(context.get(), aDesc)
+      ->Then(
+          GetCurrentSerialEventTarget(), __func__,
+          [self = RefPtr{this}, context, promise](RawId aId) {
+            RefPtr<ComputePipeline> object = new ComputePipeline(
+                self, aId, context->mImplicitPipelineLayoutId,
+                std::move(context->mImplicitBindGroupLayoutIds));
+            promise->MaybeResolve(object);
+          },
+          [promise](const ipc::ResponseRejectReason&) {
+            promise->MaybeRejectWithOperationError(
+                "Internal communication error");
+          });
+
+  return promise.forget();
+}
+
+already_AddRefed<dom::Promise> Device::CreateRenderPipelineAsync(
+    const dom::GPURenderPipelineDescriptor& aDesc, ErrorResult& aRv) {
+  RefPtr<dom::Promise> promise = dom::Promise::Create(GetParentObject(), aRv);
+  if (NS_WARN_IF(aRv.Failed())) {
+    return nullptr;
+  }
+
+  if (!mBridge->CanSend()) {
+    promise->MaybeRejectWithOperationError("Internal communication error");
+    return promise.forget();
+  }
+
+  std::shared_ptr<PipelineCreationContext> context(
+      new PipelineCreationContext());
+  context->mParentId = mId;
+  mBridge->DeviceCreateRenderPipelineAsync(context.get(), aDesc)
+      ->Then(
+          GetCurrentSerialEventTarget(), __func__,
+          [self = RefPtr{this}, context, promise](RawId aId) {
+            RefPtr<RenderPipeline> object = new RenderPipeline(
+                self, aId, context->mImplicitPipelineLayoutId,
+                std::move(context->mImplicitBindGroupLayoutIds));
+            promise->MaybeResolve(object);
+          },
+          [promise](const ipc::ResponseRejectReason&) {
+            promise->MaybeRejectWithOperationError(
+                "Internal communication error");
+          });
+
+  return promise.forget();
+}
+
+already_AddRefed<Texture> Device::InitSwapChain(
+    const dom::GPUCanvasConfiguration& aDesc,
+    const layers::RemoteTextureOwnerId aOwnerId, gfx::SurfaceFormat aFormat,
+    gfx::IntSize* aCanvasSize) {
+  if (!mBridge->CanSend()) {
+    return nullptr;
+  }
+
+  gfx::IntSize size = *aCanvasSize;
+  if (aDesc.mSize.WasPassed()) {
+    const auto& descSize = aDesc.mSize.Value();
+    if (descSize.IsRangeEnforcedUnsignedLongSequence()) {
+      const auto& seq = descSize.GetAsRangeEnforcedUnsignedLongSequence();
+      // TODO: add a check for `seq.Length()`
+      size.width = AssertedCast<int>(seq[0]);
+      size.height = AssertedCast<int>(seq[1]);
+    } else if (descSize.IsGPUExtent3DDict()) {
+      const auto& dict = descSize.GetAsGPUExtent3DDict();
+      size.width = AssertedCast<int>(dict.mWidth);
+      size.height = AssertedCast<int>(dict.mHeight);
+    } else {
+      MOZ_CRASH("Unexpected union");
+    }
+    *aCanvasSize = size;
+  }
+
+  const layers::RGBDescriptor rgbDesc(size, aFormat);
+  // buffer count doesn't matter much, will be created on demand
+  const size_t maxBufferCount = 10;
+  mBridge->DeviceCreateSwapChain(mId, rgbDesc, maxBufferCount, aOwnerId);
+
+  dom::GPUTextureDescriptor desc;
+  desc.mDimension = dom::GPUTextureDimension::_2d;
+  auto& sizeDict = desc.mSize.SetAsGPUExtent3DDict();
+  sizeDict.mWidth = size.width;
+  sizeDict.mHeight = size.height;
+  sizeDict.mDepthOrArrayLayers = 1;
+  desc.mFormat = aDesc.mFormat;
+  desc.mMipLevelCount = 1;
+  desc.mSampleCount = 1;
+  desc.mUsage = aDesc.mUsage | dom::GPUTextureUsage_Binding::COPY_SRC;
+  return CreateTexture(desc);
+}
+
+bool Device::CheckNewWarning(const nsACString& aMessage) {
+  return mKnownWarnings.EnsureInserted(aMessage);
+}
+
+void Device::Destroy() {
+  // TODO
+}
+
+void Device::PushErrorScope(const dom::GPUErrorFilter& aFilter) {
+  if (mBridge->CanSend()) {
+    mBridge->SendDevicePushErrorScope(mId);
+  }
+}
+
+already_AddRefed<dom::Promise> Device::PopErrorScope(ErrorResult& aRv) {
+  RefPtr<dom::Promise> promise = dom::Promise::Create(GetParentObject(), aRv);
+  if (NS_WARN_IF(aRv.Failed())) {
+    return nullptr;
+  }
+
+  if (!mBridge->CanSend()) {
+    promise->MaybeRejectWithOperationError("Internal communication error");
+    return promise.forget();
+  }
+
+  auto errorPromise = mBridge->SendDevicePopErrorScope(mId);
+
+  errorPromise->Then(
+      GetCurrentSerialEventTarget(), __func__,
+      [self = RefPtr{this}, promise](const MaybeScopedError& aMaybeError) {
+        if (aMaybeError) {
+          if (aMaybeError->operationError) {
+            promise->MaybeRejectWithOperationError("Stack is empty");
+          } else {
+            dom::OwningGPUOutOfMemoryErrorOrGPUValidationError error;
+            if (aMaybeError->validationMessage.IsEmpty()) {
+              error.SetAsGPUOutOfMemoryError();
+            } else {
+              error.SetAsGPUValidationError() = new ValidationError(
+                  self->GetParentObject(), aMaybeError->validationMessage);
+            }
+            promise->MaybeResolve(std::move(error));
+          }
+        } else {
+          promise->MaybeResolveWithUndefined();
+        }
+      },
+      [promise](const ipc::ResponseRejectReason&) {
+        promise->MaybeRejectWithOperationError("Internal communication error");
+      });
+
+  return promise.forget();
+}
+
+}  // namespace mozilla::webgpu
diff --git a/dom/webgpu/Device.h b/dom/webgpu/Device.h
new file mode 100644
index 0000000000..f78426e185
--- /dev/null
+++ b/dom/webgpu/Device.h
@@ -0,0 +1,171 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef GPU_DEVICE_H_
+#define GPU_DEVICE_H_
+
+#include "ObjectModel.h"
+#include "nsTHashSet.h"
+#include "mozilla/MozPromise.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/WeakPtr.h"
+#include "mozilla/webgpu/WebGPUTypes.h"
+#include "mozilla/webgpu/PWebGPUTypes.h"
+#include "mozilla/webrender/WebRenderAPI.h"
+#include "mozilla/DOMEventTargetHelper.h"
+
+namespace mozilla {
+namespace dom {
+struct GPUExtensions;
+struct GPUFeatures;
+struct GPULimits;
+struct GPUExtent3DDict;
+
+struct GPUBufferDescriptor;
+struct GPUTextureDescriptor;
+struct GPUSamplerDescriptor;
+struct GPUBindGroupLayoutDescriptor;
+struct GPUPipelineLayoutDescriptor;
+struct GPUBindGroupDescriptor;
+struct GPUBlendStateDescriptor;
+struct GPUDepthStencilStateDescriptor;
+struct GPUInputStateDescriptor;
+struct GPUShaderModuleDescriptor;
+struct GPUAttachmentStateDescriptor;
+struct GPUComputePipelineDescriptor;
+struct GPURenderBundleEncoderDescriptor;
+struct GPURenderPipelineDescriptor;
+struct GPUCommandEncoderDescriptor;
+struct GPUCanvasConfiguration;
+
+class EventHandlerNonNull;
+class Promise;
+template <typename T>
+class Sequence;
+class GPUBufferOrGPUTexture;
+enum class GPUErrorFilter : uint8_t;
+enum class GPUFeatureName : uint8_t;
+class GPULogCallback;
+}  // namespace dom
+namespace ipc {
+enum class ResponseRejectReason;
+}  // namespace ipc
+
+namespace webgpu {
+namespace ffi {
+struct WGPULimits;
+}
+class Adapter;
+class BindGroup;
+class BindGroupLayout;
+class Buffer;
+class CommandEncoder;
+class ComputePipeline;
+class Fence;
+class InputState;
+class PipelineLayout;
+class Queue;
+class RenderBundleEncoder;
+class RenderPipeline;
+class Sampler;
+class ShaderModule;
+class SupportedFeatures;
+class SupportedLimits;
+class Texture;
+class WebGPUChild;
+
+using MappingPromise =
+    MozPromise<BufferMapResult, ipc::ResponseRejectReason, true>;
+
+class Device final : public DOMEventTargetHelper, public SupportsWeakPtr {
+ public:
+  NS_DECL_ISUPPORTS_INHERITED
+  NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(Device, DOMEventTargetHelper)
+  GPU_DECL_JS_WRAP(Device)
+
+  const RawId mId;
+  RefPtr<SupportedFeatures> mFeatures;
+  RefPtr<SupportedLimits> mLimits;
+
+  explicit Device(Adapter* const aParent, RawId aId,
+                  UniquePtr<ffi::WGPULimits> aRawLimits);
+
+  RefPtr<WebGPUChild> GetBridge();
+  already_AddRefed<Texture> InitSwapChain(
+      const dom::GPUCanvasConfiguration& aDesc,
+      const layers::RemoteTextureOwnerId aOwnerId, gfx::SurfaceFormat aFormat,
+      gfx::IntSize* aDefaultSize);
+  bool CheckNewWarning(const nsACString& aMessage);
+
+  void CleanupUnregisteredInParent();
+
+  void GenerateError(const nsCString& aMessage);
+
+  bool IsLost() const;
+
+ private:
+  ~Device();
+  void Cleanup();
+
+  RefPtr<WebGPUChild> mBridge;
+  bool mValid = true;
+  nsString mLabel;
+  RefPtr<dom::Promise> mLostPromise;
+  RefPtr<Queue> mQueue;
+  nsTHashSet<nsCString> mKnownWarnings;
+
+ public:
+  void GetLabel(nsAString& aValue) const;
+  void SetLabel(const nsAString& aLabel);
+  dom::Promise* GetLost(ErrorResult& aRv);
+  dom::Promise* MaybeGetLost() const { return mLostPromise; }
+
+  const RefPtr<SupportedFeatures>& Features() const { return mFeatures; }
+  const RefPtr<SupportedLimits>& Limits() const { return mLimits; }
+  const RefPtr<Queue>& GetQueue() const { return mQueue; }
+
+  already_AddRefed<Buffer> CreateBuffer(const dom::GPUBufferDescriptor& aDesc,
+                                        ErrorResult& aRv);
+
+  already_AddRefed<Texture> CreateTexture(
+      const dom::GPUTextureDescriptor& aDesc);
+  already_AddRefed<Sampler> CreateSampler(
+      const dom::GPUSamplerDescriptor& aDesc);
+
+  already_AddRefed<CommandEncoder> CreateCommandEncoder(
+      const dom::GPUCommandEncoderDescriptor& aDesc);
+  already_AddRefed<RenderBundleEncoder> CreateRenderBundleEncoder(
+      const dom::GPURenderBundleEncoderDescriptor& aDesc);
+
+  already_AddRefed<BindGroupLayout> CreateBindGroupLayout(
+      const dom::GPUBindGroupLayoutDescriptor& aDesc);
+  already_AddRefed<PipelineLayout> CreatePipelineLayout(
+      const dom::GPUPipelineLayoutDescriptor& aDesc);
+  already_AddRefed<BindGroup> CreateBindGroup(
+      const dom::GPUBindGroupDescriptor& aDesc);
+
+  already_AddRefed<ShaderModule> CreateShaderModule(
+      JSContext* aCx, const dom::GPUShaderModuleDescriptor& aDesc);
+  already_AddRefed<ComputePipeline> CreateComputePipeline(
+      const dom::GPUComputePipelineDescriptor& aDesc);
+  already_AddRefed<RenderPipeline> CreateRenderPipeline(
+      const dom::GPURenderPipelineDescriptor& aDesc);
+  already_AddRefed<dom::Promise> CreateComputePipelineAsync(
+      const dom::GPUComputePipelineDescriptor& aDesc, ErrorResult& aRv);
+  already_AddRefed<dom::Promise> CreateRenderPipelineAsync(
+      const dom::GPURenderPipelineDescriptor& aDesc, ErrorResult& aRv);
+
+  void PushErrorScope(const dom::GPUErrorFilter& aFilter);
+  already_AddRefed<dom::Promise> PopErrorScope(ErrorResult& aRv);
+
+  void Destroy();
+
+  IMPL_EVENT_HANDLER(uncapturederror)
+};
+
+}  // namespace webgpu
+}  // namespace mozilla
+
+#endif  // GPU_DEVICE_H_
diff --git a/dom/webgpu/DeviceLostInfo.cpp b/dom/webgpu/DeviceLostInfo.cpp
new file mode 100644
index 0000000000..4f1153ea60
--- /dev/null
+++ b/dom/webgpu/DeviceLostInfo.cpp
@@ -0,0 +1,13 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "DeviceLostInfo.h"
+
+namespace mozilla::webgpu {
+
+GPU_IMPL_CYCLE_COLLECTION(DeviceLostInfo, mGlobal)
+GPU_IMPL_JS_WRAP(DeviceLostInfo)
+
+}  // namespace mozilla::webgpu
diff --git a/dom/webgpu/DeviceLostInfo.h b/dom/webgpu/DeviceLostInfo.h
new file mode 100644
index 0000000000..1ab77610c7
--- /dev/null
+++ b/dom/webgpu/DeviceLostInfo.h
@@ -0,0 +1,51 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef GPU_DeviceLostInfo_H_
+#define GPU_DeviceLostInfo_H_
+
+#include "mozilla/dom/WebGPUBinding.h"
+#include "mozilla/Maybe.h"
+#include "nsWrapperCache.h"
+#include "ObjectModel.h"
+
+namespace mozilla::webgpu {
+class Device;
+
+class DeviceLostInfo final : public nsWrapperCache {
+ public:
+  GPU_DECL_CYCLE_COLLECTION(DeviceLostInfo)
+  GPU_DECL_JS_WRAP(DeviceLostInfo)
+
+  explicit DeviceLostInfo(nsIGlobalObject* const aGlobal,
+                          const nsAString& aMessage)
+      : mGlobal(aGlobal), mMessage(aMessage) {}
+  DeviceLostInfo(nsIGlobalObject* const aGlobal,
+                 dom::GPUDeviceLostReason aReason, const nsAString& aMessage)
+      : mGlobal(aGlobal), mReason(Some(aReason)), mMessage(aMessage) {}
+
+ private:
+  ~DeviceLostInfo() = default;
+  void Cleanup() {}
+
+  nsCOMPtr<nsIGlobalObject> mGlobal;
+  const Maybe<dom::GPUDeviceLostReason> mReason;
+  const nsAutoString mMessage;
+
+ public:
+  void GetReason(JSContext* aCx, JS::MutableHandle<JS::Value> aRetval) {
+    if (!mReason || !dom::ToJSValue(aCx, mReason.value(), aRetval)) {
+      aRetval.setUndefined();
+    }
+  }
+
+  void GetMessage(nsAString& aValue) const { aValue = mMessage; }
+
+  nsIGlobalObject* GetParentObject() const { return mGlobal; }
+};
+
+}  // namespace mozilla::webgpu
+
+#endif  // GPU_DeviceLostInfo_H_
diff --git a/dom/webgpu/Instance.cpp b/dom/webgpu/Instance.cpp
new file mode 100644
index 0000000000..a80b850da3
--- /dev/null
+++ b/dom/webgpu/Instance.cpp
@@ -0,0 +1,85 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "Instance.h"
+
+#include "Adapter.h"
+#include "nsIGlobalObject.h"
+#include "ipc/WebGPUChild.h"
+#include "ipc/WebGPUTypes.h"
+#include "mozilla/webgpu/ffi/wgpu.h"
+#include "mozilla/dom/Promise.h"
+#include "mozilla/gfx/CanvasManagerChild.h"
+#include "mozilla/gfx/gfxVars.h"
+
+namespace mozilla::webgpu {
+
+GPU_IMPL_CYCLE_COLLECTION(Instance, mOwner)
+
+/*static*/
+already_AddRefed<Instance> Instance::Create(nsIGlobalObject* aOwner) {
+  RefPtr<Instance> result = new Instance(aOwner);
+  return result.forget();
+}
+
+Instance::Instance(nsIGlobalObject* aOwner) : mOwner(aOwner) {}
+
+Instance::~Instance() { Cleanup(); }
+
+void Instance::Cleanup() {}
+
+JSObject* Instance::WrapObject(JSContext* cx,
+                               JS::Handle<JSObject*> givenProto) {
+  return dom::GPU_Binding::Wrap(cx, this, givenProto);
+}
+
+already_AddRefed<dom::Promise> Instance::RequestAdapter(
+    const dom::GPURequestAdapterOptions& aOptions, ErrorResult& aRv) {
+  RefPtr<dom::Promise> promise = dom::Promise::Create(mOwner, aRv);
+  if (NS_WARN_IF(aRv.Failed())) {
+    return nullptr;
+  }
+
+  if (!gfx::gfxVars::AllowWebGPU()) {
+    promise->MaybeRejectWithNotSupportedError("WebGPU is not enabled!");
+    return promise.forget();
+  }
+
+  auto* const canvasManager = gfx::CanvasManagerChild::Get();
+  if (!canvasManager) {
+    promise->MaybeRejectWithInvalidStateError(
+        "Failed to create CanavasManagerChild");
+    return promise.forget();
+  }
+
+  RefPtr<WebGPUChild> bridge = canvasManager->GetWebGPUChild();
+  if (!bridge) {
+    promise->MaybeRejectWithInvalidStateError("Failed to create WebGPUChild");
+    return promise.forget();
+  }
+
+  RefPtr<Instance> instance = this;
+
+  bridge->InstanceRequestAdapter(aOptions)->Then(
+      GetCurrentSerialEventTarget(), __func__,
+      [promise, instance, bridge](ipc::ByteBuf aInfoBuf) {
+        ffi::WGPUAdapterInformation info = {};
+        ffi::wgpu_client_adapter_extract_info(ToFFI(&aInfoBuf), &info);
+        MOZ_ASSERT(info.id != 0);
+        RefPtr<Adapter> adapter = new Adapter(instance, bridge, info);
+        promise->MaybeResolve(adapter);
+      },
+      [promise](const Maybe<ipc::ResponseRejectReason>& aResponseReason) {
+        if (aResponseReason.isSome()) {
+          promise->MaybeRejectWithAbortError("Internal communication error!");
+        } else {
+          promise->MaybeResolve(JS::NullHandleValue);
+        }
+      });
+
+  return promise.forget();
+}
+
+}  // namespace mozilla::webgpu
diff --git a/dom/webgpu/Instance.h b/dom/webgpu/Instance.h
new file mode 100644
index 0000000000..222a66ad81
--- /dev/null
+++ b/dom/webgpu/Instance.h
@@ -0,0 +1,51 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef GPU_INSTANCE_H_
+#define GPU_INSTANCE_H_
+
+#include "mozilla/AlreadyAddRefed.h"
+#include "mozilla/RefPtr.h"
+#include "nsCOMPtr.h"
+#include "ObjectModel.h"
+
+namespace mozilla {
+class ErrorResult;
+namespace dom {
+class Promise;
+struct GPURequestAdapterOptions;
+}  // namespace dom
+
+namespace webgpu {
+class Adapter;
+class GPUAdapter;
+class WebGPUChild;
+
+class Instance final : public nsWrapperCache {
+ public:
+  GPU_DECL_CYCLE_COLLECTION(Instance)
+  GPU_DECL_JS_WRAP(Instance)
+
+  nsIGlobalObject* GetParentObject() const { return mOwner; }
+
+  static already_AddRefed<Instance> Create(nsIGlobalObject* aOwner);
+
+  already_AddRefed<dom::Promise> RequestAdapter(
+      const dom::GPURequestAdapterOptions& aOptions, ErrorResult& aRv);
+
+ private:
+  explicit Instance(nsIGlobalObject* aOwner);
+  virtual ~Instance();
+  void Cleanup();
+
+  nsCOMPtr<nsIGlobalObject> mOwner;
+
+ public:
+};
+
+}  // namespace webgpu
+}  // namespace mozilla
+
+#endif  // GPU_INSTANCE_H_
diff --git a/dom/webgpu/ObjectModel.cpp b/dom/webgpu/ObjectModel.cpp
new file mode 100644
index 0000000000..f691a17b66
--- /dev/null
+++ b/dom/webgpu/ObjectModel.cpp
@@ -0,0 +1,40 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "ObjectModel.h"
+
+#include "Adapter.h"
+#include "ShaderModule.h"
+#include "CompilationInfo.h"
+#include "Device.h"
+#include "CommandEncoder.h"
+#include "Instance.h"
+#include "Texture.h"
+
+namespace mozilla::webgpu {
+
+template <typename T>
+ChildOf<T>::ChildOf(T* const parent) : mParent(parent) {}
+
+template <typename T>
+ChildOf<T>::~ChildOf() = default;
+
+template <typename T>
+nsIGlobalObject* ChildOf<T>::GetParentObject() const {
+  return mParent->GetParentObject();
+}
+
+void ObjectBase::GetLabel(nsAString& aValue) const { aValue = mLabel; }
+void ObjectBase::SetLabel(const nsAString& aLabel) { mLabel = aLabel; }
+
+template class ChildOf<Adapter>;
+template class ChildOf<ShaderModule>;
+template class ChildOf<CompilationInfo>;
+template class ChildOf<CommandEncoder>;
+template class ChildOf<Device>;
+template class ChildOf<Instance>;
+template class ChildOf<Texture>;
+
+}  // namespace mozilla::webgpu
diff --git a/dom/webgpu/ObjectModel.h b/dom/webgpu/ObjectModel.h
new file mode 100644
index 0000000000..d482ac16f5
--- /dev/null
+++ b/dom/webgpu/ObjectModel.h
@@ -0,0 +1,131 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef GPU_OBJECT_MODEL_H_
+#define GPU_OBJECT_MODEL_H_
+
+#include "nsWrapperCache.h"
+#include "nsString.h"
+
+class nsIGlobalObject;
+
+namespace mozilla::webgpu {
+class WebGPUChild;
+
+template <typename T>
+class ChildOf {
+ protected:
+  explicit ChildOf(T* const parent);
+  virtual ~ChildOf();
+
+  RefPtr<T> mParent;
+
+ public:
+  nsIGlobalObject* GetParentObject() const;
+};
+
+class ObjectBase : public nsWrapperCache {
+ private:
+  nsString mLabel;
+
+ protected:
+  virtual ~ObjectBase() = default;
+
+  // False if this object is definitely invalid.
+  //
+  // See WebGPU §3.2, "Invalid Internal Objects & Contagious Invalidity".
+  //
+  // There could also be state in the GPU process indicating that our
+  // counterpart object there is invalid; certain GPU process operations will
+  // report an error back to use if we try to use it. But if it's useful to know
+  // whether the object is "definitely invalid", this should suffice.
+  bool mValid = true;
+
+ public:
+  // Return true if this WebGPU object may be valid.
+  //
+  // This is used by methods that want to know whether somebody other than
+  // `this` is valid. Generally, WebGPU object methods check `this->mValid`
+  // directly.
+  bool IsValid() const { return mValid; }
+
+  void GetLabel(nsAString& aValue) const;
+  void SetLabel(const nsAString& aLabel);
+};
+
+}  // namespace mozilla::webgpu
+
+#define GPU_DECL_JS_WRAP(T)                                             \
+  JSObject* WrapObject(JSContext* cx, JS::Handle<JSObject*> givenProto) \
+      override;
+
+#define GPU_DECL_CYCLE_COLLECTION(T)                    \
+  NS_DECL_CYCLE_COLLECTION_NATIVE_WRAPPERCACHE_CLASS(T) \
+  NS_INLINE_DECL_CYCLE_COLLECTING_NATIVE_REFCOUNTING(T)
+
+#define GPU_IMPL_JS_WRAP(T)                                                  \
+  JSObject* T::WrapObject(JSContext* cx, JS::Handle<JSObject*> givenProto) { \
+    return dom::GPU##T##_Binding::Wrap(cx, this, givenProto);                \
+  }
+
+// Note: we don't use `NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE` directly
+// because there is a custom action we need to always do.
+#define GPU_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(T, ...) \
+  NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(T)       \
+  NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(T)             \
+    tmp->Cleanup();                                    \
+    NS_IMPL_CYCLE_COLLECTION_UNLINK(__VA_ARGS__)       \
+    NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER  \
+  NS_IMPL_CYCLE_COLLECTION_UNLINK_END                  \
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(T)           \
+    NS_IMPL_CYCLE_COLLECTION_TRAVERSE(__VA_ARGS__)     \
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+#define GPU_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_WEAK_PTR(T, ...) \
+  NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(T)                \
+  NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(T)                      \
+    tmp->Cleanup();                                             \
+    NS_IMPL_CYCLE_COLLECTION_UNLINK(__VA_ARGS__)                \
+    NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER           \
+    NS_IMPL_CYCLE_COLLECTION_UNLINK_WEAK_PTR                    \
+  NS_IMPL_CYCLE_COLLECTION_UNLINK_END                           \
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(T)                    \
+    NS_IMPL_CYCLE_COLLECTION_TRAVERSE(__VA_ARGS__)              \
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+#define GPU_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_INHERITED(T, P, ...) \
+  NS_IMPL_CYCLE_COLLECTION_CLASS(T)                                 \
+  NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(T, P)             \
+    tmp->Cleanup();                                                 \
+    NS_IMPL_CYCLE_COLLECTION_UNLINK(__VA_ARGS__)                    \
+    NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER               \
+    NS_IMPL_CYCLE_COLLECTION_UNLINK_WEAK_PTR                        \
+  NS_IMPL_CYCLE_COLLECTION_UNLINK_END                               \
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(T, P)           \
+    NS_IMPL_CYCLE_COLLECTION_TRAVERSE(__VA_ARGS__)                  \
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+#define GPU_IMPL_CYCLE_COLLECTION(T, ...) \
+  GPU_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(T, __VA_ARGS__)
+
+template <typename T>
+void ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& callback,
+                                 nsTArray<RefPtr<const T>>& field,
+                                 const char* name, uint32_t flags) {
+  for (auto& element : field) {
+    CycleCollectionNoteChild(callback, const_cast<T*>(element.get()), name,
+                             flags);
+  }
+}
+
+template <typename T>
+void ImplCycleCollectionUnlink(nsTArray<RefPtr<const T>>& field) {
+  for (auto& element : field) {
+    ImplCycleCollectionUnlink(element);
+  }
+  field.Clear();
+}
+
+#endif  // GPU_OBJECT_MODEL_H_
diff --git a/dom/webgpu/OutOfMemoryError.cpp b/dom/webgpu/OutOfMemoryError.cpp
new file mode 100644
index 0000000000..edf52369df
--- /dev/null
+++ b/dom/webgpu/OutOfMemoryError.cpp
@@ -0,0 +1,17 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "OutOfMemoryError.h"
+#include "Device.h"
+#include "mozilla/dom/WebGPUBinding.h"
+
+namespace mozilla::webgpu {
+
+GPU_IMPL_CYCLE_COLLECTION(OutOfMemoryError, mParent)
+GPU_IMPL_JS_WRAP(OutOfMemoryError)
+
+OutOfMemoryError::~OutOfMemoryError() = default;
+
+}  // namespace mozilla::webgpu
diff --git a/dom/webgpu/OutOfMemoryError.h b/dom/webgpu/OutOfMemoryError.h
new file mode 100644
index 0000000000..e634e396f1
--- /dev/null
+++ b/dom/webgpu/OutOfMemoryError.h
@@ -0,0 +1,35 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef GPU_OutOfMemoryError_H_
+#define GPU_OutOfMemoryError_H_
+
+#include "nsWrapperCache.h"
+#include "ObjectModel.h"
+
+namespace mozilla {
+namespace dom {
+class GlobalObject;
+}  // namespace dom
+namespace webgpu {
+class Device;
+
+class OutOfMemoryError final : public nsWrapperCache, public ChildOf<Device> {
+ public:
+  GPU_DECL_CYCLE_COLLECTION(OutOfMemoryError)
+  GPU_DECL_JS_WRAP(OutOfMemoryError)
+  OutOfMemoryError() = delete;
+
+ private:
+  virtual ~OutOfMemoryError();
+  void Cleanup() {}
+
+ public:
+};
+
+}  // namespace webgpu
+}  // namespace mozilla
+
+#endif  // GPU_OutOfMemoryError_H_
diff --git a/dom/webgpu/PipelineLayout.cpp b/dom/webgpu/PipelineLayout.cpp
new file mode 100644
index 0000000000..21485e78a5
--- /dev/null
+++ b/dom/webgpu/PipelineLayout.cpp
@@ -0,0 +1,36 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/dom/WebGPUBinding.h"
+#include "PipelineLayout.h"
+#include "ipc/WebGPUChild.h"
+
+#include "Device.h"
+
+namespace mozilla::webgpu {
+
+GPU_IMPL_CYCLE_COLLECTION(PipelineLayout, mParent)
+GPU_IMPL_JS_WRAP(PipelineLayout)
+
+PipelineLayout::PipelineLayout(Device* const aParent, RawId aId)
+    : ChildOf(aParent), mId(aId) {
+  if (!aId) {
+    mValid = false;
+  }
+}
+
+PipelineLayout::~PipelineLayout() { Cleanup(); }
+
+void PipelineLayout::Cleanup() {
+  if (mValid && mParent) {
+    mValid = false;
+    auto bridge = mParent->GetBridge();
+    if (bridge && bridge->IsOpen()) {
+      bridge->SendPipelineLayoutDestroy(mId);
+    }
+  }
+}
+
+}  // namespace mozilla::webgpu
diff --git a/dom/webgpu/PipelineLayout.h b/dom/webgpu/PipelineLayout.h
new file mode 100644
index 0000000000..65293d778d
--- /dev/null
+++ b/dom/webgpu/PipelineLayout.h
@@ -0,0 +1,33 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef GPU_PipelineLayout_H_
+#define GPU_PipelineLayout_H_
+
+#include "nsWrapperCache.h"
+#include "ObjectModel.h"
+#include "mozilla/webgpu/WebGPUTypes.h"
+
+namespace mozilla::webgpu {
+
+class Device;
+
+class PipelineLayout final : public ObjectBase, public ChildOf<Device> {
+ public:
+  GPU_DECL_CYCLE_COLLECTION(PipelineLayout)
+  GPU_DECL_JS_WRAP(PipelineLayout)
+
+  PipelineLayout(Device* const aParent, RawId aId);
+
+  const RawId mId;
+
+ private:
+  virtual ~PipelineLayout();
+  void Cleanup();
+};
+
+}  // namespace mozilla::webgpu
+
+#endif  // GPU_PipelineLayout_H_
diff --git a/dom/webgpu/QuerySet.cpp b/dom/webgpu/QuerySet.cpp
new file mode 100644
index 0000000000..05f30f6cc8
--- /dev/null
+++ b/dom/webgpu/QuerySet.cpp
@@ -0,0 +1,22 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/dom/WebGPUBinding.h"
+#include "QuerySet.h"
+
+#include "Device.h"
+
+namespace mozilla::webgpu {
+
+QuerySet::~QuerySet() = default;
+
+GPU_IMPL_CYCLE_COLLECTION(QuerySet, mParent)
+GPU_IMPL_JS_WRAP(QuerySet)
+
+void QuerySet::Destroy() {
+  // TODO
+}
+
+}  // namespace mozilla::webgpu
diff --git a/dom/webgpu/QuerySet.h b/dom/webgpu/QuerySet.h
new file mode 100644
index 0000000000..e7e6f4968b
--- /dev/null
+++ b/dom/webgpu/QuerySet.h
@@ -0,0 +1,31 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef GPU_QuerySet_H_
+#define GPU_QuerySet_H_
+
+#include "nsWrapperCache.h"
+#include "ObjectModel.h"
+
+namespace mozilla::webgpu {
+
+class Device;
+
+class QuerySet final : public ObjectBase, public ChildOf<Device> {
+ public:
+  GPU_DECL_CYCLE_COLLECTION(QuerySet)
+  GPU_DECL_JS_WRAP(QuerySet)
+
+  QuerySet() = delete;
+  void Destroy();
+
+ private:
+  virtual ~QuerySet();
+  void Cleanup() {}
+};
+
+}  // namespace mozilla::webgpu
+
+#endif  // GPU_QuerySet_H_
diff --git a/dom/webgpu/Queue.cpp b/dom/webgpu/Queue.cpp
new file mode 100644
index 0000000000..b71f220066
--- /dev/null
+++ b/dom/webgpu/Queue.cpp
@@ -0,0 +1,416 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/dom/WebGPUBinding.h"
+#include "mozilla/dom/UnionTypes.h"
+#include "Queue.h"
+
+#include <algorithm>
+
+#include "CommandBuffer.h"
+#include "CommandEncoder.h"
+#include "ipc/WebGPUChild.h"
+#include "mozilla/Casting.h"
+#include "mozilla/ErrorResult.h"
+#include "mozilla/dom/HTMLCanvasElement.h"
+#include "mozilla/dom/ImageBitmap.h"
+#include "mozilla/dom/OffscreenCanvas.h"
+#include "mozilla/dom/WebGLTexelConversions.h"
+#include "mozilla/dom/WebGLTypes.h"
+#include "nsLayoutUtils.h"
+
+namespace mozilla::webgpu {
+
+GPU_IMPL_CYCLE_COLLECTION(Queue, mParent, mBridge)
+GPU_IMPL_JS_WRAP(Queue)
+
+Queue::Queue(Device* const aParent, WebGPUChild* aBridge, RawId aId)
+    : ChildOf(aParent), mBridge(aBridge), mId(aId) {}
+
+Queue::~Queue() { Cleanup(); }
+
+void Queue::Submit(
+    const dom::Sequence<OwningNonNull<CommandBuffer>>& aCommandBuffers) {
+  nsTArray<RawId> list(aCommandBuffers.Length());
+  for (uint32_t i = 0; i < aCommandBuffers.Length(); ++i) {
+    auto idMaybe = aCommandBuffers[i]->Commit();
+    if (idMaybe) {
+      list.AppendElement(*idMaybe);
+    }
+  }
+
+  mBridge->SendQueueSubmit(mId, mParent->mId, list);
+}
+
+void Queue::WriteBuffer(const Buffer& aBuffer, uint64_t aBufferOffset,
+                        const dom::ArrayBufferViewOrArrayBuffer& aData,
+                        uint64_t aDataOffset,
+                        const dom::Optional<uint64_t>& aSize,
+                        ErrorResult& aRv) {
+  uint64_t length = 0;
+  uint8_t* data = nullptr;
+  if (aData.IsArrayBufferView()) {
+    const auto& view = aData.GetAsArrayBufferView();
+    view.ComputeState();
+    length = view.Length();
+    data = view.Data();
+  }
+  if (aData.IsArrayBuffer()) {
+    const auto& ab = aData.GetAsArrayBuffer();
+    ab.ComputeState();
+    length = ab.Length();
+    data = ab.Data();
+  }
+
+  MOZ_ASSERT(data != nullptr);
+
+  const auto checkedSize = aSize.WasPassed()
+                               ? CheckedInt<size_t>(aSize.Value())
+                               : CheckedInt<size_t>(length) - aDataOffset;
+  if (!checkedSize.isValid()) {
+    aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
+    return;
+  }
+
+  const auto& size = checkedSize.value();
+  if (aDataOffset + size > length) {
+    aRv.ThrowAbortError(nsPrintfCString("Wrong data size %" PRIuPTR, size));
+    return;
+  }
+
+  if (size % 4 != 0) {
+    aRv.ThrowAbortError("Byte size must be a multiple of 4");
+    return;
+  }
+
+  auto alloc = mozilla::ipc::UnsafeSharedMemoryHandle::CreateAndMap(size);
+  if (alloc.isNothing()) {
+    aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
+    return;
+  }
+
+  auto handle = std::move(alloc.ref().first);
+  auto mapping = std::move(alloc.ref().second);
+
+  memcpy(mapping.Bytes().data(), data + aDataOffset, size);
+  ipc::ByteBuf bb;
+  ffi::wgpu_queue_write_buffer(aBuffer.mId, aBufferOffset, ToFFI(&bb));
+  if (!mBridge->SendQueueWriteAction(mId, mParent->mId, std::move(bb),
+                                     std::move(handle))) {
+    MOZ_CRASH("IPC failure");
+  }
+}
+
+void Queue::WriteTexture(const dom::GPUImageCopyTexture& aDestination,
+                         const dom::ArrayBufferViewOrArrayBuffer& aData,
+                         const dom::GPUImageDataLayout& aDataLayout,
+                         const dom::GPUExtent3D& aSize, ErrorResult& aRv) {
+  ffi::WGPUImageCopyTexture copyView = {};
+  CommandEncoder::ConvertTextureCopyViewToFFI(aDestination, &copyView);
+  ffi::WGPUImageDataLayout dataLayout = {};
+  CommandEncoder::ConvertTextureDataLayoutToFFI(aDataLayout, &dataLayout);
+  dataLayout.offset = 0;  // our Shmem has the contents starting from 0.
+  ffi::WGPUExtent3d extent = {};
+  CommandEncoder::ConvertExtent3DToFFI(aSize, &extent);
+
+  uint64_t availableSize = 0;
+  uint8_t* data = nullptr;
+  if (aData.IsArrayBufferView()) {
+    const auto& view = aData.GetAsArrayBufferView();
+    view.ComputeState();
+    availableSize = view.Length();
+    data = view.Data();
+  }
+  if (aData.IsArrayBuffer()) {
+    const auto& ab = aData.GetAsArrayBuffer();
+    ab.ComputeState();
+    availableSize = ab.Length();
+    data = ab.Data();
+  }
+
+  if (!availableSize) {
+    aRv.ThrowAbortError("Input size cannot be zero.");
+    return;
+  }
+  MOZ_ASSERT(data != nullptr);
+
+  const auto checkedSize =
+      CheckedInt<size_t>(availableSize) - aDataLayout.mOffset;
+  if (!checkedSize.isValid()) {
+    aRv.ThrowAbortError(nsPrintfCString("Offset is higher than the size"));
+    return;
+  }
+  const auto size = checkedSize.value();
+
+  auto alloc = mozilla::ipc::UnsafeSharedMemoryHandle::CreateAndMap(size);
+  if (alloc.isNothing()) {
+    aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
+    return;
+  }
+
+  auto handle = std::move(alloc.ref().first);
+  auto mapping = std::move(alloc.ref().second);
+
+  memcpy(mapping.Bytes().data(), data + aDataLayout.mOffset, size);
+
+  ipc::ByteBuf bb;
+  ffi::wgpu_queue_write_texture(copyView, dataLayout, extent, ToFFI(&bb));
+  if (!mBridge->SendQueueWriteAction(mId, mParent->mId, std::move(bb),
+                                     std::move(handle))) {
+    MOZ_CRASH("IPC failure");
+  }
+}
+
+static WebGLTexelFormat ToWebGLTexelFormat(gfx::SurfaceFormat aFormat) {
+  switch (aFormat) {
+    case gfx::SurfaceFormat::B8G8R8A8:
+    case gfx::SurfaceFormat::B8G8R8X8:
+      return WebGLTexelFormat::BGRA8;
+    case gfx::SurfaceFormat::R8G8B8A8:
+    case gfx::SurfaceFormat::R8G8B8X8:
+      return WebGLTexelFormat::RGBA8;
+    default:
+      return WebGLTexelFormat::FormatNotSupportingAnyConversion;
+  }
+}
+
+static WebGLTexelFormat ToWebGLTexelFormat(dom::GPUTextureFormat aFormat) {
+  // TODO: We need support for Rbg10a2unorm as well.
+  switch (aFormat) {
+    case dom::GPUTextureFormat::R8unorm:
+      return WebGLTexelFormat::R8;
+    case dom::GPUTextureFormat::R16float:
+      return WebGLTexelFormat::R16F;
+    case dom::GPUTextureFormat::R32float:
+      return WebGLTexelFormat::R32F;
+    case dom::GPUTextureFormat::Rg8unorm:
+      return WebGLTexelFormat::RG8;
+    case dom::GPUTextureFormat::Rg16float:
+      return WebGLTexelFormat::RG16F;
+    case dom::GPUTextureFormat::Rg32float:
+      return WebGLTexelFormat::RG32F;
+    case dom::GPUTextureFormat::Rgba8unorm:
+    case dom::GPUTextureFormat::Rgba8unorm_srgb:
+      return WebGLTexelFormat::RGBA8;
+    case dom::GPUTextureFormat::Bgra8unorm:
+    case dom::GPUTextureFormat::Bgra8unorm_srgb:
+      return WebGLTexelFormat::BGRA8;
+    case dom::GPUTextureFormat::Rgba16float:
+      return WebGLTexelFormat::RGBA16F;
+    case dom::GPUTextureFormat::Rgba32float:
+      return WebGLTexelFormat::RGBA32F;
+    default:
+      return WebGLTexelFormat::FormatNotSupportingAnyConversion;
+  }
+}
+
+void Queue::CopyExternalImageToTexture(
+    const dom::GPUImageCopyExternalImage& aSource,
+    const dom::GPUImageCopyTextureTagged& aDestination,
+    const dom::GPUExtent3D& aCopySize, ErrorResult& aRv) {
+  const auto dstFormat = ToWebGLTexelFormat(aDestination.mTexture->mFormat);
+  if (dstFormat == WebGLTexelFormat::FormatNotSupportingAnyConversion) {
+    aRv.ThrowInvalidStateError("Unsupported destination format");
+    return;
+  }
+
+  const uint32_t surfaceFlags = nsLayoutUtils::SFE_ALLOW_NON_PREMULT;
+  SurfaceFromElementResult sfeResult;
+  if (aSource.mSource.IsImageBitmap()) {
+    const auto& bitmap = aSource.mSource.GetAsImageBitmap();
+    if (bitmap->IsClosed()) {
+      aRv.ThrowInvalidStateError("Detached ImageBitmap");
+      return;
+    }
+
+    sfeResult = nsLayoutUtils::SurfaceFromImageBitmap(bitmap, surfaceFlags);
+  } else if (aSource.mSource.IsHTMLCanvasElement()) {
+    MOZ_ASSERT(NS_IsMainThread());
+
+    const auto& canvas = aSource.mSource.GetAsHTMLCanvasElement();
+    if (canvas->Width() == 0 || canvas->Height() == 0) {
+      aRv.ThrowInvalidStateError("Zero-sized HTMLCanvasElement");
+      return;
+    }
+
+    sfeResult = nsLayoutUtils::SurfaceFromElement(canvas, surfaceFlags);
+  } else if (aSource.mSource.IsOffscreenCanvas()) {
+    const auto& canvas = aSource.mSource.GetAsOffscreenCanvas();
+    if (canvas->Width() == 0 || canvas->Height() == 0) {
+      aRv.ThrowInvalidStateError("Zero-sized OffscreenCanvas");
+      return;
+    }
+
+    sfeResult = nsLayoutUtils::SurfaceFromOffscreenCanvas(canvas, surfaceFlags);
+  }
+
+  if (!sfeResult.mCORSUsed) {
+    nsIGlobalObject* global = mParent->GetOwnerGlobal();
+    nsIPrincipal* dstPrincipal = global ? global->PrincipalOrNull() : nullptr;
+    if (!sfeResult.mPrincipal || !dstPrincipal ||
+        !dstPrincipal->Subsumes(sfeResult.mPrincipal)) {
+      aRv.ThrowSecurityError("Cross-origin elements require CORS!");
+      return;
+    }
+  }
+
+  if (sfeResult.mIsWriteOnly) {
+    aRv.ThrowSecurityError("Write only source data not supported!");
+    return;
+  }
+
+  RefPtr<gfx::SourceSurface> surface = sfeResult.GetSourceSurface();
+  if (!surface) {
+    aRv.ThrowInvalidStateError("No surface available from source");
+    return;
+  }
+
+  RefPtr<gfx::DataSourceSurface> dataSurface = surface->GetDataSurface();
+  if (!dataSurface) {
+    aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
+    return;
+  }
+
+  bool srcPremultiplied;
+  switch (sfeResult.mAlphaType) {
+    case gfxAlphaType::Premult:
+      srcPremultiplied = true;
+      break;
+    case gfxAlphaType::NonPremult:
+      srcPremultiplied = false;
+      break;
+    case gfxAlphaType::Opaque:
+      // No (un)premultiplication necessary so match the output.
+      srcPremultiplied = aDestination.mPremultipliedAlpha;
+      break;
+  }
+
+  const auto surfaceFormat = dataSurface->GetFormat();
+  const auto srcFormat = ToWebGLTexelFormat(surfaceFormat);
+  if (srcFormat == WebGLTexelFormat::FormatNotSupportingAnyConversion) {
+    gfxCriticalError() << "Unsupported surface format from source "
+                       << surfaceFormat;
+    MOZ_CRASH();
+  }
+
+  gfx::DataSourceSurface::ScopedMap map(dataSurface,
+                                        gfx::DataSourceSurface::READ);
+  if (!map.IsMapped()) {
+    aRv.ThrowInvalidStateError("Cannot map surface from source");
+    return;
+  }
+
+  if (!aSource.mOrigin.IsGPUOrigin2DDict()) {
+    aRv.ThrowInvalidStateError("Cannot get origin from source");
+    return;
+  }
+
+  ffi::WGPUExtent3d extent = {};
+  CommandEncoder::ConvertExtent3DToFFI(aCopySize, &extent);
+  if (extent.depth_or_array_layers > 1) {
+    aRv.ThrowOperationError("Depth is greater than 1");
+    return;
+  }
+
+  uint32_t srcOriginX;
+  uint32_t srcOriginY;
+  if (aSource.mOrigin.IsRangeEnforcedUnsignedLongSequence()) {
+    const auto& seq = aSource.mOrigin.GetAsRangeEnforcedUnsignedLongSequence();
+    srcOriginX = seq.Length() > 0 ? seq[0] : 0;
+    srcOriginY = seq.Length() > 1 ? seq[1] : 0;
+  } else if (aSource.mOrigin.IsGPUOrigin2DDict()) {
+    const auto& dict = aSource.mOrigin.GetAsGPUOrigin2DDict();
+    srcOriginX = dict.mX;
+    srcOriginY = dict.mY;
+  } else {
+    MOZ_CRASH("Unexpected origin type!");
+  }
+
+  const auto checkedMaxWidth = CheckedInt<uint32_t>(srcOriginX) + extent.width;
+  const auto checkedMaxHeight =
+      CheckedInt<uint32_t>(srcOriginY) + extent.height;
+  if (!checkedMaxWidth.isValid() || !checkedMaxHeight.isValid()) {
+    aRv.ThrowOperationError("Offset and copy size exceed integer bounds");
+    return;
+  }
+
+  const gfx::IntSize surfaceSize = dataSurface->GetSize();
+  const auto surfaceWidth = AssertedCast<uint32_t>(surfaceSize.width);
+  const auto surfaceHeight = AssertedCast<uint32_t>(surfaceSize.height);
+  if (surfaceWidth < checkedMaxWidth.value() ||
+      surfaceHeight < checkedMaxHeight.value()) {
+    aRv.ThrowOperationError("Offset and copy size exceed surface bounds");
+    return;
+  }
+
+  const auto dstWidth = extent.width;
+  const auto dstHeight = extent.height;
+  if (dstWidth == 0 || dstHeight == 0) {
+    aRv.ThrowOperationError("Destination size is empty");
+    return;
+  }
+
+  if (!aDestination.mTexture->mBytesPerBlock) {
+    // TODO(bug 1781071) This should emmit a GPUValidationError on the device
+    // timeline.
+    aRv.ThrowInvalidStateError("Invalid destination format");
+    return;
+  }
+
+  // Note: This assumes bytes per block == bytes per pixel which is the case
+  // here because the spec only allows non-compressed texture formats for the
+  // destination.
+  const auto dstStride = CheckedInt<uint32_t>(extent.width) *
+                         aDestination.mTexture->mBytesPerBlock.value();
+  const auto dstByteLength = dstStride * extent.height;
+  if (!dstStride.isValid() || !dstByteLength.isValid()) {
+    aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
+    return;
+  }
+
+  auto alloc = mozilla::ipc::UnsafeSharedMemoryHandle::CreateAndMap(
+      dstByteLength.value());
+  if (alloc.isNothing()) {
+    aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
+    return;
+  }
+
+  auto handle = std::move(alloc.ref().first);
+  auto mapping = std::move(alloc.ref().second);
+
+  const int32_t pixelSize = gfx::BytesPerPixel(surfaceFormat);
+  auto* dstBegin = mapping.Bytes().data();
+  const auto* srcBegin =
+      map.GetData() + srcOriginX * pixelSize + srcOriginY * map.GetStride();
+  const auto srcOriginPos = gl::OriginPos::TopLeft;
+  const auto srcStride = AssertedCast<uint32_t>(map.GetStride());
+  const auto dstOriginPos =
+      aSource.mFlipY ? gl::OriginPos::BottomLeft : gl::OriginPos::TopLeft;
+  bool wasTrivial;
+
+  if (!ConvertImage(dstWidth, dstHeight, srcBegin, srcStride, srcOriginPos,
+                    srcFormat, srcPremultiplied, dstBegin, dstStride.value(),
+                    dstOriginPos, dstFormat, aDestination.mPremultipliedAlpha,
+                    &wasTrivial)) {
+    MOZ_ASSERT_UNREACHABLE("ConvertImage failed!");
+    aRv.ThrowInvalidStateError(
+        nsPrintfCString("Failed to convert source to destination format "
+                        "(%i/%i), please file a bug!",
+                        (int)srcFormat, (int)dstFormat));
+    return;
+  }
+
+  ffi::WGPUImageDataLayout dataLayout = {0, dstStride.value(), dstHeight};
+  ffi::WGPUImageCopyTexture copyView = {};
+  CommandEncoder::ConvertTextureCopyViewToFFI(aDestination, &copyView);
+  ipc::ByteBuf bb;
+  ffi::wgpu_queue_write_texture(copyView, dataLayout, extent, ToFFI(&bb));
+  if (!mBridge->SendQueueWriteAction(mId, mParent->mId, std::move(bb),
+                                     std::move(handle))) {
+    MOZ_CRASH("IPC failure");
+  }
+}
+
+}  // namespace mozilla::webgpu
diff --git a/dom/webgpu/Queue.h b/dom/webgpu/Queue.h
new file mode 100644
index 0000000000..27fb23c780
--- /dev/null
+++ b/dom/webgpu/Queue.h
@@ -0,0 +1,74 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef GPU_Queue_H_
+#define GPU_Queue_H_
+
+#include "nsWrapperCache.h"
+#include "ObjectModel.h"
+#include "mozilla/dom/TypedArray.h"
+#include "mozilla/webgpu/WebGPUTypes.h"
+
+namespace mozilla {
+class ErrorResult;
+namespace dom {
+class RangeEnforcedUnsignedLongSequenceOrGPUExtent3DDict;
+class ArrayBufferViewOrArrayBuffer;
+template <typename T>
+class Optional;
+template <typename T>
+class Sequence;
+struct GPUImageCopyTexture;
+struct GPUImageDataLayout;
+struct TextureCopyView;
+struct TextureDataLayout;
+using GPUExtent3D = RangeEnforcedUnsignedLongSequenceOrGPUExtent3DDict;
+}  // namespace dom
+namespace webgpu {
+
+class Buffer;
+class CommandBuffer;
+class Device;
+class Fence;
+
+class Queue final : public ObjectBase, public ChildOf<Device> {
+ public:
+  GPU_DECL_CYCLE_COLLECTION(Queue)
+  GPU_DECL_JS_WRAP(Queue)
+
+  Queue(Device* const aParent, WebGPUChild* aBridge, RawId aId);
+
+  void Submit(
+      const dom::Sequence<OwningNonNull<CommandBuffer>>& aCommandBuffers);
+
+  void WriteBuffer(const Buffer& aBuffer, uint64_t aBufferOffset,
+                   const dom::ArrayBufferViewOrArrayBuffer& aData,
+                   uint64_t aDataOffset, const dom::Optional<uint64_t>& aSize,
+                   ErrorResult& aRv);
+
+  void WriteTexture(const dom::GPUImageCopyTexture& aDestination,
+                    const dom::ArrayBufferViewOrArrayBuffer& aData,
+                    const dom::GPUImageDataLayout& aDataLayout,
+                    const dom::GPUExtent3D& aSize, ErrorResult& aRv);
+
+  void CopyExternalImageToTexture(
+      const dom::GPUImageCopyExternalImage& aSource,
+      const dom::GPUImageCopyTextureTagged& aDestination,
+      const dom::GPUExtent3D& aCopySize, ErrorResult& aRv);
+
+ private:
+  virtual ~Queue();
+  void Cleanup() {}
+
+  RefPtr<WebGPUChild> mBridge;
+  const RawId mId;
+
+ public:
+};
+
+}  // namespace webgpu
+}  // namespace mozilla
+
+#endif  // GPU_Queue_H_
diff --git a/dom/webgpu/RenderBundle.cpp b/dom/webgpu/RenderBundle.cpp
new file mode 100644
index 0000000000..0e6ce87874
--- /dev/null
+++ b/dom/webgpu/RenderBundle.cpp
@@ -0,0 +1,38 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/dom/WebGPUBinding.h"
+#include "RenderBundle.h"
+
+#include "Device.h"
+#include "ipc/WebGPUChild.h"
+
+namespace mozilla::webgpu {
+
+GPU_IMPL_CYCLE_COLLECTION(RenderBundle, mParent)
+GPU_IMPL_JS_WRAP(RenderBundle)
+
+RenderBundle::RenderBundle(Device* const aParent, RawId aId)
+    : ChildOf(aParent), mId(aId) {
+  // If we happened to finish an encoder twice, the second
+  // bundle should be invalid.
+  if (!mId) {
+    mValid = false;
+  }
+}
+
+RenderBundle::~RenderBundle() { Cleanup(); }
+
+void RenderBundle::Cleanup() {
+  if (mValid && mParent) {
+    mValid = false;
+    auto bridge = mParent->GetBridge();
+    if (bridge && bridge->IsOpen()) {
+      bridge->SendRenderBundleDestroy(mId);
+    }
+  }
+}
+
+}  // namespace mozilla::webgpu
diff --git a/dom/webgpu/RenderBundle.h b/dom/webgpu/RenderBundle.h
new file mode 100644
index 0000000000..0fef6af781
--- /dev/null
+++ b/dom/webgpu/RenderBundle.h
@@ -0,0 +1,32 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef GPU_RenderBundle_H_
+#define GPU_RenderBundle_H_
+
+#include "nsWrapperCache.h"
+#include "ObjectModel.h"
+
+namespace mozilla::webgpu {
+
+class Device;
+
+class RenderBundle final : public ObjectBase, public ChildOf<Device> {
+ public:
+  GPU_DECL_CYCLE_COLLECTION(RenderBundle)
+  GPU_DECL_JS_WRAP(RenderBundle)
+
+  RenderBundle(Device* const aParent, RawId aId);
+
+  const RawId mId;
+
+ private:
+  virtual ~RenderBundle();
+  void Cleanup();
+};
+
+}  // namespace mozilla::webgpu
+
+#endif  // GPU_RenderBundle_H_
diff --git a/dom/webgpu/RenderBundleEncoder.cpp b/dom/webgpu/RenderBundleEncoder.cpp
new file mode 100644
index 0000000000..cb14db1dd0
--- /dev/null
+++ b/dom/webgpu/RenderBundleEncoder.cpp
@@ -0,0 +1,196 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/dom/WebGPUBinding.h"
+#include "RenderBundleEncoder.h"
+
+#include "BindGroup.h"
+#include "Buffer.h"
+#include "RenderBundle.h"
+#include "RenderPipeline.h"
+#include "ipc/WebGPUChild.h"
+#include "mozilla/webgpu/ffi/wgpu.h"
+
+namespace mozilla::webgpu {
+
+GPU_IMPL_CYCLE_COLLECTION(RenderBundleEncoder, mParent, mUsedBindGroups,
+                          mUsedBuffers, mUsedPipelines, mUsedTextureViews)
+GPU_IMPL_JS_WRAP(RenderBundleEncoder)
+
+ffi::WGPURenderBundleEncoder* ScopedFfiBundleTraits::empty() { return nullptr; }
+
+void ScopedFfiBundleTraits::release(ffi::WGPURenderBundleEncoder* raw) {
+  if (raw) {
+    ffi::wgpu_render_bundle_encoder_destroy(raw);
+  }
+}
+
+ffi::WGPURenderBundleEncoder* CreateRenderBundleEncoder(
+    RawId aDeviceId, const dom::GPURenderBundleEncoderDescriptor& aDesc,
+    WebGPUChild* const aBridge) {
+  if (!aBridge->CanSend()) {
+    return nullptr;
+  }
+
+  ffi::WGPURenderBundleEncoderDescriptor desc = {};
+  desc.sample_count = aDesc.mSampleCount;
+
+  webgpu::StringHelper label(aDesc.mLabel);
+  desc.label = label.Get();
+
+  ffi::WGPUTextureFormat depthStencilFormat = {ffi::WGPUTextureFormat_Sentinel};
+  if (aDesc.mDepthStencilFormat.WasPassed()) {
+    WebGPUChild::ConvertTextureFormatRef(aDesc.mDepthStencilFormat.Value(),
+                                         depthStencilFormat);
+    desc.depth_stencil_format = &depthStencilFormat;
+  }
+
+  std::vector<ffi::WGPUTextureFormat> colorFormats = {};
+  for (const auto i : IntegerRange(aDesc.mColorFormats.Length())) {
+    ffi::WGPUTextureFormat format = {ffi::WGPUTextureFormat_Sentinel};
+    WebGPUChild::ConvertTextureFormatRef(aDesc.mColorFormats[i], format);
+    colorFormats.push_back(format);
+  }
+
+  desc.color_formats = colorFormats.data();
+  desc.color_formats_length = colorFormats.size();
+
+  ipc::ByteBuf failureAction;
+  auto* bundle = ffi::wgpu_device_create_render_bundle_encoder(
+      aDeviceId, &desc, ToFFI(&failureAction));
+  // report an error only if the operation failed
+  if (!bundle &&
+      !aBridge->SendDeviceAction(aDeviceId, std::move(failureAction))) {
+    MOZ_CRASH("IPC failure");
+  }
+  return bundle;
+}
+
+RenderBundleEncoder::RenderBundleEncoder(
+    Device* const aParent, WebGPUChild* const aBridge,
+    const dom::GPURenderBundleEncoderDescriptor& aDesc)
+    : ChildOf(aParent),
+      mEncoder(CreateRenderBundleEncoder(aParent->mId, aDesc, aBridge)) {
+  mValid = mEncoder.get() != nullptr;
+}
+
+RenderBundleEncoder::~RenderBundleEncoder() { Cleanup(); }
+
+void RenderBundleEncoder::Cleanup() {
+  if (mValid) {
+    mValid = false;
+  }
+}
+
+void RenderBundleEncoder::SetBindGroup(
+    uint32_t aSlot, const BindGroup& aBindGroup,
+    const dom::Sequence<uint32_t>& aDynamicOffsets) {
+  if (mValid) {
+    mUsedBindGroups.AppendElement(&aBindGroup);
+    ffi::wgpu_render_bundle_set_bind_group(mEncoder, aSlot, aBindGroup.mId,
+                                           aDynamicOffsets.Elements(),
+                                           aDynamicOffsets.Length());
+  }
+}
+
+void RenderBundleEncoder::SetPipeline(const RenderPipeline& aPipeline) {
+  if (mValid) {
+    mUsedPipelines.AppendElement(&aPipeline);
+    ffi::wgpu_render_bundle_set_pipeline(mEncoder, aPipeline.mId);
+  }
+}
+
+void RenderBundleEncoder::SetIndexBuffer(
+    const Buffer& aBuffer, const dom::GPUIndexFormat& aIndexFormat,
+    uint64_t aOffset, uint64_t aSize) {
+  if (mValid) {
+    mUsedBuffers.AppendElement(&aBuffer);
+    const auto iformat = aIndexFormat == dom::GPUIndexFormat::Uint32
+                             ? ffi::WGPUIndexFormat_Uint32
+                             : ffi::WGPUIndexFormat_Uint16;
+    ffi::wgpu_render_bundle_set_index_buffer(mEncoder, aBuffer.mId, iformat,
+                                             aOffset, aSize);
+  }
+}
+
+void RenderBundleEncoder::SetVertexBuffer(uint32_t aSlot, const Buffer& aBuffer,
+                                          uint64_t aOffset, uint64_t aSize) {
+  if (mValid) {
+    mUsedBuffers.AppendElement(&aBuffer);
+    ffi::wgpu_render_bundle_set_vertex_buffer(mEncoder, aSlot, aBuffer.mId,
+                                              aOffset, aSize);
+  }
+}
+
+void RenderBundleEncoder::Draw(uint32_t aVertexCount, uint32_t aInstanceCount,
+                               uint32_t aFirstVertex, uint32_t aFirstInstance) {
+  if (mValid) {
+    ffi::wgpu_render_bundle_draw(mEncoder, aVertexCount, aInstanceCount,
+                                 aFirstVertex, aFirstInstance);
+  }
+}
+
+void RenderBundleEncoder::DrawIndexed(uint32_t aIndexCount,
+                                      uint32_t aInstanceCount,
+                                      uint32_t aFirstIndex, int32_t aBaseVertex,
+                                      uint32_t aFirstInstance) {
+  if (mValid) {
+    ffi::wgpu_render_bundle_draw_indexed(mEncoder, aIndexCount, aInstanceCount,
+                                         aFirstIndex, aBaseVertex,
+                                         aFirstInstance);
+  }
+}
+
+void RenderBundleEncoder::DrawIndirect(const Buffer& aIndirectBuffer,
+                                       uint64_t aIndirectOffset) {
+  if (mValid) {
+    ffi::wgpu_render_bundle_draw_indirect(mEncoder, aIndirectBuffer.mId,
+                                          aIndirectOffset);
+  }
+}
+
+void RenderBundleEncoder::DrawIndexedIndirect(const Buffer& aIndirectBuffer,
+                                              uint64_t aIndirectOffset) {
+  if (mValid) {
+    ffi::wgpu_render_bundle_draw_indexed_indirect(mEncoder, aIndirectBuffer.mId,
+                                                  aIndirectOffset);
+  }
+}
+
+void RenderBundleEncoder::PushDebugGroup(const nsAString& aString) {
+  if (mValid) {
+    const NS_ConvertUTF16toUTF8 utf8(aString);
+    ffi::wgpu_render_bundle_push_debug_group(mEncoder, utf8.get());
+  }
+}
+void RenderBundleEncoder::PopDebugGroup() {
+  if (mValid) {
+    ffi::wgpu_render_bundle_pop_debug_group(mEncoder);
+  }
+}
+void RenderBundleEncoder::InsertDebugMarker(const nsAString& aString) {
+  if (mValid) {
+    const NS_ConvertUTF16toUTF8 utf8(aString);
+    ffi::wgpu_render_bundle_insert_debug_marker(mEncoder, utf8.get());
+  }
+}
+
+already_AddRefed<RenderBundle> RenderBundleEncoder::Finish(
+    const dom::GPURenderBundleDescriptor& aDesc) {
+  RawId id = 0;
+  if (mValid) {
+    mValid = false;
+    auto bridge = mParent->GetBridge();
+    if (bridge && bridge->CanSend()) {
+      auto* encoder = mEncoder.forget();
+      MOZ_ASSERT(encoder);
+      id = bridge->RenderBundleEncoderFinish(*encoder, mParent->mId, aDesc);
+    }
+  }
+  RefPtr<RenderBundle> bundle = new RenderBundle(mParent, id);
+  return bundle.forget();
+}
+
+}  // namespace mozilla::webgpu
diff --git a/dom/webgpu/RenderBundleEncoder.h b/dom/webgpu/RenderBundleEncoder.h
new file mode 100644
index 0000000000..f8bfebe21e
--- /dev/null
+++ b/dom/webgpu/RenderBundleEncoder.h
@@ -0,0 +1,77 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef GPU_RenderBundleEncoder_H_
+#define GPU_RenderBundleEncoder_H_
+
+#include "mozilla/Scoped.h"
+#include "mozilla/dom/TypedArray.h"
+#include "ObjectModel.h"
+
+namespace mozilla::webgpu {
+namespace ffi {
+struct WGPURenderBundleEncoder;
+}  // namespace ffi
+
+class Device;
+class RenderBundle;
+
+struct ScopedFfiBundleTraits {
+  using type = ffi::WGPURenderBundleEncoder*;
+  static type empty();
+  static void release(type raw);
+};
+
+class RenderBundleEncoder final : public ObjectBase, public ChildOf<Device> {
+ public:
+  GPU_DECL_CYCLE_COLLECTION(RenderBundleEncoder)
+  GPU_DECL_JS_WRAP(RenderBundleEncoder)
+
+  RenderBundleEncoder(Device* const aParent, WebGPUChild* const aBridge,
+                      const dom::GPURenderBundleEncoderDescriptor& aDesc);
+
+ private:
+  ~RenderBundleEncoder();
+  void Cleanup();
+
+  Scoped<ScopedFfiBundleTraits> mEncoder;
+  // keep all the used objects alive while the encoder is finished
+  nsTArray<RefPtr<const BindGroup>> mUsedBindGroups;
+  nsTArray<RefPtr<const Buffer>> mUsedBuffers;
+  nsTArray<RefPtr<const RenderPipeline>> mUsedPipelines;
+  nsTArray<RefPtr<const TextureView>> mUsedTextureViews;
+
+ public:
+  // programmable pass encoder
+  void SetBindGroup(uint32_t aSlot, const BindGroup& aBindGroup,
+                    const dom::Sequence<uint32_t>& aDynamicOffsets);
+  // render encoder base
+  void SetPipeline(const RenderPipeline& aPipeline);
+  void SetIndexBuffer(const Buffer& aBuffer,
+                      const dom::GPUIndexFormat& aIndexFormat, uint64_t aOffset,
+                      uint64_t aSize);
+  void SetVertexBuffer(uint32_t aSlot, const Buffer& aBuffer, uint64_t aOffset,
+                       uint64_t aSize);
+  void Draw(uint32_t aVertexCount, uint32_t aInstanceCount,
+            uint32_t aFirstVertex, uint32_t aFirstInstance);
+  void DrawIndexed(uint32_t aIndexCount, uint32_t aInstanceCount,
+                   uint32_t aFirstIndex, int32_t aBaseVertex,
+                   uint32_t aFirstInstance);
+  void DrawIndirect(const Buffer& aIndirectBuffer, uint64_t aIndirectOffset);
+  void DrawIndexedIndirect(const Buffer& aIndirectBuffer,
+                           uint64_t aIndirectOffset);
+
+  void PushDebugGroup(const nsAString& aString);
+  void PopDebugGroup();
+  void InsertDebugMarker(const nsAString& aString);
+
+  // self
+  already_AddRefed<RenderBundle> Finish(
+      const dom::GPURenderBundleDescriptor& aDesc);
+};
+
+}  // namespace mozilla::webgpu
+
+#endif  // GPU_RenderBundleEncoder_H_
diff --git a/dom/webgpu/RenderPassEncoder.cpp b/dom/webgpu/RenderPassEncoder.cpp
new file mode 100644
index 0000000000..4cc2b9fbf3
--- /dev/null
+++ b/dom/webgpu/RenderPassEncoder.cpp
@@ -0,0 +1,306 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/dom/WebGPUBinding.h"
+#include "RenderPassEncoder.h"
+#include "BindGroup.h"
+#include "CommandEncoder.h"
+#include "RenderBundle.h"
+#include "RenderPipeline.h"
+#include "mozilla/webgpu/ffi/wgpu.h"
+
+namespace mozilla::webgpu {
+
+GPU_IMPL_CYCLE_COLLECTION(RenderPassEncoder, mParent, mUsedBindGroups,
+                          mUsedBuffers, mUsedPipelines, mUsedTextureViews,
+                          mUsedRenderBundles)
+GPU_IMPL_JS_WRAP(RenderPassEncoder)
+
+ffi::WGPURenderPass* ScopedFfiRenderTraits::empty() { return nullptr; }
+
+void ScopedFfiRenderTraits::release(ffi::WGPURenderPass* raw) {
+  if (raw) {
+    ffi::wgpu_render_pass_destroy(raw);
+  }
+}
+
+ffi::WGPULoadOp ConvertLoadOp(const dom::GPULoadOp& aOp) {
+  switch (aOp) {
+    case dom::GPULoadOp::Load:
+      return ffi::WGPULoadOp_Load;
+    default:
+      MOZ_CRASH("Unexpected load op");
+  }
+}
+
+ffi::WGPUStoreOp ConvertStoreOp(const dom::GPUStoreOp& aOp) {
+  switch (aOp) {
+    case dom::GPUStoreOp::Store:
+      return ffi::WGPUStoreOp_Store;
+    case dom::GPUStoreOp::Discard:
+      return ffi::WGPUStoreOp_Discard;
+    default:
+      MOZ_CRASH("Unexpected load op");
+  }
+}
+
+ffi::WGPUColor ConvertColor(const dom::GPUColorDict& aColor) {
+  ffi::WGPUColor color = {aColor.mR, aColor.mG, aColor.mB, aColor.mA};
+  return color;
+}
+
+ffi::WGPURenderPass* BeginRenderPass(
+    CommandEncoder* const aParent, const dom::GPURenderPassDescriptor& aDesc) {
+  ffi::WGPURenderPassDescriptor desc = {};
+
+  webgpu::StringHelper label(aDesc.mLabel);
+  desc.label = label.Get();
+
+  ffi::WGPURenderPassDepthStencilAttachment dsDesc = {};
+  if (aDesc.mDepthStencilAttachment.WasPassed()) {
+    const auto& dsa = aDesc.mDepthStencilAttachment.Value();
+    dsDesc.view = dsa.mView->mId;
+
+    if (dsa.mDepthLoadValue.IsFloat()) {
+      dsDesc.depth.load_op = ffi::WGPULoadOp_Clear;
+      dsDesc.depth.clear_value = dsa.mDepthLoadValue.GetAsFloat();
+    }
+    if (dsa.mDepthLoadValue.IsGPULoadOp()) {
+      dsDesc.depth.load_op =
+          ConvertLoadOp(dsa.mDepthLoadValue.GetAsGPULoadOp());
+    }
+    dsDesc.depth.store_op = ConvertStoreOp(dsa.mDepthStoreOp);
+
+    if (dsa.mStencilLoadValue.IsRangeEnforcedUnsignedLong()) {
+      dsDesc.stencil.load_op = ffi::WGPULoadOp_Clear;
+      dsDesc.stencil.clear_value =
+          dsa.mStencilLoadValue.GetAsRangeEnforcedUnsignedLong();
+    }
+    if (dsa.mStencilLoadValue.IsGPULoadOp()) {
+      dsDesc.stencil.load_op =
+          ConvertLoadOp(dsa.mStencilLoadValue.GetAsGPULoadOp());
+    }
+    dsDesc.stencil.store_op = ConvertStoreOp(dsa.mStencilStoreOp);
+
+    desc.depth_stencil_attachment = &dsDesc;
+  }
+
+  if (aDesc.mColorAttachments.Length() > WGPUMAX_COLOR_ATTACHMENTS) {
+    aParent->GetDevice()->GenerateError(nsLiteralCString(
+        "Too many color attachments in GPURenderPassDescriptor"));
+    return nullptr;
+  }
+
+  std::array<ffi::WGPURenderPassColorAttachment, WGPUMAX_COLOR_ATTACHMENTS>
+      colorDescs = {};
+  desc.color_attachments = colorDescs.data();
+  desc.color_attachments_length = aDesc.mColorAttachments.Length();
+
+  for (size_t i = 0; i < aDesc.mColorAttachments.Length(); ++i) {
+    const auto& ca = aDesc.mColorAttachments[i];
+    ffi::WGPURenderPassColorAttachment& cd = colorDescs[i];
+    cd.view = ca.mView->mId;
+    cd.channel.store_op = ConvertStoreOp(ca.mStoreOp);
+
+    if (ca.mResolveTarget.WasPassed()) {
+      cd.resolve_target = ca.mResolveTarget.Value().mId;
+    }
+    if (ca.mLoadValue.IsGPULoadOp()) {
+      cd.channel.load_op = ConvertLoadOp(ca.mLoadValue.GetAsGPULoadOp());
+    } else {
+      cd.channel.load_op = ffi::WGPULoadOp_Clear;
+      if (ca.mLoadValue.IsDoubleSequence()) {
+        const auto& seq = ca.mLoadValue.GetAsDoubleSequence();
+        if (seq.Length() >= 1) {
+          cd.channel.clear_value.r = seq[0];
+        }
+        if (seq.Length() >= 2) {
+          cd.channel.clear_value.g = seq[1];
+        }
+        if (seq.Length() >= 3) {
+          cd.channel.clear_value.b = seq[2];
+        }
+        if (seq.Length() >= 4) {
+          cd.channel.clear_value.a = seq[3];
+        }
+      }
+      if (ca.mLoadValue.IsGPUColorDict()) {
+        cd.channel.clear_value =
+            ConvertColor(ca.mLoadValue.GetAsGPUColorDict());
+      }
+    }
+  }
+
+  return ffi::wgpu_command_encoder_begin_render_pass(aParent->mId, &desc);
+}
+
+RenderPassEncoder::RenderPassEncoder(CommandEncoder* const aParent,
+                                     const dom::GPURenderPassDescriptor& aDesc)
+    : ChildOf(aParent), mPass(BeginRenderPass(aParent, aDesc)) {
+  if (!mPass) {
+    mValid = false;
+    return;
+  }
+
+  for (const auto& at : aDesc.mColorAttachments) {
+    mUsedTextureViews.AppendElement(at.mView);
+  }
+  if (aDesc.mDepthStencilAttachment.WasPassed()) {
+    mUsedTextureViews.AppendElement(
+        aDesc.mDepthStencilAttachment.Value().mView);
+  }
+}
+
+RenderPassEncoder::~RenderPassEncoder() {
+  if (mValid) {
+    mValid = false;
+  }
+}
+
+void RenderPassEncoder::SetBindGroup(
+    uint32_t aSlot, const BindGroup& aBindGroup,
+    const dom::Sequence<uint32_t>& aDynamicOffsets) {
+  if (mValid) {
+    mUsedBindGroups.AppendElement(&aBindGroup);
+    ffi::wgpu_render_pass_set_bind_group(mPass, aSlot, aBindGroup.mId,
+                                         aDynamicOffsets.Elements(),
+                                         aDynamicOffsets.Length());
+  }
+}
+
+void RenderPassEncoder::SetPipeline(const RenderPipeline& aPipeline) {
+  if (mValid) {
+    mUsedPipelines.AppendElement(&aPipeline);
+    ffi::wgpu_render_pass_set_pipeline(mPass, aPipeline.mId);
+  }
+}
+
+void RenderPassEncoder::SetIndexBuffer(const Buffer& aBuffer,
+                                       const dom::GPUIndexFormat& aIndexFormat,
+                                       uint64_t aOffset, uint64_t aSize) {
+  if (mValid) {
+    mUsedBuffers.AppendElement(&aBuffer);
+    const auto iformat = aIndexFormat == dom::GPUIndexFormat::Uint32
+                             ? ffi::WGPUIndexFormat_Uint32
+                             : ffi::WGPUIndexFormat_Uint16;
+    ffi::wgpu_render_pass_set_index_buffer(mPass, aBuffer.mId, iformat, aOffset,
+                                           aSize);
+  }
+}
+
+void RenderPassEncoder::SetVertexBuffer(uint32_t aSlot, const Buffer& aBuffer,
+                                        uint64_t aOffset, uint64_t aSize) {
+  if (mValid) {
+    mUsedBuffers.AppendElement(&aBuffer);
+    ffi::wgpu_render_pass_set_vertex_buffer(mPass, aSlot, aBuffer.mId, aOffset,
+                                            aSize);
+  }
+}
+
+void RenderPassEncoder::Draw(uint32_t aVertexCount, uint32_t aInstanceCount,
+                             uint32_t aFirstVertex, uint32_t aFirstInstance) {
+  if (mValid) {
+    ffi::wgpu_render_pass_draw(mPass, aVertexCount, aInstanceCount,
+                               aFirstVertex, aFirstInstance);
+  }
+}
+
+void RenderPassEncoder::DrawIndexed(uint32_t aIndexCount,
+                                    uint32_t aInstanceCount,
+                                    uint32_t aFirstIndex, int32_t aBaseVertex,
+                                    uint32_t aFirstInstance) {
+  if (mValid) {
+    ffi::wgpu_render_pass_draw_indexed(mPass, aIndexCount, aInstanceCount,
+                                       aFirstIndex, aBaseVertex,
+                                       aFirstInstance);
+  }
+}
+
+void RenderPassEncoder::DrawIndirect(const Buffer& aIndirectBuffer,
+                                     uint64_t aIndirectOffset) {
+  if (mValid) {
+    ffi::wgpu_render_pass_draw_indirect(mPass, aIndirectBuffer.mId,
+                                        aIndirectOffset);
+  }
+}
+
+void RenderPassEncoder::DrawIndexedIndirect(const Buffer& aIndirectBuffer,
+                                            uint64_t aIndirectOffset) {
+  if (mValid) {
+    ffi::wgpu_render_pass_draw_indexed_indirect(mPass, aIndirectBuffer.mId,
+                                                aIndirectOffset);
+  }
+}
+
+void RenderPassEncoder::SetViewport(float x, float y, float width, float height,
+                                    float minDepth, float maxDepth) {
+  if (mValid) {
+    ffi::wgpu_render_pass_set_viewport(mPass, x, y, width, height, minDepth,
+                                       maxDepth);
+  }
+}
+
+void RenderPassEncoder::SetScissorRect(uint32_t x, uint32_t y, uint32_t width,
+                                       uint32_t height) {
+  if (mValid) {
+    ffi::wgpu_render_pass_set_scissor_rect(mPass, x, y, width, height);
+  }
+}
+
+void RenderPassEncoder::SetBlendConstant(
+    const dom::DoubleSequenceOrGPUColorDict& color) {
+  if (mValid) {
+    ffi::WGPUColor aColor = ConvertColor(color.GetAsGPUColorDict());
+    ffi::wgpu_render_pass_set_blend_constant(mPass, &aColor);
+  }
+}
+
+void RenderPassEncoder::SetStencilReference(uint32_t reference) {
+  if (mValid) {
+    ffi::wgpu_render_pass_set_stencil_reference(mPass, reference);
+  }
+}
+
+void RenderPassEncoder::ExecuteBundles(
+    const dom::Sequence<OwningNonNull<RenderBundle>>& aBundles) {
+  if (mValid) {
+    nsTArray<ffi::WGPURenderBundleId> renderBundles(aBundles.Length());
+    for (const auto& bundle : aBundles) {
+      mUsedRenderBundles.AppendElement(bundle);
+      renderBundles.AppendElement(bundle->mId);
+    }
+    ffi::wgpu_render_pass_execute_bundles(mPass, renderBundles.Elements(),
+                                          renderBundles.Length());
+  }
+}
+
+void RenderPassEncoder::PushDebugGroup(const nsAString& aString) {
+  if (mValid) {
+    const NS_ConvertUTF16toUTF8 utf8(aString);
+    ffi::wgpu_render_pass_push_debug_group(mPass, utf8.get(), 0);
+  }
+}
+void RenderPassEncoder::PopDebugGroup() {
+  if (mValid) {
+    ffi::wgpu_render_pass_pop_debug_group(mPass);
+  }
+}
+void RenderPassEncoder::InsertDebugMarker(const nsAString& aString) {
+  if (mValid) {
+    const NS_ConvertUTF16toUTF8 utf8(aString);
+    ffi::wgpu_render_pass_insert_debug_marker(mPass, utf8.get(), 0);
+  }
+}
+
+void RenderPassEncoder::EndPass(ErrorResult& aRv) {
+  if (mValid) {
+    mValid = false;
+    auto* pass = mPass.forget();
+    MOZ_ASSERT(pass);
+    mParent->EndRenderPass(*pass, aRv);
+  }
+}
+
+}  // namespace mozilla::webgpu
diff --git a/dom/webgpu/RenderPassEncoder.h b/dom/webgpu/RenderPassEncoder.h
new file mode 100644
index 0000000000..f94d3c750a
--- /dev/null
+++ b/dom/webgpu/RenderPassEncoder.h
@@ -0,0 +1,104 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef GPU_RenderPassEncoder_H_
+#define GPU_RenderPassEncoder_H_
+
+#include "mozilla/Scoped.h"
+#include "mozilla/dom/TypedArray.h"
+#include "ObjectModel.h"
+
+namespace mozilla {
+class ErrorResult;
+
+namespace dom {
+class DoubleSequenceOrGPUColorDict;
+struct GPURenderPassDescriptor;
+template <typename T>
+class Sequence;
+namespace binding_detail {
+template <typename T>
+class AutoSequence;
+}  // namespace binding_detail
+}  // namespace dom
+namespace webgpu {
+namespace ffi {
+struct WGPURenderPass;
+}  // namespace ffi
+
+class BindGroup;
+class Buffer;
+class CommandEncoder;
+class RenderBundle;
+class RenderPipeline;
+class TextureView;
+
+struct ScopedFfiRenderTraits {
+  using type = ffi::WGPURenderPass*;
+  static type empty();
+  static void release(type raw);
+};
+
+class RenderPassEncoder final : public ObjectBase,
+                                public ChildOf<CommandEncoder> {
+ public:
+  GPU_DECL_CYCLE_COLLECTION(RenderPassEncoder)
+  GPU_DECL_JS_WRAP(RenderPassEncoder)
+
+  RenderPassEncoder(CommandEncoder* const aParent,
+                    const dom::GPURenderPassDescriptor& aDesc);
+
+ protected:
+  virtual ~RenderPassEncoder();
+  void Cleanup() {}
+
+  Scoped<ScopedFfiRenderTraits> mPass;
+  // keep all the used objects alive while the pass is recorded
+  nsTArray<RefPtr<const BindGroup>> mUsedBindGroups;
+  nsTArray<RefPtr<const Buffer>> mUsedBuffers;
+  nsTArray<RefPtr<const RenderPipeline>> mUsedPipelines;
+  nsTArray<RefPtr<const TextureView>> mUsedTextureViews;
+  nsTArray<RefPtr<const RenderBundle>> mUsedRenderBundles;
+
+ public:
+  // programmable pass encoder
+  void SetBindGroup(uint32_t aSlot, const BindGroup& aBindGroup,
+                    const dom::Sequence<uint32_t>& aDynamicOffsets);
+  // render encoder base
+  void SetPipeline(const RenderPipeline& aPipeline);
+  void SetIndexBuffer(const Buffer& aBuffer,
+                      const dom::GPUIndexFormat& aIndexFormat, uint64_t aOffset,
+                      uint64_t aSize);
+  void SetVertexBuffer(uint32_t aSlot, const Buffer& aBuffer, uint64_t aOffset,
+                       uint64_t aSize);
+  void Draw(uint32_t aVertexCount, uint32_t aInstanceCount,
+            uint32_t aFirstVertex, uint32_t aFirstInstance);
+  void DrawIndexed(uint32_t aIndexCount, uint32_t aInstanceCount,
+                   uint32_t aFirstIndex, int32_t aBaseVertex,
+                   uint32_t aFirstInstance);
+  void DrawIndirect(const Buffer& aIndirectBuffer, uint64_t aIndirectOffset);
+  void DrawIndexedIndirect(const Buffer& aIndirectBuffer,
+                           uint64_t aIndirectOffset);
+  // self
+  void SetViewport(float x, float y, float width, float height, float minDepth,
+                   float maxDepth);
+  void SetScissorRect(uint32_t x, uint32_t y, uint32_t width, uint32_t height);
+  void SetBlendConstant(const dom::DoubleSequenceOrGPUColorDict& color);
+  void SetStencilReference(uint32_t reference);
+
+  void PushDebugGroup(const nsAString& aString);
+  void PopDebugGroup();
+  void InsertDebugMarker(const nsAString& aString);
+
+  void ExecuteBundles(
+      const dom::Sequence<OwningNonNull<RenderBundle>>& aBundles);
+
+  void EndPass(ErrorResult& aRv);
+};
+
+}  // namespace webgpu
+}  // namespace mozilla
+
+#endif  // GPU_RenderPassEncoder_H_
diff --git a/dom/webgpu/RenderPipeline.cpp b/dom/webgpu/RenderPipeline.cpp
new file mode 100644
index 0000000000..d99ac87c4a
--- /dev/null
+++ b/dom/webgpu/RenderPipeline.cpp
@@ -0,0 +1,50 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "RenderPipeline.h"
+
+#include "Device.h"
+#include "ipc/WebGPUChild.h"
+#include "mozilla/dom/WebGPUBinding.h"
+
+namespace mozilla::webgpu {
+
+GPU_IMPL_CYCLE_COLLECTION(RenderPipeline, mParent)
+GPU_IMPL_JS_WRAP(RenderPipeline)
+
+RenderPipeline::RenderPipeline(Device* const aParent, RawId aId,
+                               RawId aImplicitPipelineLayoutId,
+                               nsTArray<RawId>&& aImplicitBindGroupLayoutIds)
+    : ChildOf(aParent),
+      mImplicitPipelineLayoutId(aImplicitPipelineLayoutId),
+      mImplicitBindGroupLayoutIds(std::move(aImplicitBindGroupLayoutIds)),
+      mId(aId) {}
+
+RenderPipeline::~RenderPipeline() { Cleanup(); }
+
+void RenderPipeline::Cleanup() {
+  if (mValid && mParent) {
+    mValid = false;
+    auto bridge = mParent->GetBridge();
+    if (bridge && bridge->IsOpen()) {
+      bridge->SendRenderPipelineDestroy(mId);
+      if (mImplicitPipelineLayoutId) {
+        bridge->SendImplicitLayoutDestroy(mImplicitPipelineLayoutId,
+                                          mImplicitBindGroupLayoutIds);
+      }
+    }
+  }
+}
+
+already_AddRefed<BindGroupLayout> RenderPipeline::GetBindGroupLayout(
+    uint32_t index) const {
+  const RawId id = index < mImplicitBindGroupLayoutIds.Length()
+                       ? mImplicitBindGroupLayoutIds[index]
+                       : 0;
+  RefPtr<BindGroupLayout> object = new BindGroupLayout(mParent, id, false);
+  return object.forget();
+}
+
+}  // namespace mozilla::webgpu
diff --git a/dom/webgpu/RenderPipeline.h b/dom/webgpu/RenderPipeline.h
new file mode 100644
index 0000000000..859259da27
--- /dev/null
+++ b/dom/webgpu/RenderPipeline.h
@@ -0,0 +1,41 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef GPU_RenderPipeline_H_
+#define GPU_RenderPipeline_H_
+
+#include "nsWrapperCache.h"
+#include "ObjectModel.h"
+#include "mozilla/webgpu/WebGPUTypes.h"
+#include "nsTArray.h"
+
+namespace mozilla::webgpu {
+
+class BindGroupLayout;
+class Device;
+
+class RenderPipeline final : public ObjectBase, public ChildOf<Device> {
+  const RawId mImplicitPipelineLayoutId;
+  const nsTArray<RawId> mImplicitBindGroupLayoutIds;
+
+ public:
+  GPU_DECL_CYCLE_COLLECTION(RenderPipeline)
+  GPU_DECL_JS_WRAP(RenderPipeline)
+
+  const RawId mId;
+
+  RenderPipeline(Device* const aParent, RawId aId,
+                 RawId aImplicitPipelineLayoutId,
+                 nsTArray<RawId>&& aImplicitBindGroupLayoutIds);
+  already_AddRefed<BindGroupLayout> GetBindGroupLayout(uint32_t index) const;
+
+ private:
+  virtual ~RenderPipeline();
+  void Cleanup();
+};
+
+}  // namespace mozilla::webgpu
+
+#endif  // GPU_RenderPipeline_H_
diff --git a/dom/webgpu/Sampler.cpp b/dom/webgpu/Sampler.cpp
new file mode 100644
index 0000000000..9a3b90c4dd
--- /dev/null
+++ b/dom/webgpu/Sampler.cpp
@@ -0,0 +1,32 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/dom/WebGPUBinding.h"
+#include "Sampler.h"
+#include "ipc/WebGPUChild.h"
+
+#include "Device.h"
+
+namespace mozilla::webgpu {
+
+GPU_IMPL_CYCLE_COLLECTION(Sampler, mParent)
+GPU_IMPL_JS_WRAP(Sampler)
+
+Sampler::Sampler(Device* const aParent, RawId aId)
+    : ChildOf(aParent), mId(aId) {}
+
+Sampler::~Sampler() { Cleanup(); }
+
+void Sampler::Cleanup() {
+  if (mValid && mParent) {
+    mValid = false;
+    auto bridge = mParent->GetBridge();
+    if (bridge && bridge->IsOpen()) {
+      bridge->SendSamplerDestroy(mId);
+    }
+  }
+}
+
+}  // namespace mozilla::webgpu
diff --git a/dom/webgpu/Sampler.h b/dom/webgpu/Sampler.h
new file mode 100644
index 0000000000..02e01982cd
--- /dev/null
+++ b/dom/webgpu/Sampler.h
@@ -0,0 +1,33 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef GPU_SAMPLER_H_
+#define GPU_SAMPLER_H_
+
+#include "mozilla/webgpu/WebGPUTypes.h"
+#include "nsWrapperCache.h"
+#include "ObjectModel.h"
+
+namespace mozilla::webgpu {
+
+class Device;
+
+class Sampler final : public ObjectBase, public ChildOf<Device> {
+ public:
+  GPU_DECL_CYCLE_COLLECTION(Sampler)
+  GPU_DECL_JS_WRAP(Sampler)
+
+  Sampler(Device* const aParent, RawId aId);
+
+  const RawId mId;
+
+ private:
+  virtual ~Sampler();
+  void Cleanup();
+};
+
+}  // namespace mozilla::webgpu
+
+#endif  // GPU_SAMPLER_H_
diff --git a/dom/webgpu/ShaderModule.cpp b/dom/webgpu/ShaderModule.cpp
new file mode 100644
index 0000000000..c415fa732a
--- /dev/null
+++ b/dom/webgpu/ShaderModule.cpp
@@ -0,0 +1,40 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/dom/WebGPUBinding.h"
+#include "mozilla/dom/Promise.h"
+#include "ShaderModule.h"
+#include "CompilationInfo.h"
+#include "ipc/WebGPUChild.h"
+
+#include "Device.h"
+
+namespace mozilla::webgpu {
+
+GPU_IMPL_CYCLE_COLLECTION(ShaderModule, mParent)
+GPU_IMPL_JS_WRAP(ShaderModule)
+
+ShaderModule::ShaderModule(Device* const aParent, RawId aId,
+                           const RefPtr<dom::Promise>& aCompilationInfo)
+    : ChildOf(aParent), mId(aId), mCompilationInfo(aCompilationInfo) {}
+
+ShaderModule::~ShaderModule() { Cleanup(); }
+
+void ShaderModule::Cleanup() {
+  if (mValid && mParent) {
+    mValid = false;
+    auto bridge = mParent->GetBridge();
+    if (bridge && bridge->IsOpen()) {
+      bridge->SendShaderModuleDestroy(mId);
+    }
+  }
+}
+
+already_AddRefed<dom::Promise> ShaderModule::CompilationInfo(ErrorResult& aRv) {
+  RefPtr<dom::Promise> tmp = mCompilationInfo;
+  return tmp.forget();
+}
+
+}  // namespace mozilla::webgpu
diff --git a/dom/webgpu/ShaderModule.h b/dom/webgpu/ShaderModule.h
new file mode 100644
index 0000000000..08eaf2b804
--- /dev/null
+++ b/dom/webgpu/ShaderModule.h
@@ -0,0 +1,40 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef GPU_ShaderModule_H_
+#define GPU_ShaderModule_H_
+
+#include "mozilla/webgpu/WebGPUTypes.h"
+#include "nsWrapperCache.h"
+#include "ObjectModel.h"
+
+namespace mozilla::webgpu {
+
+class CompilationInfo;
+class Device;
+
+class ShaderModule final : public ObjectBase, public ChildOf<Device> {
+ public:
+  GPU_DECL_CYCLE_COLLECTION(
+      ShaderModule)  // TODO: kvark's WIP patch was passing CompilationInfo as a
+                     // second argument here.
+  GPU_DECL_JS_WRAP(ShaderModule)
+
+  ShaderModule(Device* const aParent, RawId aId,
+               const RefPtr<dom::Promise>& aCompilationInfo);
+  already_AddRefed<dom::Promise> CompilationInfo(ErrorResult& aRv);
+
+  const RawId mId;
+
+ private:
+  virtual ~ShaderModule();
+  void Cleanup();
+
+  RefPtr<dom::Promise> mCompilationInfo;
+};
+
+}  // namespace mozilla::webgpu
+
+#endif  // GPU_ShaderModule_H_
diff --git a/dom/webgpu/SupportedFeatures.cpp b/dom/webgpu/SupportedFeatures.cpp
new file mode 100644
index 0000000000..072705892e
--- /dev/null
+++ b/dom/webgpu/SupportedFeatures.cpp
@@ -0,0 +1,18 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "SupportedFeatures.h"
+#include "Adapter.h"
+#include "mozilla/dom/WebGPUBinding.h"
+
+namespace mozilla::webgpu {
+
+GPU_IMPL_CYCLE_COLLECTION(SupportedFeatures, mParent)
+GPU_IMPL_JS_WRAP(SupportedFeatures)
+
+SupportedFeatures::SupportedFeatures(Adapter* const aParent)
+    : ChildOf(aParent) {}
+
+}  // namespace mozilla::webgpu
diff --git a/dom/webgpu/SupportedFeatures.h b/dom/webgpu/SupportedFeatures.h
new file mode 100644
index 0000000000..5c12ac8d3c
--- /dev/null
+++ b/dom/webgpu/SupportedFeatures.h
@@ -0,0 +1,29 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef GPU_SupportedFeatures_H_
+#define GPU_SupportedFeatures_H_
+
+#include "nsWrapperCache.h"
+#include "ObjectModel.h"
+
+namespace mozilla::webgpu {
+class Adapter;
+
+class SupportedFeatures final : public nsWrapperCache, public ChildOf<Adapter> {
+ public:
+  GPU_DECL_CYCLE_COLLECTION(SupportedFeatures)
+  GPU_DECL_JS_WRAP(SupportedFeatures)
+
+  explicit SupportedFeatures(Adapter* const aParent);
+
+ private:
+  ~SupportedFeatures() = default;
+  void Cleanup() {}
+};
+
+}  // namespace mozilla::webgpu
+
+#endif  // GPU_SupportedFeatures_H_
diff --git a/dom/webgpu/SupportedLimits.cpp b/dom/webgpu/SupportedLimits.cpp
new file mode 100644
index 0000000000..ea37dec206
--- /dev/null
+++ b/dom/webgpu/SupportedLimits.cpp
@@ -0,0 +1,101 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "SupportedLimits.h"
+#include "Adapter.h"
+#include "mozilla/dom/WebGPUBinding.h"
+#include "mozilla/webgpu/ffi/wgpu.h"
+
+namespace mozilla::webgpu {
+
+GPU_IMPL_CYCLE_COLLECTION(SupportedLimits, mParent)
+GPU_IMPL_JS_WRAP(SupportedLimits)
+
+SupportedLimits::SupportedLimits(Adapter* const aParent,
+                                 UniquePtr<ffi::WGPULimits>&& aLimits)
+    : ChildOf(aParent), mLimits(std::move(aLimits)) {}
+
+SupportedLimits::~SupportedLimits() = default;
+
+uint32_t SupportedLimits::MaxTextureDimension1D() const {
+  return mLimits->max_texture_dimension_1d;
+}
+uint32_t SupportedLimits::MaxTextureDimension2D() const {
+  return mLimits->max_texture_dimension_2d;
+}
+uint32_t SupportedLimits::MaxTextureDimension3D() const {
+  return mLimits->max_texture_dimension_3d;
+}
+uint32_t SupportedLimits::MaxTextureArrayLayers() const {
+  return mLimits->max_texture_array_layers;
+}
+uint32_t SupportedLimits::MaxBindGroups() const {
+  return mLimits->max_bind_groups;
+}
+uint32_t SupportedLimits::MaxDynamicUniformBuffersPerPipelineLayout() const {
+  return mLimits->max_dynamic_uniform_buffers_per_pipeline_layout;
+}
+uint32_t SupportedLimits::MaxDynamicStorageBuffersPerPipelineLayout() const {
+  return mLimits->max_dynamic_storage_buffers_per_pipeline_layout;
+}
+uint32_t SupportedLimits::MaxSampledTexturesPerShaderStage() const {
+  return mLimits->max_sampled_textures_per_shader_stage;
+}
+uint32_t SupportedLimits::MaxSamplersPerShaderStage() const {
+  return mLimits->max_samplers_per_shader_stage;
+}
+uint32_t SupportedLimits::MaxStorageBuffersPerShaderStage() const {
+  return mLimits->max_storage_buffers_per_shader_stage;
+}
+uint32_t SupportedLimits::MaxStorageTexturesPerShaderStage() const {
+  return mLimits->max_storage_textures_per_shader_stage;
+}
+uint32_t SupportedLimits::MaxUniformBuffersPerShaderStage() const {
+  return mLimits->max_uniform_buffers_per_shader_stage;
+}
+uint32_t SupportedLimits::MaxUniformBufferBindingSize() const {
+  return mLimits->max_uniform_buffer_binding_size;
+}
+uint32_t SupportedLimits::MaxStorageBufferBindingSize() const {
+  return mLimits->max_storage_buffer_binding_size;
+}
+uint32_t SupportedLimits::MinUniformBufferOffsetAlignment() const {
+  return mLimits->min_uniform_buffer_offset_alignment;
+}
+uint32_t SupportedLimits::MinStorageBufferOffsetAlignment() const {
+  return mLimits->min_storage_buffer_offset_alignment;
+}
+uint32_t SupportedLimits::MaxVertexBuffers() const {
+  return mLimits->max_vertex_buffers;
+}
+uint32_t SupportedLimits::MaxVertexAttributes() const {
+  return mLimits->max_vertex_attributes;
+}
+uint32_t SupportedLimits::MaxVertexBufferArrayStride() const {
+  return mLimits->max_vertex_buffer_array_stride;
+}
+uint32_t SupportedLimits::MaxInterStageShaderComponents() const {
+  return mLimits->max_inter_stage_shader_components;
+}
+uint32_t SupportedLimits::MaxComputeWorkgroupStorageSize() const {
+  return mLimits->max_compute_workgroup_storage_size;
+}
+uint32_t SupportedLimits::MaxComputeInvocationsPerWorkgroup() const {
+  return mLimits->max_compute_invocations_per_workgroup;
+}
+uint32_t SupportedLimits::MaxComputeWorkgroupSizeX() const {
+  return mLimits->max_compute_workgroup_size_x;
+}
+uint32_t SupportedLimits::MaxComputeWorkgroupSizeY() const {
+  return mLimits->max_compute_workgroup_size_y;
+}
+uint32_t SupportedLimits::MaxComputeWorkgroupSizeZ() const {
+  return mLimits->max_compute_workgroup_size_z;
+}
+uint32_t SupportedLimits::MaxComputeWorkgroupsPerDimension() const {
+  return mLimits->max_compute_workgroups_per_dimension;
+}
+
+}  // namespace mozilla::webgpu
diff --git a/dom/webgpu/SupportedLimits.h b/dom/webgpu/SupportedLimits.h
new file mode 100644
index 0000000000..3c38ae6343
--- /dev/null
+++ b/dom/webgpu/SupportedLimits.h
@@ -0,0 +1,61 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef GPU_SupportedLimits_H_
+#define GPU_SupportedLimits_H_
+
+#include "nsWrapperCache.h"
+#include "ObjectModel.h"
+
+namespace mozilla::webgpu {
+namespace ffi {
+struct WGPULimits;
+}
+class Adapter;
+
+class SupportedLimits final : public nsWrapperCache, public ChildOf<Adapter> {
+  const UniquePtr<ffi::WGPULimits> mLimits;
+
+ public:
+  GPU_DECL_CYCLE_COLLECTION(SupportedLimits)
+  GPU_DECL_JS_WRAP(SupportedLimits)
+
+  uint32_t MaxTextureDimension1D() const;
+  uint32_t MaxTextureDimension2D() const;
+  uint32_t MaxTextureDimension3D() const;
+  uint32_t MaxTextureArrayLayers() const;
+  uint32_t MaxBindGroups() const;
+  uint32_t MaxDynamicUniformBuffersPerPipelineLayout() const;
+  uint32_t MaxDynamicStorageBuffersPerPipelineLayout() const;
+  uint32_t MaxSampledTexturesPerShaderStage() const;
+  uint32_t MaxSamplersPerShaderStage() const;
+  uint32_t MaxStorageBuffersPerShaderStage() const;
+  uint32_t MaxStorageTexturesPerShaderStage() const;
+  uint32_t MaxUniformBuffersPerShaderStage() const;
+  uint32_t MaxUniformBufferBindingSize() const;
+  uint32_t MaxStorageBufferBindingSize() const;
+  uint32_t MinUniformBufferOffsetAlignment() const;
+  uint32_t MinStorageBufferOffsetAlignment() const;
+  uint32_t MaxVertexBuffers() const;
+  uint32_t MaxVertexAttributes() const;
+  uint32_t MaxVertexBufferArrayStride() const;
+  uint32_t MaxInterStageShaderComponents() const;
+  uint32_t MaxComputeWorkgroupStorageSize() const;
+  uint32_t MaxComputeInvocationsPerWorkgroup() const;
+  uint32_t MaxComputeWorkgroupSizeX() const;
+  uint32_t MaxComputeWorkgroupSizeY() const;
+  uint32_t MaxComputeWorkgroupSizeZ() const;
+  uint32_t MaxComputeWorkgroupsPerDimension() const;
+
+  SupportedLimits(Adapter* const aParent, UniquePtr<ffi::WGPULimits>&& aLimits);
+
+ private:
+  ~SupportedLimits();
+  void Cleanup() {}
+};
+
+}  // namespace mozilla::webgpu
+
+#endif  // GPU_SupportedLimits_H_
diff --git a/dom/webgpu/Texture.cpp b/dom/webgpu/Texture.cpp
new file mode 100644
index 0000000000..d4df4ecc02
--- /dev/null
+++ b/dom/webgpu/Texture.cpp
@@ -0,0 +1,123 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "Texture.h"
+
+#include "ipc/WebGPUChild.h"
+#include "mozilla/webgpu/ffi/wgpu.h"
+#include "mozilla/webgpu/CanvasContext.h"
+#include "mozilla/dom/WebGPUBinding.h"
+#include "TextureView.h"
+
+namespace mozilla::webgpu {
+
+GPU_IMPL_CYCLE_COLLECTION(Texture, mParent)
+GPU_IMPL_JS_WRAP(Texture)
+
+static Maybe<uint8_t> GetBytesPerBlock(dom::GPUTextureFormat format) {
+  switch (format) {
+    case dom::GPUTextureFormat::R8unorm:
+    case dom::GPUTextureFormat::R8snorm:
+    case dom::GPUTextureFormat::R8uint:
+    case dom::GPUTextureFormat::R8sint:
+      return Some<uint8_t>(1u);
+    case dom::GPUTextureFormat::R16uint:
+    case dom::GPUTextureFormat::R16sint:
+    case dom::GPUTextureFormat::R16float:
+    case dom::GPUTextureFormat::Rg8unorm:
+    case dom::GPUTextureFormat::Rg8snorm:
+    case dom::GPUTextureFormat::Rg8uint:
+    case dom::GPUTextureFormat::Rg8sint:
+      return Some<uint8_t>(2u);
+    case dom::GPUTextureFormat::R32uint:
+    case dom::GPUTextureFormat::R32sint:
+    case dom::GPUTextureFormat::R32float:
+    case dom::GPUTextureFormat::Rg16uint:
+    case dom::GPUTextureFormat::Rg16sint:
+    case dom::GPUTextureFormat::Rg16float:
+    case dom::GPUTextureFormat::Rgba8unorm:
+    case dom::GPUTextureFormat::Rgba8unorm_srgb:
+    case dom::GPUTextureFormat::Rgba8snorm:
+    case dom::GPUTextureFormat::Rgba8uint:
+    case dom::GPUTextureFormat::Rgba8sint:
+    case dom::GPUTextureFormat::Bgra8unorm:
+    case dom::GPUTextureFormat::Bgra8unorm_srgb:
+    case dom::GPUTextureFormat::Rgb10a2unorm:
+    case dom::GPUTextureFormat::Rg11b10float:
+      return Some<uint8_t>(4u);
+    case dom::GPUTextureFormat::Rg32uint:
+    case dom::GPUTextureFormat::Rg32sint:
+    case dom::GPUTextureFormat::Rg32float:
+    case dom::GPUTextureFormat::Rgba16uint:
+    case dom::GPUTextureFormat::Rgba16sint:
+    case dom::GPUTextureFormat::Rgba16float:
+      return Some<uint8_t>(8u);
+    case dom::GPUTextureFormat::Rgba32uint:
+    case dom::GPUTextureFormat::Rgba32sint:
+    case dom::GPUTextureFormat::Rgba32float:
+      return Some<uint8_t>(16u);
+    case dom::GPUTextureFormat::Depth32float:
+      return Some<uint8_t>(4u);
+    case dom::GPUTextureFormat::Bc1_rgba_unorm:
+    case dom::GPUTextureFormat::Bc1_rgba_unorm_srgb:
+    case dom::GPUTextureFormat::Bc4_r_unorm:
+    case dom::GPUTextureFormat::Bc4_r_snorm:
+      return Some<uint8_t>(8u);
+    case dom::GPUTextureFormat::Bc2_rgba_unorm:
+    case dom::GPUTextureFormat::Bc2_rgba_unorm_srgb:
+    case dom::GPUTextureFormat::Bc3_rgba_unorm:
+    case dom::GPUTextureFormat::Bc3_rgba_unorm_srgb:
+    case dom::GPUTextureFormat::Bc5_rg_unorm:
+    case dom::GPUTextureFormat::Bc5_rg_snorm:
+    case dom::GPUTextureFormat::Bc6h_rgb_ufloat:
+    case dom::GPUTextureFormat::Bc6h_rgb_float:
+    case dom::GPUTextureFormat::Bc7_rgba_unorm:
+    case dom::GPUTextureFormat::Bc7_rgba_unorm_srgb:
+      return Some<uint8_t>(16u);
+    case dom::GPUTextureFormat::Depth24plus:
+    case dom::GPUTextureFormat::Depth24plus_stencil8:
+    case dom::GPUTextureFormat::EndGuard_:
+      return Nothing();
+  }
+  return Nothing();
+}
+
+Texture::Texture(Device* const aParent, RawId aId,
+                 const dom::GPUTextureDescriptor& aDesc)
+    : ChildOf(aParent),
+      mId(aId),
+      mFormat(aDesc.mFormat),
+      mBytesPerBlock(GetBytesPerBlock(aDesc.mFormat)) {}
+
+Texture::~Texture() { Cleanup(); }
+
+void Texture::Cleanup() {
+  if (mValid && mParent) {
+    mValid = false;
+    auto bridge = mParent->GetBridge();
+    if (bridge && bridge->IsOpen()) {
+      bridge->SendTextureDestroy(mId);
+    }
+  }
+}
+
+already_AddRefed<TextureView> Texture::CreateView(
+    const dom::GPUTextureViewDescriptor& aDesc) {
+  auto bridge = mParent->GetBridge();
+  RawId id = 0;
+  if (bridge->IsOpen()) {
+    id = bridge->TextureCreateView(mId, mParent->mId, aDesc);
+  }
+
+  RefPtr<TextureView> view = new TextureView(this, id);
+  return view.forget();
+}
+
+void Texture::Destroy() {
+  // TODO: we don't have to implement it right now, but it's used by the
+  // examples
+}
+
+}  // namespace mozilla::webgpu
diff --git a/dom/webgpu/Texture.h b/dom/webgpu/Texture.h
new file mode 100644
index 0000000000..63f87d2bcd
--- /dev/null
+++ b/dom/webgpu/Texture.h
@@ -0,0 +1,57 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef GPU_Texture_H_
+#define GPU_Texture_H_
+
+#include "mozilla/WeakPtr.h"
+#include "nsWrapperCache.h"
+#include "ObjectModel.h"
+#include "mozilla/webgpu/WebGPUTypes.h"
+
+namespace mozilla {
+namespace dom {
+struct GPUTextureDescriptor;
+struct GPUTextureViewDescriptor;
+enum class GPUTextureFormat : uint8_t;
+}  // namespace dom
+
+namespace webgpu {
+namespace ffi {
+struct WGPUTextureViewDescriptor;
+}  // namespace ffi
+
+class CanvasContext;
+class Device;
+class TextureView;
+
+class Texture final : public ObjectBase, public ChildOf<Device> {
+ public:
+  GPU_DECL_CYCLE_COLLECTION(Texture)
+  GPU_DECL_JS_WRAP(Texture)
+
+  Texture(Device* const aParent, RawId aId,
+          const dom::GPUTextureDescriptor& aDesc);
+  Device* GetParentDevice() { return mParent; }
+  const RawId mId;
+  const dom::GPUTextureFormat mFormat;
+  const Maybe<uint8_t> mBytesPerBlock;
+
+  WeakPtr<CanvasContext> mTargetContext;
+
+ private:
+  virtual ~Texture();
+  void Cleanup();
+
+ public:
+  already_AddRefed<TextureView> CreateView(
+      const dom::GPUTextureViewDescriptor& aDesc);
+  void Destroy();
+};
+
+}  // namespace webgpu
+}  // namespace mozilla
+
+#endif  // GPU_Texture_H_
diff --git a/dom/webgpu/TextureView.cpp b/dom/webgpu/TextureView.cpp
new file mode 100644
index 0000000000..4401155b90
--- /dev/null
+++ b/dom/webgpu/TextureView.cpp
@@ -0,0 +1,37 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "TextureView.h"
+
+#include "Device.h"
+#include "mozilla/dom/WebGPUBinding.h"
+#include "mozilla/webgpu/CanvasContext.h"
+#include "ipc/WebGPUChild.h"
+
+namespace mozilla::webgpu {
+
+GPU_IMPL_CYCLE_COLLECTION(TextureView, mParent)
+GPU_IMPL_JS_WRAP(TextureView)
+
+TextureView::TextureView(Texture* const aParent, RawId aId)
+    : ChildOf(aParent), mId(aId) {}
+
+TextureView::~TextureView() { Cleanup(); }
+
+CanvasContext* TextureView::GetTargetContext() const {
+  return mParent->mTargetContext;
+}  // namespace webgpu
+
+void TextureView::Cleanup() {
+  if (mValid && mParent && mParent->GetParentDevice()) {
+    mValid = false;
+    auto bridge = mParent->GetParentDevice()->GetBridge();
+    if (bridge && bridge->IsOpen()) {
+      bridge->SendTextureViewDestroy(mId);
+    }
+  }
+}
+
+}  // namespace mozilla::webgpu
diff --git a/dom/webgpu/TextureView.h b/dom/webgpu/TextureView.h
new file mode 100644
index 0000000000..a0c69c106b
--- /dev/null
+++ b/dom/webgpu/TextureView.h
@@ -0,0 +1,35 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef GPU_TextureView_H_
+#define GPU_TextureView_H_
+
+#include "nsWrapperCache.h"
+#include "ObjectModel.h"
+#include "mozilla/webgpu/WebGPUTypes.h"
+
+namespace mozilla::webgpu {
+
+class CanvasContext;
+class Texture;
+
+class TextureView final : public ObjectBase, public ChildOf<Texture> {
+ public:
+  GPU_DECL_CYCLE_COLLECTION(TextureView)
+  GPU_DECL_JS_WRAP(TextureView)
+
+  TextureView(Texture* const aParent, RawId aId);
+  CanvasContext* GetTargetContext() const;
+
+  const RawId mId;
+
+ private:
+  virtual ~TextureView();
+  void Cleanup();
+};
+
+}  // namespace mozilla::webgpu
+
+#endif  // GPU_TextureView_H_
diff --git a/dom/webgpu/ValidationError.cpp b/dom/webgpu/ValidationError.cpp
new file mode 100644
index 0000000000..119156713c
--- /dev/null
+++ b/dom/webgpu/ValidationError.cpp
@@ -0,0 +1,41 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "ValidationError.h"
+#include "mozilla/dom/WebGPUBinding.h"
+#include "mozilla/ErrorResult.h"
+#include "nsIGlobalObject.h"
+#include "nsReadableUtils.h"
+
+namespace mozilla::webgpu {
+
+GPU_IMPL_CYCLE_COLLECTION(ValidationError, mGlobal)
+GPU_IMPL_JS_WRAP(ValidationError)
+
+ValidationError::ValidationError(nsIGlobalObject* aGlobal,
+                                 const nsACString& aMessage)
+    : mGlobal(aGlobal) {
+  CopyUTF8toUTF16(aMessage, mMessage);
+}
+
+ValidationError::ValidationError(nsIGlobalObject* aGlobal,
+                                 const nsAString& aMessage)
+    : mGlobal(aGlobal), mMessage(aMessage) {}
+
+ValidationError::~ValidationError() = default;
+
+already_AddRefed<ValidationError> ValidationError::Constructor(
+    const dom::GlobalObject& aGlobal, const nsAString& aString,
+    ErrorResult& aRv) {
+  nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(aGlobal.GetAsSupports());
+  if (!global) {
+    aRv.ThrowInvalidStateError("aGlobal is not nsIGlobalObject");
+    return nullptr;
+  }
+
+  return MakeAndAddRef<ValidationError>(global, aString);
+}
+
+}  // namespace mozilla::webgpu
diff --git a/dom/webgpu/ValidationError.h b/dom/webgpu/ValidationError.h
new file mode 100644
index 0000000000..bdbc1ce2eb
--- /dev/null
+++ b/dom/webgpu/ValidationError.h
@@ -0,0 +1,47 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef GPU_ValidationError_H_
+#define GPU_ValidationError_H_
+
+#include "nsCOMPtr.h"
+#include "nsString.h"
+#include "nsWrapperCache.h"
+#include "ObjectModel.h"
+
+namespace mozilla {
+class ErrorResult;
+
+namespace dom {
+class GlobalObject;
+}  // namespace dom
+namespace webgpu {
+
+class ValidationError final : public nsWrapperCache {
+  nsCOMPtr<nsIGlobalObject> mGlobal;
+  nsString mMessage;
+
+ public:
+  GPU_DECL_CYCLE_COLLECTION(ValidationError)
+  GPU_DECL_JS_WRAP(ValidationError)
+  ValidationError(nsIGlobalObject* aGlobal, const nsACString& aMessage);
+  ValidationError(nsIGlobalObject* aGlobal, const nsAString& aMessage);
+
+ private:
+  virtual ~ValidationError();
+  void Cleanup() {}
+
+ public:
+  static already_AddRefed<ValidationError> Constructor(
+      const dom::GlobalObject& aGlobal, const nsAString& aString,
+      ErrorResult& aRv);
+  void GetMessage(nsAString& aMessage) const { aMessage = mMessage; }
+  nsIGlobalObject* GetParentObject() const { return mGlobal; }
+};
+
+}  // namespace webgpu
+}  // namespace mozilla
+
+#endif  // GPU_ValidationError_H_
diff --git a/dom/webgpu/ipc/PWebGPU.ipdl b/dom/webgpu/ipc/PWebGPU.ipdl
new file mode 100644
index 0000000000..daa3873550
--- /dev/null
+++ b/dom/webgpu/ipc/PWebGPU.ipdl
@@ -0,0 +1,93 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ * vim: sw=2 ts=8 et :
+ */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+using layers::RGBDescriptor from "mozilla/layers/LayersSurfaces.h";
+using layers::RemoteTextureId from "mozilla/layers/LayersTypes.h";
+using layers::RemoteTextureOwnerId from "mozilla/layers/LayersTypes.h";
+using RawId from "mozilla/webgpu/WebGPUTypes.h";
+using dom::GPURequestAdapterOptions from "mozilla/dom/WebGPUBinding.h";
+using dom::GPUCommandBufferDescriptor from "mozilla/dom/WebGPUBinding.h";
+using dom::GPUBufferDescriptor from "mozilla/dom/WebGPUBinding.h";
+using MaybeScopedError from "mozilla/webgpu/WebGPUTypes.h";
+using WebGPUCompilationMessage from "mozilla/webgpu/WebGPUTypes.h";
+[MoveOnly] using class mozilla::ipc::UnsafeSharedMemoryHandle from "mozilla/ipc/RawShmem.h";
+
+include "mozilla/ipc/ByteBufUtils.h";
+include "mozilla/layers/LayersMessageUtils.h";
+include "mozilla/webgpu/WebGPUSerialize.h";
+include "mozilla/layers/WebRenderMessageUtils.h";
+include protocol PCanvasManager;
+include PWebGPUTypes;
+
+namespace mozilla {
+namespace webgpu {
+
+/**
+ * Represents the connection between a WebGPUChild actor that issues WebGPU
+ * command from the content process, and a WebGPUParent in the compositor
+ * process that runs the commands.
+ */
+async protocol PWebGPU
+{
+  manager PCanvasManager;
+
+parent:
+  async DeviceAction(RawId selfId, ByteBuf buf);
+  async DeviceActionWithAck(RawId selfId, ByteBuf buf) returns (bool dummy);
+  async TextureAction(RawId selfId, RawId aDeviceId, ByteBuf buf);
+  async CommandEncoderAction(RawId selfId, RawId aDeviceId, ByteBuf buf);
+  async BumpImplicitBindGroupLayout(RawId pipelineId, bool isCompute, uint32_t index, RawId assignId);
+
+  async CreateBuffer(RawId deviceId, RawId bufferId, GPUBufferDescriptor desc, UnsafeSharedMemoryHandle shm);
+
+  async InstanceRequestAdapter(GPURequestAdapterOptions options, RawId[] ids) returns (ByteBuf byteBuf);
+  async AdapterRequestDevice(RawId selfId, ByteBuf buf, RawId newId) returns (bool success);
+  async AdapterDestroy(RawId selfId);
+  // TODO: We want to return an array of compilation messages.
+  async DeviceCreateShaderModule(RawId selfId, RawId bufferId, nsString label, nsCString code) returns (WebGPUCompilationMessage[] messages);
+  async BufferMap(RawId selfId, uint32_t aMode, uint64_t offset, uint64_t size) returns (BufferMapResult result);
+  async BufferUnmap(RawId deviceId, RawId bufferId, bool flush);
+  async BufferDestroy(RawId selfId);
+  async BufferDrop(RawId selfId);
+  async TextureDestroy(RawId selfId);
+  async TextureViewDestroy(RawId selfId);
+  async SamplerDestroy(RawId selfId);
+  async DeviceDestroy(RawId selfId);
+
+  async CommandEncoderFinish(RawId selfId, RawId deviceId, GPUCommandBufferDescriptor desc);
+  async CommandEncoderDestroy(RawId selfId);
+  async CommandBufferDestroy(RawId selfId);
+  async RenderBundleDestroy(RawId selfId);
+  async QueueSubmit(RawId selfId, RawId aDeviceId, RawId[] commandBuffers);
+  async QueueWriteAction(RawId selfId, RawId aDeviceId, ByteBuf buf, UnsafeSharedMemoryHandle shmem);
+
+  async BindGroupLayoutDestroy(RawId selfId);
+  async PipelineLayoutDestroy(RawId selfId);
+  async BindGroupDestroy(RawId selfId);
+  async ShaderModuleDestroy(RawId selfId);
+  async ComputePipelineDestroy(RawId selfId);
+  async RenderPipelineDestroy(RawId selfId);
+  async ImplicitLayoutDestroy(RawId implicitPlId, RawId[] implicitBglIds);
+  async DeviceCreateSwapChain(RawId selfId, RawId queueId, RGBDescriptor desc, RawId[] bufferIds, RemoteTextureOwnerId ownerId);
+  async SwapChainPresent(RawId textureId, RawId commandEncoderId, RemoteTextureId remoteTextureId, RemoteTextureOwnerId remoteTextureOwnerId);
+  async SwapChainDestroy(RemoteTextureOwnerId ownerId);
+
+  async DevicePushErrorScope(RawId selfId);
+  async DevicePopErrorScope(RawId selfId) returns (MaybeScopedError maybeError);
+
+  // Generate an error on the Device timeline for `deviceId`.
+  // The `message` parameter is interpreted as UTF-8.
+  async GenerateError(RawId deviceId, nsCString message);
+
+child:
+  async DeviceUncapturedError(RawId aDeviceId, nsCString message);
+  async DropAction(ByteBuf buf);
+  async __delete__();
+};
+
+} // webgpu
+} // mozilla
diff --git a/dom/webgpu/ipc/PWebGPUTypes.ipdlh b/dom/webgpu/ipc/PWebGPUTypes.ipdlh
new file mode 100644
index 0000000000..98f062856c
--- /dev/null
+++ b/dom/webgpu/ipc/PWebGPUTypes.ipdlh
@@ -0,0 +1,26 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+using struct mozilla::null_t from "mozilla/ipc/IPCCore.h";
+
+namespace mozilla {
+namespace webgpu {
+
+struct BufferMapSuccess {
+    uint64_t offset;
+    uint64_t size;
+    bool writable;
+};
+
+struct BufferMapError {
+    nsCString message;
+};
+
+union BufferMapResult {
+    BufferMapSuccess;
+    BufferMapError;
+};
+
+}  // namespace layers
+}  // namespace mozilla
diff --git a/dom/webgpu/ipc/WebGPUChild.cpp b/dom/webgpu/ipc/WebGPUChild.cpp
new file mode 100644
index 0000000000..5bc08c4386
--- /dev/null
+++ b/dom/webgpu/ipc/WebGPUChild.cpp
@@ -0,0 +1,1080 @@
+/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "WebGPUChild.h"
+#include "js/Warnings.h"  // JS::WarnUTF8
+#include "mozilla/EnumTypeTraits.h"
+#include "mozilla/dom/Promise.h"
+#include "mozilla/dom/ScriptSettings.h"
+#include "mozilla/dom/WebGPUBinding.h"
+#include "mozilla/dom/GPUUncapturedErrorEvent.h"
+#include "mozilla/webgpu/ValidationError.h"
+#include "mozilla/webgpu/ffi/wgpu.h"
+#include "Adapter.h"
+#include "DeviceLostInfo.h"
+#include "Sampler.h"
+#include "CompilationInfo.h"
+#include "mozilla/ipc/RawShmem.h"
+
+namespace mozilla::webgpu {
+
+NS_IMPL_CYCLE_COLLECTION(WebGPUChild)
+
+void WebGPUChild::JsWarning(nsIGlobalObject* aGlobal,
+                            const nsACString& aMessage) {
+  const auto& flatString = PromiseFlatCString(aMessage);
+  if (aGlobal) {
+    dom::AutoJSAPI api;
+    if (api.Init(aGlobal)) {
+      JS::WarnUTF8(api.cx(), "%s", flatString.get());
+    }
+  } else {
+    printf_stderr("Validation error without device target: %s\n",
+                  flatString.get());
+  }
+}
+
+static ffi::WGPUCompareFunction ConvertCompareFunction(
+    const dom::GPUCompareFunction& aCompare) {
+  // Value of 0 = Undefined is reserved on the C side for "null" semantics.
+  return ffi::WGPUCompareFunction(UnderlyingValue(aCompare) + 1);
+}
+
+static ffi::WGPUTextureFormat ConvertTextureFormat(
+    const dom::GPUTextureFormat& aFormat) {
+  ffi::WGPUTextureFormat result = {ffi::WGPUTextureFormat_Sentinel};
+  switch (aFormat) {
+    case dom::GPUTextureFormat::R8unorm:
+      result.tag = ffi::WGPUTextureFormat_R8Unorm;
+      break;
+    case dom::GPUTextureFormat::R8snorm:
+      result.tag = ffi::WGPUTextureFormat_R8Snorm;
+      break;
+    case dom::GPUTextureFormat::R8uint:
+      result.tag = ffi::WGPUTextureFormat_R8Uint;
+      break;
+    case dom::GPUTextureFormat::R8sint:
+      result.tag = ffi::WGPUTextureFormat_R8Sint;
+      break;
+    case dom::GPUTextureFormat::R16uint:
+      result.tag = ffi::WGPUTextureFormat_R16Uint;
+      break;
+    case dom::GPUTextureFormat::R16sint:
+      result.tag = ffi::WGPUTextureFormat_R16Sint;
+      break;
+    case dom::GPUTextureFormat::R16float:
+      result.tag = ffi::WGPUTextureFormat_R16Float;
+      break;
+    case dom::GPUTextureFormat::Rg8unorm:
+      result.tag = ffi::WGPUTextureFormat_Rg8Unorm;
+      break;
+    case dom::GPUTextureFormat::Rg8snorm:
+      result.tag = ffi::WGPUTextureFormat_Rg8Snorm;
+      break;
+    case dom::GPUTextureFormat::Rg8uint:
+      result.tag = ffi::WGPUTextureFormat_Rg8Uint;
+      break;
+    case dom::GPUTextureFormat::Rg8sint:
+      result.tag = ffi::WGPUTextureFormat_Rg8Sint;
+      break;
+    case dom::GPUTextureFormat::R32uint:
+      result.tag = ffi::WGPUTextureFormat_R32Uint;
+      break;
+    case dom::GPUTextureFormat::R32sint:
+      result.tag = ffi::WGPUTextureFormat_R32Sint;
+      break;
+    case dom::GPUTextureFormat::R32float:
+      result.tag = ffi::WGPUTextureFormat_R32Float;
+      break;
+    case dom::GPUTextureFormat::Rg16uint:
+      result.tag = ffi::WGPUTextureFormat_Rg16Uint;
+      break;
+    case dom::GPUTextureFormat::Rg16sint:
+      result.tag = ffi::WGPUTextureFormat_Rg16Sint;
+      break;
+    case dom::GPUTextureFormat::Rg16float:
+      result.tag = ffi::WGPUTextureFormat_Rg16Float;
+      break;
+    case dom::GPUTextureFormat::Rgba8unorm:
+      result.tag = ffi::WGPUTextureFormat_Rgba8Unorm;
+      break;
+    case dom::GPUTextureFormat::Rgba8unorm_srgb:
+      result.tag = ffi::WGPUTextureFormat_Rgba8UnormSrgb;
+      break;
+    case dom::GPUTextureFormat::Rgba8snorm:
+      result.tag = ffi::WGPUTextureFormat_Rgba8Snorm;
+      break;
+    case dom::GPUTextureFormat::Rgba8uint:
+      result.tag = ffi::WGPUTextureFormat_Rgba8Uint;
+      break;
+    case dom::GPUTextureFormat::Rgba8sint:
+      result.tag = ffi::WGPUTextureFormat_Rgba8Sint;
+      break;
+    case dom::GPUTextureFormat::Bgra8unorm:
+      result.tag = ffi::WGPUTextureFormat_Bgra8Unorm;
+      break;
+    case dom::GPUTextureFormat::Bgra8unorm_srgb:
+      result.tag = ffi::WGPUTextureFormat_Bgra8UnormSrgb;
+      break;
+    case dom::GPUTextureFormat::Rgb10a2unorm:
+      result.tag = ffi::WGPUTextureFormat_Rgb10a2Unorm;
+      break;
+    case dom::GPUTextureFormat::Rg11b10float:
+      result.tag = ffi::WGPUTextureFormat_Rg11b10Float;
+      break;
+    case dom::GPUTextureFormat::Rg32uint:
+      result.tag = ffi::WGPUTextureFormat_Rg32Uint;
+      break;
+    case dom::GPUTextureFormat::Rg32sint:
+      result.tag = ffi::WGPUTextureFormat_Rg32Sint;
+      break;
+    case dom::GPUTextureFormat::Rg32float:
+      result.tag = ffi::WGPUTextureFormat_Rg32Float;
+      break;
+    case dom::GPUTextureFormat::Rgba16uint:
+      result.tag = ffi::WGPUTextureFormat_Rgba16Uint;
+      break;
+    case dom::GPUTextureFormat::Rgba16sint:
+      result.tag = ffi::WGPUTextureFormat_Rgba16Sint;
+      break;
+    case dom::GPUTextureFormat::Rgba16float:
+      result.tag = ffi::WGPUTextureFormat_Rgba16Float;
+      break;
+    case dom::GPUTextureFormat::Rgba32uint:
+      result.tag = ffi::WGPUTextureFormat_Rgba32Uint;
+      break;
+    case dom::GPUTextureFormat::Rgba32sint:
+      result.tag = ffi::WGPUTextureFormat_Rgba32Sint;
+      break;
+    case dom::GPUTextureFormat::Rgba32float:
+      result.tag = ffi::WGPUTextureFormat_Rgba32Float;
+      break;
+    case dom::GPUTextureFormat::Depth32float:
+      result.tag = ffi::WGPUTextureFormat_Depth32Float;
+      break;
+    case dom::GPUTextureFormat::Bc1_rgba_unorm:
+      result.tag = ffi::WGPUTextureFormat_Bc1RgbaUnorm;
+      break;
+    case dom::GPUTextureFormat::Bc1_rgba_unorm_srgb:
+      result.tag = ffi::WGPUTextureFormat_Bc1RgbaUnormSrgb;
+      break;
+    case dom::GPUTextureFormat::Bc4_r_unorm:
+      result.tag = ffi::WGPUTextureFormat_Bc4RUnorm;
+      break;
+    case dom::GPUTextureFormat::Bc4_r_snorm:
+      result.tag = ffi::WGPUTextureFormat_Bc4RSnorm;
+      break;
+    case dom::GPUTextureFormat::Bc2_rgba_unorm:
+      result.tag = ffi::WGPUTextureFormat_Bc2RgbaUnorm;
+      break;
+    case dom::GPUTextureFormat::Bc2_rgba_unorm_srgb:
+      result.tag = ffi::WGPUTextureFormat_Bc2RgbaUnormSrgb;
+      break;
+    case dom::GPUTextureFormat::Bc3_rgba_unorm:
+      result.tag = ffi::WGPUTextureFormat_Bc3RgbaUnorm;
+      break;
+    case dom::GPUTextureFormat::Bc3_rgba_unorm_srgb:
+      result.tag = ffi::WGPUTextureFormat_Bc3RgbaUnormSrgb;
+      break;
+    case dom::GPUTextureFormat::Bc5_rg_unorm:
+      result.tag = ffi::WGPUTextureFormat_Bc5RgUnorm;
+      break;
+    case dom::GPUTextureFormat::Bc5_rg_snorm:
+      result.tag = ffi::WGPUTextureFormat_Bc5RgSnorm;
+      break;
+    case dom::GPUTextureFormat::Bc6h_rgb_ufloat:
+      result.tag = ffi::WGPUTextureFormat_Bc6hRgbUfloat;
+      break;
+    case dom::GPUTextureFormat::Bc6h_rgb_float:
+      result.tag = ffi::WGPUTextureFormat_Bc6hRgbSfloat;
+      break;
+    case dom::GPUTextureFormat::Bc7_rgba_unorm:
+      result.tag = ffi::WGPUTextureFormat_Bc7RgbaUnorm;
+      break;
+    case dom::GPUTextureFormat::Bc7_rgba_unorm_srgb:
+      result.tag = ffi::WGPUTextureFormat_Bc7RgbaUnormSrgb;
+      break;
+    case dom::GPUTextureFormat::Depth24plus:
+      result.tag = ffi::WGPUTextureFormat_Depth24Plus;
+      break;
+    case dom::GPUTextureFormat::Depth24plus_stencil8:
+      result.tag = ffi::WGPUTextureFormat_Depth24PlusStencil8;
+      break;
+    case dom::GPUTextureFormat::EndGuard_:
+      MOZ_ASSERT_UNREACHABLE();
+  }
+
+  // Clang will check for us that the switch above is exhaustive,
+  // but not if we add a 'default' case. So, check this here.
+  MOZ_ASSERT(result.tag != ffi::WGPUTextureFormat_Sentinel,
+             "unexpected texture format enum");
+
+  return result;
+}
+
+void WebGPUChild::ConvertTextureFormatRef(const dom::GPUTextureFormat& aInput,
+                                          ffi::WGPUTextureFormat& aOutput) {
+  aOutput = ConvertTextureFormat(aInput);
+}
+
+static UniquePtr<ffi::WGPUClient> initialize() {
+  ffi::WGPUInfrastructure infra = ffi::wgpu_client_new();
+  return UniquePtr<ffi::WGPUClient>{infra.client};
+}
+
+WebGPUChild::WebGPUChild() : mClient(initialize()) {}
+
+WebGPUChild::~WebGPUChild() = default;
+
+RefPtr<AdapterPromise> WebGPUChild::InstanceRequestAdapter(
+    const dom::GPURequestAdapterOptions& aOptions) {
+  const int max_ids = 10;
+  RawId ids[max_ids] = {0};
+  unsigned long count =
+      ffi::wgpu_client_make_adapter_ids(mClient.get(), ids, max_ids);
+
+  nsTArray<RawId> sharedIds(count);
+  for (unsigned long i = 0; i != count; ++i) {
+    sharedIds.AppendElement(ids[i]);
+  }
+
+  return SendInstanceRequestAdapter(aOptions, sharedIds)
+      ->Then(
+          GetCurrentSerialEventTarget(), __func__,
+          [](ipc::ByteBuf&& aInfoBuf) {
+            // Ideally, we'd just send an empty ByteBuf, but the IPC code
+            // complains if the capacity is zero...
+            // So for the case where an adapter wasn't found, we just
+            // transfer a single 0u64 in this buffer.
+            return aInfoBuf.mLen > sizeof(uint64_t)
+                       ? AdapterPromise::CreateAndResolve(std::move(aInfoBuf),
+                                                          __func__)
+                       : AdapterPromise::CreateAndReject(Nothing(), __func__);
+          },
+          [](const ipc::ResponseRejectReason& aReason) {
+            return AdapterPromise::CreateAndReject(Some(aReason), __func__);
+          });
+}
+
+Maybe<DeviceRequest> WebGPUChild::AdapterRequestDevice(
+    RawId aSelfId, const dom::GPUDeviceDescriptor& aDesc,
+    ffi::WGPULimits* aLimits) {
+  ffi::WGPUDeviceDescriptor desc = {};
+  ffi::wgpu_client_fill_default_limits(&desc.limits);
+
+  // webgpu::StringHelper label(aDesc.mLabel);
+  // desc.label = label.Get();
+
+  const auto featureBits = Adapter::MakeFeatureBits(aDesc.mRequiredFeatures);
+  if (!featureBits) {
+    return Nothing();
+  }
+  desc.features = *featureBits;
+
+  if (aDesc.mRequiredLimits.WasPassed()) {
+    for (const auto& entry : aDesc.mRequiredLimits.Value().Entries()) {
+      const uint32_t valueU32 =
+          entry.mValue < std::numeric_limits<uint32_t>::max()
+              ? entry.mValue
+              : std::numeric_limits<uint32_t>::max();
+      if (entry.mKey == u"maxTextureDimension1D"_ns) {
+        desc.limits.max_texture_dimension_1d = valueU32;
+      } else if (entry.mKey == u"maxTextureDimension2D"_ns) {
+        desc.limits.max_texture_dimension_2d = valueU32;
+      } else if (entry.mKey == u"maxTextureDimension3D"_ns) {
+        desc.limits.max_texture_dimension_3d = valueU32;
+      } else if (entry.mKey == u"maxTextureArrayLayers"_ns) {
+        desc.limits.max_texture_array_layers = valueU32;
+      } else if (entry.mKey == u"maxBindGroups"_ns) {
+        desc.limits.max_bind_groups = valueU32;
+      } else if (entry.mKey ==
+                 u"maxDynamicUniformBuffersPerPipelineLayout"_ns) {
+        desc.limits.max_dynamic_uniform_buffers_per_pipeline_layout = valueU32;
+      } else if (entry.mKey ==
+                 u"maxDynamicStorageBuffersPerPipelineLayout"_ns) {
+        desc.limits.max_dynamic_storage_buffers_per_pipeline_layout = valueU32;
+      } else if (entry.mKey == u"maxSampledTexturesPerShaderStage"_ns) {
+        desc.limits.max_sampled_textures_per_shader_stage = valueU32;
+      } else if (entry.mKey == u"maxSamplersPerShaderStage"_ns) {
+        desc.limits.max_samplers_per_shader_stage = valueU32;
+      } else if (entry.mKey == u"maxStorageBuffersPerShaderStage"_ns) {
+        desc.limits.max_storage_buffers_per_shader_stage = valueU32;
+      } else if (entry.mKey == u"maxStorageTexturesPerShaderStage"_ns) {
+        desc.limits.max_storage_textures_per_shader_stage = valueU32;
+      } else if (entry.mKey == u"maxUniformBuffersPerShaderStage"_ns) {
+        desc.limits.max_uniform_buffers_per_shader_stage = valueU32;
+      } else if (entry.mKey == u"maxUniformBufferBindingSize"_ns) {
+        desc.limits.max_uniform_buffer_binding_size = entry.mValue;
+      } else if (entry.mKey == u"maxStorageBufferBindingSize"_ns) {
+        desc.limits.max_storage_buffer_binding_size = entry.mValue;
+      } else if (entry.mKey == u"minUniformBufferOffsetAlignment"_ns) {
+        desc.limits.min_uniform_buffer_offset_alignment = valueU32;
+      } else if (entry.mKey == u"minStorageBufferOffsetAlignment"_ns) {
+        desc.limits.min_storage_buffer_offset_alignment = valueU32;
+      } else if (entry.mKey == u"maxVertexBuffers"_ns) {
+        desc.limits.max_vertex_buffers = valueU32;
+      } else if (entry.mKey == u"maxVertexAttributes"_ns) {
+        desc.limits.max_vertex_attributes = valueU32;
+      } else if (entry.mKey == u"maxVertexBufferArrayStride"_ns) {
+        desc.limits.max_vertex_buffer_array_stride = valueU32;
+      } else if (entry.mKey == u"maxComputeWorkgroupSizeX"_ns) {
+        desc.limits.max_compute_workgroup_size_x = valueU32;
+      } else if (entry.mKey == u"maxComputeWorkgroupSizeY"_ns) {
+        desc.limits.max_compute_workgroup_size_y = valueU32;
+      } else if (entry.mKey == u"maxComputeWorkgroupSizeZ"_ns) {
+        desc.limits.max_compute_workgroup_size_z = valueU32;
+      } else if (entry.mKey == u"maxComputeWorkgroupsPerDimension"_ns) {
+        desc.limits.max_compute_workgroups_per_dimension = valueU32;
+      } else {
+        NS_WARNING(nsPrintfCString("Requested limit '%s' is not recognized.",
+                                   NS_ConvertUTF16toUTF8(entry.mKey).get())
+                       .get());
+        return Nothing();
+      }
+
+      // TODO: maxInterStageShaderComponents
+      // TODO: maxComputeWorkgroupStorageSize
+      // TODO: maxComputeInvocationsPerWorkgroup
+    }
+  }
+
+  RawId id = ffi::wgpu_client_make_device_id(mClient.get(), aSelfId);
+
+  ByteBuf bb;
+  ffi::wgpu_client_serialize_device_descriptor(&desc, ToFFI(&bb));
+
+  DeviceRequest request;
+  request.mId = id;
+  request.mPromise = SendAdapterRequestDevice(aSelfId, std::move(bb), id);
+  *aLimits = desc.limits;
+
+  return Some(std::move(request));
+}
+
+RawId WebGPUChild::DeviceCreateBuffer(RawId aSelfId,
+                                      const dom::GPUBufferDescriptor& aDesc,
+                                      ipc::UnsafeSharedMemoryHandle&& aShmem) {
+  RawId bufferId = ffi::wgpu_client_make_buffer_id(mClient.get(), aSelfId);
+  if (!SendCreateBuffer(aSelfId, bufferId, aDesc, std::move(aShmem))) {
+    MOZ_CRASH("IPC failure");
+  }
+  return bufferId;
+}
+
+RawId WebGPUChild::DeviceCreateTexture(RawId aSelfId,
+                                       const dom::GPUTextureDescriptor& aDesc) {
+  ffi::WGPUTextureDescriptor desc = {};
+
+  webgpu::StringHelper label(aDesc.mLabel);
+  desc.label = label.Get();
+
+  if (aDesc.mSize.IsRangeEnforcedUnsignedLongSequence()) {
+    const auto& seq = aDesc.mSize.GetAsRangeEnforcedUnsignedLongSequence();
+    desc.size.width = seq.Length() > 0 ? seq[0] : 1;
+    desc.size.height = seq.Length() > 1 ? seq[1] : 1;
+    desc.size.depth_or_array_layers = seq.Length() > 2 ? seq[2] : 1;
+  } else if (aDesc.mSize.IsGPUExtent3DDict()) {
+    const auto& dict = aDesc.mSize.GetAsGPUExtent3DDict();
+    desc.size.width = dict.mWidth;
+    desc.size.height = dict.mHeight;
+    desc.size.depth_or_array_layers = dict.mDepthOrArrayLayers;
+  } else {
+    MOZ_CRASH("Unexpected union");
+  }
+  desc.mip_level_count = aDesc.mMipLevelCount;
+  desc.sample_count = aDesc.mSampleCount;
+  desc.dimension = ffi::WGPUTextureDimension(aDesc.mDimension);
+  desc.format = ConvertTextureFormat(aDesc.mFormat);
+  desc.usage = aDesc.mUsage;
+
+  ByteBuf bb;
+  RawId id = ffi::wgpu_client_create_texture(mClient.get(), aSelfId, &desc,
+                                             ToFFI(&bb));
+  if (!SendDeviceAction(aSelfId, std::move(bb))) {
+    MOZ_CRASH("IPC failure");
+  }
+  return id;
+}
+
+RawId WebGPUChild::TextureCreateView(
+    RawId aSelfId, RawId aDeviceId,
+    const dom::GPUTextureViewDescriptor& aDesc) {
+  ffi::WGPUTextureViewDescriptor desc = {};
+
+  webgpu::StringHelper label(aDesc.mLabel);
+  desc.label = label.Get();
+
+  ffi::WGPUTextureFormat format = {ffi::WGPUTextureFormat_Sentinel};
+  if (aDesc.mFormat.WasPassed()) {
+    format = ConvertTextureFormat(aDesc.mFormat.Value());
+    desc.format = &format;
+  }
+  ffi::WGPUTextureViewDimension dimension =
+      ffi::WGPUTextureViewDimension_Sentinel;
+  if (aDesc.mDimension.WasPassed()) {
+    dimension = ffi::WGPUTextureViewDimension(aDesc.mDimension.Value());
+    desc.dimension = &dimension;
+  }
+
+  desc.aspect = ffi::WGPUTextureAspect(aDesc.mAspect);
+  desc.base_mip_level = aDesc.mBaseMipLevel;
+  desc.mip_level_count =
+      aDesc.mMipLevelCount.WasPassed() ? aDesc.mMipLevelCount.Value() : 0;
+  desc.base_array_layer = aDesc.mBaseArrayLayer;
+  desc.array_layer_count =
+      aDesc.mArrayLayerCount.WasPassed() ? aDesc.mArrayLayerCount.Value() : 0;
+
+  ByteBuf bb;
+  RawId id = ffi::wgpu_client_create_texture_view(mClient.get(), aSelfId, &desc,
+                                                  ToFFI(&bb));
+  if (!SendTextureAction(aSelfId, aDeviceId, std::move(bb))) {
+    MOZ_CRASH("IPC failure");
+  }
+  return id;
+}
+
+RawId WebGPUChild::DeviceCreateSampler(RawId aSelfId,
+                                       const dom::GPUSamplerDescriptor& aDesc) {
+  ffi::WGPUSamplerDescriptor desc = {};
+
+  webgpu::StringHelper label(aDesc.mLabel);
+  desc.label = label.Get();
+  desc.address_modes[0] = ffi::WGPUAddressMode(aDesc.mAddressModeU);
+  desc.address_modes[1] = ffi::WGPUAddressMode(aDesc.mAddressModeV);
+  desc.address_modes[2] = ffi::WGPUAddressMode(aDesc.mAddressModeW);
+  desc.mag_filter = ffi::WGPUFilterMode(aDesc.mMagFilter);
+  desc.min_filter = ffi::WGPUFilterMode(aDesc.mMinFilter);
+  desc.mipmap_filter = ffi::WGPUFilterMode(aDesc.mMipmapFilter);
+  desc.lod_min_clamp = aDesc.mLodMinClamp;
+  desc.lod_max_clamp = aDesc.mLodMaxClamp;
+
+  ffi::WGPUCompareFunction comparison = ffi::WGPUCompareFunction_Sentinel;
+  if (aDesc.mCompare.WasPassed()) {
+    comparison = ConvertCompareFunction(aDesc.mCompare.Value());
+    desc.compare = &comparison;
+  }
+
+  ByteBuf bb;
+  RawId id = ffi::wgpu_client_create_sampler(mClient.get(), aSelfId, &desc,
+                                             ToFFI(&bb));
+  if (!SendDeviceAction(aSelfId, std::move(bb))) {
+    MOZ_CRASH("IPC failure");
+  }
+  return id;
+}
+
+RawId WebGPUChild::DeviceCreateCommandEncoder(
+    RawId aSelfId, const dom::GPUCommandEncoderDescriptor& aDesc) {
+  ffi::WGPUCommandEncoderDescriptor desc = {};
+
+  webgpu::StringHelper label(aDesc.mLabel);
+  desc.label = label.Get();
+
+  ByteBuf bb;
+  RawId id = ffi::wgpu_client_create_command_encoder(mClient.get(), aSelfId,
+                                                     &desc, ToFFI(&bb));
+  if (!SendDeviceAction(aSelfId, std::move(bb))) {
+    MOZ_CRASH("IPC failure");
+  }
+  return id;
+}
+
+RawId WebGPUChild::CommandEncoderFinish(
+    RawId aSelfId, RawId aDeviceId,
+    const dom::GPUCommandBufferDescriptor& aDesc) {
+  if (!SendCommandEncoderFinish(aSelfId, aDeviceId, aDesc)) {
+    MOZ_CRASH("IPC failure");
+  }
+  // We rely on knowledge that `CommandEncoderId` == `CommandBufferId`
+  // TODO: refactor this to truly behave as if the encoder is being finished,
+  // and a new command buffer ID is being created from it. Resolve the ID
+  // type aliasing at the place that introduces it: `wgpu-core`.
+  return aSelfId;
+}
+
+RawId WebGPUChild::RenderBundleEncoderFinish(
+    ffi::WGPURenderBundleEncoder& aEncoder, RawId aDeviceId,
+    const dom::GPURenderBundleDescriptor& aDesc) {
+  ffi::WGPURenderBundleDescriptor desc = {};
+
+  webgpu::StringHelper label(aDesc.mLabel);
+  desc.label = label.Get();
+
+  ipc::ByteBuf bb;
+  RawId id = ffi::wgpu_client_create_render_bundle(
+      mClient.get(), &aEncoder, aDeviceId, &desc, ToFFI(&bb));
+
+  if (!SendDeviceAction(aDeviceId, std::move(bb))) {
+    MOZ_CRASH("IPC failure");
+  }
+
+  return id;
+}
+
+RawId WebGPUChild::DeviceCreateBindGroupLayout(
+    RawId aSelfId, const dom::GPUBindGroupLayoutDescriptor& aDesc) {
+  struct OptionalData {
+    ffi::WGPUTextureViewDimension dim;
+    ffi::WGPURawTextureSampleType type;
+    ffi::WGPUTextureFormat format;
+  };
+  nsTArray<OptionalData> optional(aDesc.mEntries.Length());
+  for (const auto& entry : aDesc.mEntries) {
+    OptionalData data = {};
+    if (entry.mTexture.WasPassed()) {
+      const auto& texture = entry.mTexture.Value();
+      data.dim = ffi::WGPUTextureViewDimension(texture.mViewDimension);
+      switch (texture.mSampleType) {
+        case dom::GPUTextureSampleType::Float:
+          data.type = ffi::WGPURawTextureSampleType_Float;
+          break;
+        case dom::GPUTextureSampleType::Unfilterable_float:
+          data.type = ffi::WGPURawTextureSampleType_UnfilterableFloat;
+          break;
+        case dom::GPUTextureSampleType::Uint:
+          data.type = ffi::WGPURawTextureSampleType_Uint;
+          break;
+        case dom::GPUTextureSampleType::Sint:
+          data.type = ffi::WGPURawTextureSampleType_Sint;
+          break;
+        case dom::GPUTextureSampleType::Depth:
+          data.type = ffi::WGPURawTextureSampleType_Depth;
+          break;
+        case dom::GPUTextureSampleType::EndGuard_:
+          MOZ_ASSERT_UNREACHABLE();
+      }
+    }
+    if (entry.mStorageTexture.WasPassed()) {
+      const auto& texture = entry.mStorageTexture.Value();
+      data.dim = ffi::WGPUTextureViewDimension(texture.mViewDimension);
+      data.format = ConvertTextureFormat(texture.mFormat);
+    }
+    optional.AppendElement(data);
+  }
+
+  nsTArray<ffi::WGPUBindGroupLayoutEntry> entries(aDesc.mEntries.Length());
+  for (size_t i = 0; i < aDesc.mEntries.Length(); ++i) {
+    const auto& entry = aDesc.mEntries[i];
+    ffi::WGPUBindGroupLayoutEntry e = {};
+    e.binding = entry.mBinding;
+    e.visibility = entry.mVisibility;
+    if (entry.mBuffer.WasPassed()) {
+      switch (entry.mBuffer.Value().mType) {
+        case dom::GPUBufferBindingType::Uniform:
+          e.ty = ffi::WGPURawBindingType_UniformBuffer;
+          break;
+        case dom::GPUBufferBindingType::Storage:
+          e.ty = ffi::WGPURawBindingType_StorageBuffer;
+          break;
+        case dom::GPUBufferBindingType::Read_only_storage:
+          e.ty = ffi::WGPURawBindingType_ReadonlyStorageBuffer;
+          break;
+        case dom::GPUBufferBindingType::EndGuard_:
+          MOZ_ASSERT_UNREACHABLE();
+      }
+      e.has_dynamic_offset = entry.mBuffer.Value().mHasDynamicOffset;
+    }
+    if (entry.mTexture.WasPassed()) {
+      e.ty = ffi::WGPURawBindingType_SampledTexture;
+      e.view_dimension = &optional[i].dim;
+      e.texture_sample_type = &optional[i].type;
+      e.multisampled = entry.mTexture.Value().mMultisampled;
+    }
+    if (entry.mStorageTexture.WasPassed()) {
+      e.ty = entry.mStorageTexture.Value().mAccess ==
+                     dom::GPUStorageTextureAccess::Write_only
+                 ? ffi::WGPURawBindingType_WriteonlyStorageTexture
+                 : ffi::WGPURawBindingType_ReadonlyStorageTexture;
+      e.view_dimension = &optional[i].dim;
+      e.storage_texture_format = &optional[i].format;
+    }
+    if (entry.mSampler.WasPassed()) {
+      e.ty = ffi::WGPURawBindingType_Sampler;
+      switch (entry.mSampler.Value().mType) {
+        case dom::GPUSamplerBindingType::Filtering:
+          e.sampler_filter = true;
+          break;
+        case dom::GPUSamplerBindingType::Non_filtering:
+          break;
+        case dom::GPUSamplerBindingType::Comparison:
+          e.sampler_compare = true;
+          break;
+        case dom::GPUSamplerBindingType::EndGuard_:
+          MOZ_ASSERT_UNREACHABLE();
+      }
+    }
+    entries.AppendElement(e);
+  }
+
+  ffi::WGPUBindGroupLayoutDescriptor desc = {};
+
+  webgpu::StringHelper label(aDesc.mLabel);
+  desc.label = label.Get();
+  desc.entries = entries.Elements();
+  desc.entries_length = entries.Length();
+
+  ByteBuf bb;
+  RawId id = ffi::wgpu_client_create_bind_group_layout(mClient.get(), aSelfId,
+                                                       &desc, ToFFI(&bb));
+  if (!SendDeviceAction(aSelfId, std::move(bb))) {
+    MOZ_CRASH("IPC failure");
+  }
+  return id;
+}
+
+RawId WebGPUChild::DeviceCreatePipelineLayout(
+    RawId aSelfId, const dom::GPUPipelineLayoutDescriptor& aDesc) {
+  nsTArray<ffi::WGPUBindGroupLayoutId> bindGroupLayouts(
+      aDesc.mBindGroupLayouts.Length());
+  for (const auto& layout : aDesc.mBindGroupLayouts) {
+    if (!layout->IsValid()) {
+      return 0;
+    }
+    bindGroupLayouts.AppendElement(layout->mId);
+  }
+
+  ffi::WGPUPipelineLayoutDescriptor desc = {};
+
+  webgpu::StringHelper label(aDesc.mLabel);
+  desc.label = label.Get();
+  desc.bind_group_layouts = bindGroupLayouts.Elements();
+  desc.bind_group_layouts_length = bindGroupLayouts.Length();
+
+  ByteBuf bb;
+  RawId id = ffi::wgpu_client_create_pipeline_layout(mClient.get(), aSelfId,
+                                                     &desc, ToFFI(&bb));
+  if (!SendDeviceAction(aSelfId, std::move(bb))) {
+    MOZ_CRASH("IPC failure");
+  }
+  return id;
+}
+
+RawId WebGPUChild::DeviceCreateBindGroup(
+    RawId aSelfId, const dom::GPUBindGroupDescriptor& aDesc) {
+  if (!aDesc.mLayout->IsValid()) {
+    return 0;
+  }
+
+  nsTArray<ffi::WGPUBindGroupEntry> entries(aDesc.mEntries.Length());
+  for (const auto& entry : aDesc.mEntries) {
+    ffi::WGPUBindGroupEntry e = {};
+    e.binding = entry.mBinding;
+    if (entry.mResource.IsGPUBufferBinding()) {
+      const auto& bufBinding = entry.mResource.GetAsGPUBufferBinding();
+      e.buffer = bufBinding.mBuffer->mId;
+      e.offset = bufBinding.mOffset;
+      e.size = bufBinding.mSize.WasPassed() ? bufBinding.mSize.Value() : 0;
+    }
+    if (entry.mResource.IsGPUTextureView()) {
+      e.texture_view = entry.mResource.GetAsGPUTextureView()->mId;
+    }
+    if (entry.mResource.IsGPUSampler()) {
+      e.sampler = entry.mResource.GetAsGPUSampler()->mId;
+    }
+    entries.AppendElement(e);
+  }
+
+  ffi::WGPUBindGroupDescriptor desc = {};
+
+  webgpu::StringHelper label(aDesc.mLabel);
+  desc.label = label.Get();
+  desc.layout = aDesc.mLayout->mId;
+  desc.entries = entries.Elements();
+  desc.entries_length = entries.Length();
+
+  ByteBuf bb;
+  RawId id = ffi::wgpu_client_create_bind_group(mClient.get(), aSelfId, &desc,
+                                                ToFFI(&bb));
+  if (!SendDeviceAction(aSelfId, std::move(bb))) {
+    MOZ_CRASH("IPC failure");
+  }
+  return id;
+}
+
+already_AddRefed<ShaderModule> WebGPUChild::DeviceCreateShaderModule(
+    Device* aDevice, const dom::GPUShaderModuleDescriptor& aDesc,
+    RefPtr<dom::Promise> aPromise) {
+  RawId deviceId = aDevice->mId;
+  RawId moduleId =
+      ffi::wgpu_client_make_shader_module_id(mClient.get(), deviceId);
+
+  RefPtr<ShaderModule> shaderModule =
+      new ShaderModule(aDevice, moduleId, aPromise);
+
+  nsString noLabel;
+  const nsString& label =
+      aDesc.mLabel.WasPassed() ? aDesc.mLabel.Value() : noLabel;
+  SendDeviceCreateShaderModule(deviceId, moduleId, label, aDesc.mCode)
+      ->Then(
+          GetCurrentSerialEventTarget(), __func__,
+          [aPromise,
+           shaderModule](nsTArray<WebGPUCompilationMessage>&& messages) {
+            RefPtr<CompilationInfo> infoObject(
+                new CompilationInfo(shaderModule));
+            infoObject->SetMessages(messages);
+            aPromise->MaybeResolve(infoObject);
+          },
+          [aPromise](const ipc::ResponseRejectReason& aReason) {
+            aPromise->MaybeRejectWithNotSupportedError("IPC error");
+          });
+
+  return shaderModule.forget();
+}
+
+RawId WebGPUChild::DeviceCreateComputePipelineImpl(
+    PipelineCreationContext* const aContext,
+    const dom::GPUComputePipelineDescriptor& aDesc, ByteBuf* const aByteBuf) {
+  ffi::WGPUComputePipelineDescriptor desc = {};
+  nsCString label, entryPoint;
+  if (aDesc.mLabel.WasPassed()) {
+    LossyCopyUTF16toASCII(aDesc.mLabel.Value(), label);
+    desc.label = label.get();
+  }
+  if (aDesc.mLayout.WasPassed()) {
+    desc.layout = aDesc.mLayout.Value().mId;
+  }
+  desc.stage.module = aDesc.mCompute.mModule->mId;
+  LossyCopyUTF16toASCII(aDesc.mCompute.mEntryPoint, entryPoint);
+  desc.stage.entry_point = entryPoint.get();
+
+  RawId implicit_bgl_ids[WGPUMAX_BIND_GROUPS] = {};
+  RawId id = ffi::wgpu_client_create_compute_pipeline(
+      mClient.get(), aContext->mParentId, &desc, ToFFI(aByteBuf),
+      &aContext->mImplicitPipelineLayoutId, implicit_bgl_ids);
+
+  for (const auto& cur : implicit_bgl_ids) {
+    if (!cur) break;
+    aContext->mImplicitBindGroupLayoutIds.AppendElement(cur);
+  }
+
+  return id;
+}
+
+RawId WebGPUChild::DeviceCreateComputePipeline(
+    PipelineCreationContext* const aContext,
+    const dom::GPUComputePipelineDescriptor& aDesc) {
+  ByteBuf bb;
+  const RawId id = DeviceCreateComputePipelineImpl(aContext, aDesc, &bb);
+
+  if (!SendDeviceAction(aContext->mParentId, std::move(bb))) {
+    MOZ_CRASH("IPC failure");
+  }
+  return id;
+}
+
+RefPtr<PipelinePromise> WebGPUChild::DeviceCreateComputePipelineAsync(
+    PipelineCreationContext* const aContext,
+    const dom::GPUComputePipelineDescriptor& aDesc) {
+  ByteBuf bb;
+  const RawId id = DeviceCreateComputePipelineImpl(aContext, aDesc, &bb);
+
+  return SendDeviceActionWithAck(aContext->mParentId, std::move(bb))
+      ->Then(
+          GetCurrentSerialEventTarget(), __func__,
+          [id](bool aDummy) {
+            Unused << aDummy;
+            return PipelinePromise::CreateAndResolve(id, __func__);
+          },
+          [](const ipc::ResponseRejectReason& aReason) {
+            return PipelinePromise::CreateAndReject(aReason, __func__);
+          });
+}
+
+static ffi::WGPUMultisampleState ConvertMultisampleState(
+    const dom::GPUMultisampleState& aDesc) {
+  ffi::WGPUMultisampleState desc = {};
+  desc.count = aDesc.mCount;
+  desc.mask = aDesc.mMask;
+  desc.alpha_to_coverage_enabled = aDesc.mAlphaToCoverageEnabled;
+  return desc;
+}
+
+static ffi::WGPUBlendComponent ConvertBlendComponent(
+    const dom::GPUBlendComponent& aDesc) {
+  ffi::WGPUBlendComponent desc = {};
+  desc.src_factor = ffi::WGPUBlendFactor(aDesc.mSrcFactor);
+  desc.dst_factor = ffi::WGPUBlendFactor(aDesc.mDstFactor);
+  desc.operation = ffi::WGPUBlendOperation(aDesc.mOperation);
+  return desc;
+}
+
+static ffi::WGPUStencilFaceState ConvertStencilFaceState(
+    const dom::GPUStencilFaceState& aDesc) {
+  ffi::WGPUStencilFaceState desc = {};
+  desc.compare = ConvertCompareFunction(aDesc.mCompare);
+  desc.fail_op = ffi::WGPUStencilOperation(aDesc.mFailOp);
+  desc.depth_fail_op = ffi::WGPUStencilOperation(aDesc.mDepthFailOp);
+  desc.pass_op = ffi::WGPUStencilOperation(aDesc.mPassOp);
+  return desc;
+}
+
+static ffi::WGPUDepthStencilState ConvertDepthStencilState(
+    const dom::GPUDepthStencilState& aDesc) {
+  ffi::WGPUDepthStencilState desc = {};
+  desc.format = ConvertTextureFormat(aDesc.mFormat);
+  desc.depth_write_enabled = aDesc.mDepthWriteEnabled;
+  desc.depth_compare = ConvertCompareFunction(aDesc.mDepthCompare);
+  desc.stencil.front = ConvertStencilFaceState(aDesc.mStencilFront);
+  desc.stencil.back = ConvertStencilFaceState(aDesc.mStencilBack);
+  desc.stencil.read_mask = aDesc.mStencilReadMask;
+  desc.stencil.write_mask = aDesc.mStencilWriteMask;
+  desc.bias.constant = aDesc.mDepthBias;
+  desc.bias.slope_scale = aDesc.mDepthBiasSlopeScale;
+  desc.bias.clamp = aDesc.mDepthBiasClamp;
+  return desc;
+}
+
+RawId WebGPUChild::DeviceCreateRenderPipelineImpl(
+    PipelineCreationContext* const aContext,
+    const dom::GPURenderPipelineDescriptor& aDesc, ByteBuf* const aByteBuf) {
+  // A bunch of stack locals that we can have pointers into
+  nsTArray<ffi::WGPUVertexBufferLayout> vertexBuffers;
+  nsTArray<ffi::WGPUVertexAttribute> vertexAttributes;
+  ffi::WGPURenderPipelineDescriptor desc = {};
+  nsCString vsEntry, fsEntry;
+  ffi::WGPUIndexFormat stripIndexFormat = ffi::WGPUIndexFormat_Uint16;
+  ffi::WGPUFace cullFace = ffi::WGPUFace_Front;
+  ffi::WGPUVertexState vertexState = {};
+  ffi::WGPUFragmentState fragmentState = {};
+  nsTArray<ffi::WGPUColorTargetState> colorStates;
+  nsTArray<ffi::WGPUBlendState> blendStates;
+
+  webgpu::StringHelper label(aDesc.mLabel);
+  desc.label = label.Get();
+
+  if (aDesc.mLayout.WasPassed()) {
+    desc.layout = aDesc.mLayout.Value().mId;
+  }
+
+  {
+    const auto& stage = aDesc.mVertex;
+    vertexState.stage.module = stage.mModule->mId;
+    LossyCopyUTF16toASCII(stage.mEntryPoint, vsEntry);
+    vertexState.stage.entry_point = vsEntry.get();
+
+    for (const auto& vertex_desc : stage.mBuffers) {
+      ffi::WGPUVertexBufferLayout vb_desc = {};
+      if (!vertex_desc.IsNull()) {
+        const auto& vd = vertex_desc.Value();
+        vb_desc.array_stride = vd.mArrayStride;
+        vb_desc.step_mode = ffi::WGPUVertexStepMode(vd.mStepMode);
+        // Note: we are setting the length but not the pointer
+        vb_desc.attributes_length = vd.mAttributes.Length();
+        for (const auto& vat : vd.mAttributes) {
+          ffi::WGPUVertexAttribute ad = {};
+          ad.offset = vat.mOffset;
+          ad.format = ffi::WGPUVertexFormat(vat.mFormat);
+          ad.shader_location = vat.mShaderLocation;
+          vertexAttributes.AppendElement(ad);
+        }
+      }
+      vertexBuffers.AppendElement(vb_desc);
+    }
+    // Now patch up all the pointers to attribute lists.
+    size_t numAttributes = 0;
+    for (auto& vb_desc : vertexBuffers) {
+      vb_desc.attributes = vertexAttributes.Elements() + numAttributes;
+      numAttributes += vb_desc.attributes_length;
+    }
+
+    vertexState.buffers = vertexBuffers.Elements();
+    vertexState.buffers_length = vertexBuffers.Length();
+    desc.vertex = &vertexState;
+  }
+
+  if (aDesc.mFragment.WasPassed()) {
+    const auto& stage = aDesc.mFragment.Value();
+    fragmentState.stage.module = stage.mModule->mId;
+    LossyCopyUTF16toASCII(stage.mEntryPoint, fsEntry);
+    fragmentState.stage.entry_point = fsEntry.get();
+
+    // Note: we pre-collect the blend states into a different array
+    // so that we can have non-stale pointers into it.
+    for (const auto& colorState : stage.mTargets) {
+      ffi::WGPUColorTargetState desc = {};
+      desc.format = ConvertTextureFormat(colorState.mFormat);
+      desc.write_mask = colorState.mWriteMask;
+      colorStates.AppendElement(desc);
+      ffi::WGPUBlendState bs = {};
+      if (colorState.mBlend.WasPassed()) {
+        const auto& blend = colorState.mBlend.Value();
+        bs.alpha = ConvertBlendComponent(blend.mAlpha);
+        bs.color = ConvertBlendComponent(blend.mColor);
+      }
+      blendStates.AppendElement(bs);
+    }
+    for (size_t i = 0; i < colorStates.Length(); ++i) {
+      if (stage.mTargets[i].mBlend.WasPassed()) {
+        colorStates[i].blend = &blendStates[i];
+      }
+    }
+
+    fragmentState.targets = colorStates.Elements();
+    fragmentState.targets_length = colorStates.Length();
+    desc.fragment = &fragmentState;
+  }
+
+  {
+    const auto& prim = aDesc.mPrimitive;
+    desc.primitive.topology = ffi::WGPUPrimitiveTopology(prim.mTopology);
+    if (prim.mStripIndexFormat.WasPassed()) {
+      stripIndexFormat = ffi::WGPUIndexFormat(prim.mStripIndexFormat.Value());
+      desc.primitive.strip_index_format = &stripIndexFormat;
+    }
+    desc.primitive.front_face = ffi::WGPUFrontFace(prim.mFrontFace);
+    if (prim.mCullMode != dom::GPUCullMode::None) {
+      cullFace = prim.mCullMode == dom::GPUCullMode::Front ? ffi::WGPUFace_Front
+                                                           : ffi::WGPUFace_Back;
+      desc.primitive.cull_mode = &cullFace;
+    }
+  }
+  desc.multisample = ConvertMultisampleState(aDesc.mMultisample);
+
+  ffi::WGPUDepthStencilState depthStencilState = {};
+  if (aDesc.mDepthStencil.WasPassed()) {
+    depthStencilState = ConvertDepthStencilState(aDesc.mDepthStencil.Value());
+    desc.depth_stencil = &depthStencilState;
+  }
+
+  RawId implicit_bgl_ids[WGPUMAX_BIND_GROUPS] = {};
+  RawId id = ffi::wgpu_client_create_render_pipeline(
+      mClient.get(), aContext->mParentId, &desc, ToFFI(aByteBuf),
+      &aContext->mImplicitPipelineLayoutId, implicit_bgl_ids);
+
+  for (const auto& cur : implicit_bgl_ids) {
+    if (!cur) break;
+    aContext->mImplicitBindGroupLayoutIds.AppendElement(cur);
+  }
+
+  return id;
+}
+
+RawId WebGPUChild::DeviceCreateRenderPipeline(
+    PipelineCreationContext* const aContext,
+    const dom::GPURenderPipelineDescriptor& aDesc) {
+  ByteBuf bb;
+  const RawId id = DeviceCreateRenderPipelineImpl(aContext, aDesc, &bb);
+
+  if (!SendDeviceAction(aContext->mParentId, std::move(bb))) {
+    MOZ_CRASH("IPC failure");
+  }
+  return id;
+}
+
+RefPtr<PipelinePromise> WebGPUChild::DeviceCreateRenderPipelineAsync(
+    PipelineCreationContext* const aContext,
+    const dom::GPURenderPipelineDescriptor& aDesc) {
+  ByteBuf bb;
+  const RawId id = DeviceCreateRenderPipelineImpl(aContext, aDesc, &bb);
+
+  return SendDeviceActionWithAck(aContext->mParentId, std::move(bb))
+      ->Then(
+          GetCurrentSerialEventTarget(), __func__,
+          [id](bool aDummy) {
+            Unused << aDummy;
+            return PipelinePromise::CreateAndResolve(id, __func__);
+          },
+          [](const ipc::ResponseRejectReason& aReason) {
+            return PipelinePromise::CreateAndReject(aReason, __func__);
+          });
+}
+
+ipc::IPCResult WebGPUChild::RecvDeviceUncapturedError(
+    RawId aDeviceId, const nsACString& aMessage) {
+  auto targetIter = mDeviceMap.find(aDeviceId);
+  if (!aDeviceId || targetIter == mDeviceMap.end()) {
+    JsWarning(nullptr, aMessage);
+  } else {
+    auto* target = targetIter->second.get();
+    MOZ_ASSERT(target);
+    // We don't want to spam the errors to the console indefinitely
+    if (target->CheckNewWarning(aMessage)) {
+      JsWarning(target->GetOwnerGlobal(), aMessage);
+
+      dom::GPUUncapturedErrorEventInit init;
+      init.mError.SetAsGPUValidationError() =
+          new ValidationError(target->GetParentObject(), aMessage);
+      RefPtr<mozilla::dom::GPUUncapturedErrorEvent> event =
+          dom::GPUUncapturedErrorEvent::Constructor(
+              target, u"uncapturederror"_ns, init);
+      target->DispatchEvent(*event);
+    }
+  }
+  return IPC_OK();
+}
+
+ipc::IPCResult WebGPUChild::RecvDropAction(const ipc::ByteBuf& aByteBuf) {
+  const auto* byteBuf = ToFFI(&aByteBuf);
+  ffi::wgpu_client_drop_action(mClient.get(), byteBuf);
+  return IPC_OK();
+}
+
+void WebGPUChild::DeviceCreateSwapChain(
+    RawId aSelfId, const RGBDescriptor& aRgbDesc, size_t maxBufferCount,
+    const layers::RemoteTextureOwnerId& aOwnerId) {
+  RawId queueId = aSelfId;  // TODO: multiple queues
+  nsTArray<RawId> bufferIds(maxBufferCount);
+  for (size_t i = 0; i < maxBufferCount; ++i) {
+    bufferIds.AppendElement(
+        ffi::wgpu_client_make_buffer_id(mClient.get(), aSelfId));
+  }
+  SendDeviceCreateSwapChain(aSelfId, queueId, aRgbDesc, bufferIds, aOwnerId);
+}
+
+void WebGPUChild::SwapChainPresent(RawId aTextureId,
+                                   const RemoteTextureId& aRemoteTextureId,
+                                   const RemoteTextureOwnerId& aOwnerId) {
+  // Hack: the function expects `DeviceId`, but it only uses it for `backend()`
+  // selection.
+  RawId encoderId = ffi::wgpu_client_make_encoder_id(mClient.get(), aTextureId);
+  SendSwapChainPresent(aTextureId, encoderId, aRemoteTextureId, aOwnerId);
+}
+
+void WebGPUChild::RegisterDevice(Device* const aDevice) {
+  mDeviceMap.insert({aDevice->mId, aDevice});
+}
+
+void WebGPUChild::UnregisterDevice(RawId aId) {
+  mDeviceMap.erase(aId);
+  if (IsOpen()) {
+    SendDeviceDestroy(aId);
+  }
+}
+
+void WebGPUChild::FreeUnregisteredInParentDevice(RawId aId) {
+  ffi::wgpu_client_kill_device_id(mClient.get(), aId);
+  mDeviceMap.erase(aId);
+}
+
+void WebGPUChild::ActorDestroy(ActorDestroyReason) {
+  // Resolving the promise could cause us to update the original map if the
+  // callee frees the Device objects immediately. Since any remaining entries
+  // in the map are no longer valid, we can just move the map onto the stack.
+  const auto deviceMap = std::move(mDeviceMap);
+  mDeviceMap.clear();
+
+  for (const auto& targetIter : deviceMap) {
+    RefPtr<Device> device = targetIter.second.get();
+    if (!device) {
+      // The Device may have gotten freed when we resolved the Promise for
+      // another Device in the map.
+      continue;
+    }
+
+    RefPtr<dom::Promise> promise = device->MaybeGetLost();
+    if (!promise) {
+      continue;
+    }
+
+    auto info = MakeRefPtr<DeviceLostInfo>(device->GetParentObject(),
+                                           u"WebGPUChild destroyed"_ns);
+
+    // We have strong references to both the Device and the DeviceLostInfo and
+    // the Promise objects on the stack which keeps them alive for long enough.
+    promise->MaybeResolve(info);
+  }
+}
+
+}  // namespace mozilla::webgpu
diff --git a/dom/webgpu/ipc/WebGPUChild.h b/dom/webgpu/ipc/WebGPUChild.h
new file mode 100644
index 0000000000..7ab993239c
--- /dev/null
+++ b/dom/webgpu/ipc/WebGPUChild.h
@@ -0,0 +1,146 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef WEBGPU_CHILD_H_
+#define WEBGPU_CHILD_H_
+
+#include "mozilla/webgpu/PWebGPUChild.h"
+#include "mozilla/MozPromise.h"
+#include "mozilla/WeakPtr.h"
+#include "mozilla/webgpu/ffi/wgpu.h"
+
+namespace mozilla {
+namespace ipc {
+class UnsafeSharedMemoryHandle;
+}  // namespace ipc
+namespace dom {
+struct GPURequestAdapterOptions;
+}  // namespace dom
+namespace layers {
+class CompositorBridgeChild;
+}  // namespace layers
+namespace webgpu {
+namespace ffi {
+struct WGPUClient;
+struct WGPULimits;
+struct WGPUTextureViewDescriptor;
+}  // namespace ffi
+
+using AdapterPromise =
+    MozPromise<ipc::ByteBuf, Maybe<ipc::ResponseRejectReason>, true>;
+using PipelinePromise = MozPromise<RawId, ipc::ResponseRejectReason, true>;
+using DevicePromise = MozPromise<bool, ipc::ResponseRejectReason, true>;
+
+struct PipelineCreationContext {
+  RawId mParentId = 0;
+  RawId mImplicitPipelineLayoutId = 0;
+  nsTArray<RawId> mImplicitBindGroupLayoutIds;
+};
+
+struct DeviceRequest {
+  RawId mId = 0;
+  RefPtr<DevicePromise> mPromise;
+  // Note: we could put `ffi::WGPULimits` in here as well,
+  //  but we don't want to #include ffi stuff in this header
+};
+
+ffi::WGPUByteBuf* ToFFI(ipc::ByteBuf* x);
+
+class WebGPUChild final : public PWebGPUChild, public SupportsWeakPtr {
+ public:
+  friend class layers::CompositorBridgeChild;
+
+  NS_DECL_CYCLE_COLLECTION_NATIVE_CLASS(WebGPUChild)
+  NS_INLINE_DECL_CYCLE_COLLECTING_NATIVE_REFCOUNTING_INHERITED(WebGPUChild)
+
+ public:
+  explicit WebGPUChild();
+
+  bool IsOpen() const { return CanSend(); }
+
+  RefPtr<AdapterPromise> InstanceRequestAdapter(
+      const dom::GPURequestAdapterOptions& aOptions);
+  Maybe<DeviceRequest> AdapterRequestDevice(
+      RawId aSelfId, const dom::GPUDeviceDescriptor& aDesc,
+      ffi::WGPULimits* aLimits);
+  RawId DeviceCreateBuffer(RawId aSelfId, const dom::GPUBufferDescriptor& aDesc,
+                           ipc::UnsafeSharedMemoryHandle&& aShmem);
+  RawId DeviceCreateTexture(RawId aSelfId,
+                            const dom::GPUTextureDescriptor& aDesc);
+  RawId TextureCreateView(RawId aSelfId, RawId aDeviceId,
+                          const dom::GPUTextureViewDescriptor& aDesc);
+  RawId DeviceCreateSampler(RawId aSelfId,
+                            const dom::GPUSamplerDescriptor& aDesc);
+  RawId DeviceCreateCommandEncoder(
+      RawId aSelfId, const dom::GPUCommandEncoderDescriptor& aDesc);
+  RawId CommandEncoderFinish(RawId aSelfId, RawId aDeviceId,
+                             const dom::GPUCommandBufferDescriptor& aDesc);
+  RawId RenderBundleEncoderFinish(ffi::WGPURenderBundleEncoder& aEncoder,
+                                  RawId aDeviceId,
+                                  const dom::GPURenderBundleDescriptor& aDesc);
+  RawId DeviceCreateBindGroupLayout(
+      RawId aSelfId, const dom::GPUBindGroupLayoutDescriptor& aDesc);
+  RawId DeviceCreatePipelineLayout(
+      RawId aSelfId, const dom::GPUPipelineLayoutDescriptor& aDesc);
+  RawId DeviceCreateBindGroup(RawId aSelfId,
+                              const dom::GPUBindGroupDescriptor& aDesc);
+  RawId DeviceCreateComputePipeline(
+      PipelineCreationContext* const aContext,
+      const dom::GPUComputePipelineDescriptor& aDesc);
+  RefPtr<PipelinePromise> DeviceCreateComputePipelineAsync(
+      PipelineCreationContext* const aContext,
+      const dom::GPUComputePipelineDescriptor& aDesc);
+  RawId DeviceCreateRenderPipeline(
+      PipelineCreationContext* const aContext,
+      const dom::GPURenderPipelineDescriptor& aDesc);
+  RefPtr<PipelinePromise> DeviceCreateRenderPipelineAsync(
+      PipelineCreationContext* const aContext,
+      const dom::GPURenderPipelineDescriptor& aDesc);
+  already_AddRefed<ShaderModule> DeviceCreateShaderModule(
+      Device* aDevice, const dom::GPUShaderModuleDescriptor& aDesc,
+      RefPtr<dom::Promise> aPromise);
+
+  void DeviceCreateSwapChain(RawId aSelfId, const RGBDescriptor& aRgbDesc,
+                             size_t maxBufferCount,
+                             const layers::RemoteTextureOwnerId& aOwnerId);
+  void SwapChainPresent(RawId aTextureId,
+                        const RemoteTextureId& aRemoteTextureId,
+                        const RemoteTextureOwnerId& aOwnerId);
+
+  void RegisterDevice(Device* const aDevice);
+  void UnregisterDevice(RawId aId);
+  void FreeUnregisteredInParentDevice(RawId aId);
+
+  static void ConvertTextureFormatRef(const dom::GPUTextureFormat& aInput,
+                                      ffi::WGPUTextureFormat& aOutput);
+
+ private:
+  virtual ~WebGPUChild();
+
+  void JsWarning(nsIGlobalObject* aGlobal, const nsACString& aMessage);
+
+  RawId DeviceCreateComputePipelineImpl(
+      PipelineCreationContext* const aContext,
+      const dom::GPUComputePipelineDescriptor& aDesc,
+      ipc::ByteBuf* const aByteBuf);
+  RawId DeviceCreateRenderPipelineImpl(
+      PipelineCreationContext* const aContext,
+      const dom::GPURenderPipelineDescriptor& aDesc,
+      ipc::ByteBuf* const aByteBuf);
+
+  UniquePtr<ffi::WGPUClient> const mClient;
+  std::unordered_map<RawId, WeakPtr<Device>> mDeviceMap;
+
+ public:
+  ipc::IPCResult RecvDeviceUncapturedError(RawId aDeviceId,
+                                           const nsACString& aMessage);
+  ipc::IPCResult RecvDropAction(const ipc::ByteBuf& aByteBuf);
+  void ActorDestroy(ActorDestroyReason) override;
+};
+
+}  // namespace webgpu
+}  // namespace mozilla
+
+#endif  // WEBGPU_CHILD_H_
diff --git a/dom/webgpu/ipc/WebGPUParent.cpp b/dom/webgpu/ipc/WebGPUParent.cpp
new file mode 100644
index 0000000000..f3f9515319
--- /dev/null
+++ b/dom/webgpu/ipc/WebGPUParent.cpp
@@ -0,0 +1,1116 @@
+/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "WebGPUParent.h"
+#include "mozilla/PodOperations.h"
+#include "mozilla/webgpu/ffi/wgpu.h"
+#include "mozilla/layers/CompositorThread.h"
+#include "mozilla/layers/ImageDataSerializer.h"
+#include "mozilla/layers/RemoteTextureMap.h"
+#include "mozilla/layers/TextureHost.h"
+#include "mozilla/layers/WebRenderImageHost.h"
+#include "mozilla/layers/WebRenderTextureHost.h"
+
+namespace mozilla::webgpu {
+
+const uint64_t POLL_TIME_MS = 100;
+
+static mozilla::LazyLogModule sLogger("WebGPU");
+
+// A fixed-capacity buffer for receiving textual error messages from
+// `wgpu_bindings`.
+//
+// The `ToFFI` method returns an `ffi::WGPUErrorBuffer` pointing to our
+// buffer, for you to pass to fallible FFI-visible `wgpu_bindings`
+// functions. These indicate failure by storing an error message in the
+// buffer, which you can retrieve by calling `GetError`.
+//
+// If you call `ToFFI` on this type, you must also call `GetError` to check for
+// an error. Otherwise, the destructor asserts.
+//
+// TODO: refactor this to avoid stack-allocating the buffer all the time.
+class ErrorBuffer {
+  // if the message doesn't fit, it will be truncated
+  static constexpr unsigned BUFFER_SIZE = 512;
+  char mUtf8[BUFFER_SIZE] = {};
+  bool mGuard = false;
+
+ public:
+  ErrorBuffer() { mUtf8[0] = 0; }
+  ErrorBuffer(const ErrorBuffer&) = delete;
+  ~ErrorBuffer() { MOZ_ASSERT(!mGuard); }
+
+  ffi::WGPUErrorBuffer ToFFI() {
+    mGuard = true;
+    ffi::WGPUErrorBuffer errorBuf = {mUtf8, BUFFER_SIZE};
+    return errorBuf;
+  }
+
+  // If an error message was stored in this buffer, return Some(m)
+  // where m is the message as a UTF-8 nsCString. Otherwise, return Nothing.
+  //
+  // Mark this ErrorBuffer as having been handled, so its destructor
+  // won't assert.
+  Maybe<nsCString> GetError() {
+    mGuard = false;
+    if (!mUtf8[0]) {
+      return Nothing();
+    }
+    return Some(nsCString(mUtf8));
+  }
+};
+
+class PresentationData {
+  NS_INLINE_DECL_REFCOUNTING(PresentationData);
+
+ public:
+  RawId mDeviceId = 0;
+  RawId mQueueId = 0;
+  layers::RGBDescriptor mDesc;
+  uint32_t mSourcePitch = 0;
+  int32_t mNextFrameID = 1;
+  std::vector<RawId> mUnassignedBufferIds;
+  std::vector<RawId> mAvailableBufferIds;
+  std::vector<RawId> mQueuedBufferIds;
+  Mutex mBuffersLock MOZ_UNANNOTATED;
+
+  PresentationData(RawId aDeviceId, RawId aQueueId,
+                   const layers::RGBDescriptor& aDesc, uint32_t aSourcePitch,
+                   const nsTArray<RawId>& aBufferIds)
+      : mDeviceId(aDeviceId),
+        mQueueId(aQueueId),
+        mDesc(aDesc),
+        mSourcePitch(aSourcePitch),
+        mBuffersLock("WebGPU presentation buffers") {
+    MOZ_COUNT_CTOR(PresentationData);
+
+    for (const RawId id : aBufferIds) {
+      mUnassignedBufferIds.push_back(id);
+    }
+  }
+
+ private:
+  ~PresentationData() { MOZ_COUNT_DTOR(PresentationData); }
+};
+
+static void FreeAdapter(RawId id, void* param) {
+  ipc::ByteBuf byteBuf;
+  wgpu_server_adapter_free(id, ToFFI(&byteBuf));
+  if (!static_cast<WebGPUParent*>(param)->SendDropAction(std::move(byteBuf))) {
+    NS_ERROR("Unable FreeAdapter");
+  }
+}
+static void FreeDevice(RawId id, void* param) {
+  ipc::ByteBuf byteBuf;
+  wgpu_server_device_free(id, ToFFI(&byteBuf));
+  if (!static_cast<WebGPUParent*>(param)->SendDropAction(std::move(byteBuf))) {
+    NS_ERROR("Unable FreeDevice");
+  }
+}
+static void FreeShaderModule(RawId id, void* param) {
+  ipc::ByteBuf byteBuf;
+  wgpu_server_shader_module_free(id, ToFFI(&byteBuf));
+  if (!static_cast<WebGPUParent*>(param)->SendDropAction(std::move(byteBuf))) {
+    NS_ERROR("Unable FreeShaderModule");
+  }
+}
+static void FreePipelineLayout(RawId id, void* param) {
+  ipc::ByteBuf byteBuf;
+  wgpu_server_pipeline_layout_free(id, ToFFI(&byteBuf));
+  if (!static_cast<WebGPUParent*>(param)->SendDropAction(std::move(byteBuf))) {
+    NS_ERROR("Unable FreePipelineLayout");
+  }
+}
+static void FreeBindGroupLayout(RawId id, void* param) {
+  ipc::ByteBuf byteBuf;
+  wgpu_server_bind_group_layout_free(id, ToFFI(&byteBuf));
+  if (!static_cast<WebGPUParent*>(param)->SendDropAction(std::move(byteBuf))) {
+    NS_ERROR("Unable FreeBindGroupLayout");
+  }
+}
+static void FreeBindGroup(RawId id, void* param) {
+  ipc::ByteBuf byteBuf;
+  wgpu_server_bind_group_free(id, ToFFI(&byteBuf));
+  if (!static_cast<WebGPUParent*>(param)->SendDropAction(std::move(byteBuf))) {
+    NS_ERROR("Unable FreeBindGroup");
+  }
+}
+static void FreeCommandBuffer(RawId id, void* param) {
+  ipc::ByteBuf byteBuf;
+  wgpu_server_command_buffer_free(id, ToFFI(&byteBuf));
+  if (!static_cast<WebGPUParent*>(param)->SendDropAction(std::move(byteBuf))) {
+    NS_ERROR("Unable FreeCommandBuffer");
+  }
+}
+static void FreeRenderBundle(RawId id, void* param) {
+  ipc::ByteBuf byteBuf;
+  wgpu_server_render_bundle_free(id, ToFFI(&byteBuf));
+  if (!static_cast<WebGPUParent*>(param)->SendDropAction(std::move(byteBuf))) {
+    NS_ERROR("Unable FreeRenderBundle");
+  }
+}
+static void FreeRenderPipeline(RawId id, void* param) {
+  ipc::ByteBuf byteBuf;
+  wgpu_server_render_pipeline_free(id, ToFFI(&byteBuf));
+  if (!static_cast<WebGPUParent*>(param)->SendDropAction(std::move(byteBuf))) {
+    NS_ERROR("Unable FreeRenderPipeline");
+  }
+}
+static void FreeComputePipeline(RawId id, void* param) {
+  ipc::ByteBuf byteBuf;
+  wgpu_server_compute_pipeline_free(id, ToFFI(&byteBuf));
+  if (!static_cast<WebGPUParent*>(param)->SendDropAction(std::move(byteBuf))) {
+    NS_ERROR("Unable FreeComputePipeline");
+  }
+}
+static void FreeBuffer(RawId id, void* param) {
+  ipc::ByteBuf byteBuf;
+  wgpu_server_buffer_free(id, ToFFI(&byteBuf));
+  if (!static_cast<WebGPUParent*>(param)->SendDropAction(std::move(byteBuf))) {
+    NS_ERROR("Unable FreeBuffer");
+  }
+}
+static void FreeTexture(RawId id, void* param) {
+  ipc::ByteBuf byteBuf;
+  wgpu_server_texture_free(id, ToFFI(&byteBuf));
+  if (!static_cast<WebGPUParent*>(param)->SendDropAction(std::move(byteBuf))) {
+    NS_ERROR("Unable FreeTexture");
+  }
+}
+static void FreeTextureView(RawId id, void* param) {
+  ipc::ByteBuf byteBuf;
+  wgpu_server_texture_view_free(id, ToFFI(&byteBuf));
+  if (!static_cast<WebGPUParent*>(param)->SendDropAction(std::move(byteBuf))) {
+    NS_ERROR("Unable FreeTextureView");
+  }
+}
+static void FreeSampler(RawId id, void* param) {
+  ipc::ByteBuf byteBuf;
+  wgpu_server_sampler_free(id, ToFFI(&byteBuf));
+  if (!static_cast<WebGPUParent*>(param)->SendDropAction(std::move(byteBuf))) {
+    NS_ERROR("Unable FreeSampler");
+  }
+}
+static void FreeSurface(RawId id, void* param) {
+  Unused << id;
+  Unused << param;
+}
+
+static ffi::WGPUIdentityRecyclerFactory MakeFactory(void* param) {
+  ffi::WGPUIdentityRecyclerFactory factory;
+  PodZero(&factory);
+  factory.param = param;
+  factory.free_adapter = FreeAdapter;
+  factory.free_device = FreeDevice;
+  factory.free_pipeline_layout = FreePipelineLayout;
+  factory.free_shader_module = FreeShaderModule;
+  factory.free_bind_group_layout = FreeBindGroupLayout;
+  factory.free_bind_group = FreeBindGroup;
+  factory.free_command_buffer = FreeCommandBuffer;
+  factory.free_render_bundle = FreeRenderBundle;
+  factory.free_render_pipeline = FreeRenderPipeline;
+  factory.free_compute_pipeline = FreeComputePipeline;
+  factory.free_buffer = FreeBuffer;
+  factory.free_texture = FreeTexture;
+  factory.free_texture_view = FreeTextureView;
+  factory.free_sampler = FreeSampler;
+  factory.free_surface = FreeSurface;
+  return factory;
+}
+
+WebGPUParent::WebGPUParent()
+    : mContext(ffi::wgpu_server_new(MakeFactory(this))) {
+  mTimer.Start(base::TimeDelta::FromMilliseconds(POLL_TIME_MS), this,
+               &WebGPUParent::MaintainDevices);
+}
+
+WebGPUParent::~WebGPUParent() = default;
+
+void WebGPUParent::MaintainDevices() {
+  ffi::wgpu_server_poll_all_devices(mContext.get(), false);
+}
+
+bool WebGPUParent::ForwardError(RawId aDeviceId, ErrorBuffer& aError) {
+  // don't do anything if the error is empty
+  auto cString = aError.GetError();
+  if (!cString) {
+    return false;
+  }
+
+  ReportError(aDeviceId, cString.value());
+
+  return true;
+}
+
+// Generate an error on the Device timeline of aDeviceId.
+// aMessage is interpreted as UTF-8.
+void WebGPUParent::ReportError(RawId aDeviceId, const nsCString& aMessage) {
+  // find the appropriate error scope
+  const auto& lookup = mErrorScopeMap.find(aDeviceId);
+  if (lookup != mErrorScopeMap.end() && !lookup->second.mStack.IsEmpty()) {
+    auto& last = lookup->second.mStack.LastElement();
+    if (last.isNothing()) {
+      last.emplace(ScopedError{false, aMessage});
+    }
+  } else {
+    // fall back to the uncaptured error handler
+    if (!SendDeviceUncapturedError(aDeviceId, aMessage)) {
+      NS_ERROR("Unable to SendError");
+    }
+  }
+}
+
+ipc::IPCResult WebGPUParent::RecvInstanceRequestAdapter(
+    const dom::GPURequestAdapterOptions& aOptions,
+    const nsTArray<RawId>& aTargetIds,
+    InstanceRequestAdapterResolver&& resolver) {
+  ffi::WGPURequestAdapterOptions options = {};
+  if (aOptions.mPowerPreference.WasPassed()) {
+    options.power_preference = static_cast<ffi::WGPUPowerPreference>(
+        aOptions.mPowerPreference.Value());
+  }
+  options.force_fallback_adapter = aOptions.mForceFallbackAdapter;
+  // TODO: make available backends configurable by prefs
+
+  ErrorBuffer error;
+  int8_t index = ffi::wgpu_server_instance_request_adapter(
+      mContext.get(), &options, aTargetIds.Elements(), aTargetIds.Length(),
+      error.ToFFI());
+
+  ByteBuf infoByteBuf;
+  // Rust side expects an `Option`, so 0 maps to `None`.
+  uint64_t adapterId = 0;
+  if (index >= 0) {
+    adapterId = aTargetIds[index];
+  }
+  ffi::wgpu_server_adapter_pack_info(mContext.get(), adapterId,
+                                     ToFFI(&infoByteBuf));
+  resolver(std::move(infoByteBuf));
+  ForwardError(0, error);
+
+  // free the unused IDs
+  ipc::ByteBuf dropByteBuf;
+  for (size_t i = 0; i < aTargetIds.Length(); ++i) {
+    if (static_cast<int8_t>(i) != index) {
+      wgpu_server_adapter_free(aTargetIds[i], ToFFI(&dropByteBuf));
+    }
+  }
+  if (dropByteBuf.mData && !SendDropAction(std::move(dropByteBuf))) {
+    NS_ERROR("Unable to free free unused adapter IDs");
+  }
+  return IPC_OK();
+}
+
+ipc::IPCResult WebGPUParent::RecvAdapterRequestDevice(
+    RawId aAdapterId, const ipc::ByteBuf& aByteBuf, RawId aDeviceId,
+    AdapterRequestDeviceResolver&& resolver) {
+  ErrorBuffer error;
+  ffi::wgpu_server_adapter_request_device(
+      mContext.get(), aAdapterId, ToFFI(&aByteBuf), aDeviceId, error.ToFFI());
+  if (ForwardError(0, error)) {
+    resolver(false);
+  } else {
+    mErrorScopeMap.insert({aAdapterId, ErrorScopeStack()});
+    resolver(true);
+  }
+  return IPC_OK();
+}
+
+ipc::IPCResult WebGPUParent::RecvAdapterDestroy(RawId aAdapterId) {
+  ffi::wgpu_server_adapter_drop(mContext.get(), aAdapterId);
+  return IPC_OK();
+}
+
+ipc::IPCResult WebGPUParent::RecvDeviceDestroy(RawId aDeviceId) {
+  ffi::wgpu_server_device_drop(mContext.get(), aDeviceId);
+  mErrorScopeMap.erase(aDeviceId);
+  return IPC_OK();
+}
+
+WebGPUParent::BufferMapData* WebGPUParent::GetBufferMapData(RawId aBufferId) {
+  const auto iter = mSharedMemoryMap.find(aBufferId);
+  if (iter == mSharedMemoryMap.end()) {
+    return nullptr;
+  }
+
+  return &iter->second;
+}
+
+ipc::IPCResult WebGPUParent::RecvCreateBuffer(
+    RawId aDeviceId, RawId aBufferId, dom::GPUBufferDescriptor&& aDesc,
+    ipc::UnsafeSharedMemoryHandle&& aShmem) {
+  webgpu::StringHelper label(aDesc.mLabel);
+
+  auto shmem =
+      ipc::WritableSharedMemoryMapping::Open(std::move(aShmem)).value();
+
+  bool hasMapFlags = aDesc.mUsage & (dom::GPUBufferUsage_Binding::MAP_WRITE |
+                                     dom::GPUBufferUsage_Binding::MAP_READ);
+  if (hasMapFlags || aDesc.mMappedAtCreation) {
+    uint64_t offset = 0;
+    uint64_t size = 0;
+    if (aDesc.mMappedAtCreation) {
+      size = aDesc.mSize;
+      MOZ_RELEASE_ASSERT(shmem.Size() >= aDesc.mSize);
+    }
+
+    BufferMapData data = {std::move(shmem), hasMapFlags, offset, size};
+    mSharedMemoryMap.insert({aBufferId, std::move(data)});
+  }
+
+  ErrorBuffer error;
+  ffi::wgpu_server_device_create_buffer(mContext.get(), aDeviceId, aBufferId,
+                                        label.Get(), aDesc.mSize, aDesc.mUsage,
+                                        aDesc.mMappedAtCreation, error.ToFFI());
+  ForwardError(aDeviceId, error);
+  return IPC_OK();
+}
+
+struct MapRequest {
+  RefPtr<WebGPUParent> mParent;
+  ffi::WGPUGlobal* mContext;
+  ffi::WGPUBufferId mBufferId;
+  ffi::WGPUHostMap mHostMap;
+  uint64_t mOffset;
+  uint64_t mSize;
+  WebGPUParent::BufferMapResolver mResolver;
+};
+
+nsCString MapStatusString(ffi::WGPUBufferMapAsyncStatus status) {
+  switch (status) {
+    case ffi::WGPUBufferMapAsyncStatus_Success:
+      return nsCString("Success");
+    case ffi::WGPUBufferMapAsyncStatus_AlreadyMapped:
+      return nsCString("Already mapped");
+    case ffi::WGPUBufferMapAsyncStatus_MapAlreadyPending:
+      return nsCString("Map is already pending");
+    case ffi::WGPUBufferMapAsyncStatus_Aborted:
+      return nsCString("Map aborted");
+    case ffi::WGPUBufferMapAsyncStatus_ContextLost:
+      return nsCString("Context lost");
+    case ffi::WGPUBufferMapAsyncStatus_Invalid:
+      return nsCString("Invalid buffer");
+    case ffi::WGPUBufferMapAsyncStatus_InvalidRange:
+      return nsCString("Invalid range");
+    case ffi::WGPUBufferMapAsyncStatus_InvalidAlignment:
+      return nsCString("Invalid alignment");
+    case ffi::WGPUBufferMapAsyncStatus_InvalidUsageFlags:
+      return nsCString("Invalid usage flags");
+    case ffi::WGPUBufferMapAsyncStatus_Error:
+      return nsCString("Map failed");
+    case ffi::WGPUBufferMapAsyncStatus_Sentinel:  // For -Wswitch
+      break;
+  }
+
+  MOZ_CRASH("Bad ffi::WGPUBufferMapAsyncStatus");
+}
+
+static void MapCallback(ffi::WGPUBufferMapAsyncStatus status,
+                        uint8_t* userdata) {
+  auto* req = reinterpret_cast<MapRequest*>(userdata);
+
+  if (!req->mParent->CanSend()) {
+    delete req;
+    return;
+  }
+
+  BufferMapResult result;
+
+  auto bufferId = req->mBufferId;
+  auto* mapData = req->mParent->GetBufferMapData(bufferId);
+  MOZ_RELEASE_ASSERT(mapData);
+
+  if (status != ffi::WGPUBufferMapAsyncStatus_Success) {
+    result = BufferMapError(MapStatusString(status));
+  } else {
+    auto size = req->mSize;
+    auto offset = req->mOffset;
+
+    if (req->mHostMap == ffi::WGPUHostMap_Read && size > 0) {
+      const auto src = ffi::wgpu_server_buffer_get_mapped_range(
+          req->mContext, req->mBufferId, offset, size);
+
+      MOZ_RELEASE_ASSERT(mapData->mShmem.Size() >= offset + size);
+      if (src.ptr != nullptr && src.length >= size) {
+        auto dst = mapData->mShmem.Bytes().Subspan(offset, size);
+        memcpy(dst.data(), src.ptr, size);
+      }
+    }
+
+    result =
+        BufferMapSuccess(offset, size, req->mHostMap == ffi::WGPUHostMap_Write);
+
+    mapData->mMappedOffset = offset;
+    mapData->mMappedSize = size;
+  }
+
+  req->mResolver(std::move(result));
+  delete req;
+}
+
+ipc::IPCResult WebGPUParent::RecvBufferMap(RawId aBufferId, uint32_t aMode,
+                                           uint64_t aOffset, uint64_t aSize,
+                                           BufferMapResolver&& aResolver) {
+  MOZ_LOG(sLogger, LogLevel::Info,
+          ("RecvBufferMap %" PRIu64 " offset=%" PRIu64 " size=%" PRIu64 "\n",
+           aBufferId, aOffset, aSize));
+
+  ffi::WGPUHostMap mode;
+  switch (aMode) {
+    case dom::GPUMapMode_Binding::READ:
+      mode = ffi::WGPUHostMap_Read;
+      break;
+    case dom::GPUMapMode_Binding::WRITE:
+      mode = ffi::WGPUHostMap_Write;
+      break;
+    default: {
+      nsCString errorString(
+          "GPUBuffer.mapAsync 'mode' argument must be either GPUMapMode.READ "
+          "or GPUMapMode.WRITE");
+      aResolver(BufferMapError(errorString));
+      return IPC_OK();
+    }
+  }
+
+  auto* mapData = GetBufferMapData(aBufferId);
+
+  if (!mapData) {
+    nsCString errorString("Buffer is not mappable");
+    aResolver(BufferMapError(errorString));
+    return IPC_OK();
+  }
+
+  auto* request =
+      new MapRequest{this,    mContext.get(), aBufferId,           mode,
+                     aOffset, aSize,          std::move(aResolver)};
+
+  ffi::WGPUBufferMapCallbackC callback = {&MapCallback,
+                                          reinterpret_cast<uint8_t*>(request)};
+  ffi::wgpu_server_buffer_map(mContext.get(), aBufferId, aOffset, aSize, mode,
+                              callback);
+
+  return IPC_OK();
+}
+
+ipc::IPCResult WebGPUParent::RecvBufferUnmap(RawId aDeviceId, RawId aBufferId,
+                                             bool aFlush) {
+  MOZ_LOG(sLogger, LogLevel::Info,
+          ("RecvBufferUnmap %" PRIu64 " flush=%d\n", aBufferId, aFlush));
+
+  auto* mapData = GetBufferMapData(aBufferId);
+
+  if (mapData && aFlush) {
+    uint64_t offset = mapData->mMappedOffset;
+    uint64_t size = mapData->mMappedSize;
+
+    const auto mapped = ffi::wgpu_server_buffer_get_mapped_range(
+        mContext.get(), aBufferId, offset, size);
+
+    if (mapped.ptr != nullptr && mapped.length >= size) {
+      auto shmSize = mapData->mShmem.Size();
+      MOZ_RELEASE_ASSERT(offset <= shmSize);
+      MOZ_RELEASE_ASSERT(size <= shmSize - offset);
+
+      auto src = mapData->mShmem.Bytes().Subspan(offset, size);
+      memcpy(mapped.ptr, src.data(), size);
+    }
+
+    mapData->mMappedOffset = 0;
+    mapData->mMappedSize = 0;
+  }
+
+  ErrorBuffer error;
+  ffi::wgpu_server_buffer_unmap(mContext.get(), aBufferId, error.ToFFI());
+  ForwardError(aDeviceId, error);
+
+  if (mapData && !mapData->mHasMapFlags) {
+    // We get here if the buffer was mapped at creation without map flags.
+    // We don't need the shared memory anymore.
+    DeallocBufferShmem(aBufferId);
+  }
+
+  return IPC_OK();
+}
+
+void WebGPUParent::DeallocBufferShmem(RawId aBufferId) {
+  const auto iter = mSharedMemoryMap.find(aBufferId);
+  if (iter != mSharedMemoryMap.end()) {
+    mSharedMemoryMap.erase(iter);
+  }
+}
+
+ipc::IPCResult WebGPUParent::RecvBufferDrop(RawId aBufferId) {
+  ffi::wgpu_server_buffer_drop(mContext.get(), aBufferId);
+  MOZ_LOG(sLogger, LogLevel::Info, ("RecvBufferDrop %" PRIu64 "\n", aBufferId));
+
+  DeallocBufferShmem(aBufferId);
+
+  return IPC_OK();
+}
+
+ipc::IPCResult WebGPUParent::RecvBufferDestroy(RawId aBufferId) {
+  ffi::wgpu_server_buffer_destroy(mContext.get(), aBufferId);
+  MOZ_LOG(sLogger, LogLevel::Info,
+          ("RecvBufferDestroy %" PRIu64 "\n", aBufferId));
+
+  DeallocBufferShmem(aBufferId);
+
+  return IPC_OK();
+}
+
+ipc::IPCResult WebGPUParent::RecvTextureDestroy(RawId aTextureId) {
+  ffi::wgpu_server_texture_drop(mContext.get(), aTextureId);
+  return IPC_OK();
+}
+
+ipc::IPCResult WebGPUParent::RecvTextureViewDestroy(RawId aTextureViewId) {
+  ffi::wgpu_server_texture_view_drop(mContext.get(), aTextureViewId);
+  return IPC_OK();
+}
+
+ipc::IPCResult WebGPUParent::RecvSamplerDestroy(RawId aSamplerId) {
+  ffi::wgpu_server_sampler_drop(mContext.get(), aSamplerId);
+  return IPC_OK();
+}
+
+ipc::IPCResult WebGPUParent::RecvCommandEncoderFinish(
+    RawId aEncoderId, RawId aDeviceId,
+    const dom::GPUCommandBufferDescriptor& aDesc) {
+  Unused << aDesc;
+  ffi::WGPUCommandBufferDescriptor desc = {};
+
+  webgpu::StringHelper label(aDesc.mLabel);
+  desc.label = label.Get();
+
+  ErrorBuffer error;
+  ffi::wgpu_server_encoder_finish(mContext.get(), aEncoderId, &desc,
+                                  error.ToFFI());
+
+  ForwardError(aDeviceId, error);
+  return IPC_OK();
+}
+
+ipc::IPCResult WebGPUParent::RecvCommandEncoderDestroy(RawId aEncoderId) {
+  ffi::wgpu_server_encoder_drop(mContext.get(), aEncoderId);
+  return IPC_OK();
+}
+
+ipc::IPCResult WebGPUParent::RecvCommandBufferDestroy(RawId aCommandBufferId) {
+  ffi::wgpu_server_command_buffer_drop(mContext.get(), aCommandBufferId);
+  return IPC_OK();
+}
+
+ipc::IPCResult WebGPUParent::RecvRenderBundleDestroy(RawId aBundleId) {
+  ffi::wgpu_server_render_bundle_drop(mContext.get(), aBundleId);
+  return IPC_OK();
+}
+
+ipc::IPCResult WebGPUParent::RecvQueueSubmit(
+    RawId aQueueId, RawId aDeviceId, const nsTArray<RawId>& aCommandBuffers) {
+  ErrorBuffer error;
+  ffi::wgpu_server_queue_submit(mContext.get(), aQueueId,
+                                aCommandBuffers.Elements(),
+                                aCommandBuffers.Length(), error.ToFFI());
+  ForwardError(aDeviceId, error);
+  return IPC_OK();
+}
+
+ipc::IPCResult WebGPUParent::RecvQueueWriteAction(
+    RawId aQueueId, RawId aDeviceId, const ipc::ByteBuf& aByteBuf,
+    ipc::UnsafeSharedMemoryHandle&& aShmem) {
+  auto mapping =
+      ipc::WritableSharedMemoryMapping::Open(std::move(aShmem)).value();
+
+  ErrorBuffer error;
+  ffi::wgpu_server_queue_write_action(mContext.get(), aQueueId,
+                                      ToFFI(&aByteBuf), mapping.Bytes().data(),
+                                      mapping.Size(), error.ToFFI());
+  ForwardError(aDeviceId, error);
+  return IPC_OK();
+}
+
+ipc::IPCResult WebGPUParent::RecvBindGroupLayoutDestroy(RawId aBindGroupId) {
+  ffi::wgpu_server_bind_group_layout_drop(mContext.get(), aBindGroupId);
+  return IPC_OK();
+}
+
+ipc::IPCResult WebGPUParent::RecvPipelineLayoutDestroy(RawId aLayoutId) {
+  ffi::wgpu_server_pipeline_layout_drop(mContext.get(), aLayoutId);
+  return IPC_OK();
+}
+
+ipc::IPCResult WebGPUParent::RecvBindGroupDestroy(RawId aBindGroupId) {
+  ffi::wgpu_server_bind_group_drop(mContext.get(), aBindGroupId);
+  return IPC_OK();
+}
+
+ipc::IPCResult WebGPUParent::RecvShaderModuleDestroy(RawId aModuleId) {
+  ffi::wgpu_server_shader_module_drop(mContext.get(), aModuleId);
+  return IPC_OK();
+}
+
+ipc::IPCResult WebGPUParent::RecvComputePipelineDestroy(RawId aPipelineId) {
+  ffi::wgpu_server_compute_pipeline_drop(mContext.get(), aPipelineId);
+  return IPC_OK();
+}
+
+ipc::IPCResult WebGPUParent::RecvRenderPipelineDestroy(RawId aPipelineId) {
+  ffi::wgpu_server_render_pipeline_drop(mContext.get(), aPipelineId);
+  return IPC_OK();
+}
+
+ipc::IPCResult WebGPUParent::RecvImplicitLayoutDestroy(
+    RawId aImplicitPlId, const nsTArray<RawId>& aImplicitBglIds) {
+  ffi::wgpu_server_pipeline_layout_drop(mContext.get(), aImplicitPlId);
+  for (const auto& id : aImplicitBglIds) {
+    ffi::wgpu_server_bind_group_layout_drop(mContext.get(), id);
+  }
+  return IPC_OK();
+}
+
+// TODO: proper destruction
+
+ipc::IPCResult WebGPUParent::RecvDeviceCreateSwapChain(
+    RawId aDeviceId, RawId aQueueId, const RGBDescriptor& aDesc,
+    const nsTArray<RawId>& aBufferIds,
+    const layers::RemoteTextureOwnerId& aOwnerId) {
+  switch (aDesc.format()) {
+    case gfx::SurfaceFormat::R8G8B8A8:
+    case gfx::SurfaceFormat::B8G8R8A8:
+      break;
+    default:
+      MOZ_ASSERT_UNREACHABLE("Invalid surface format!");
+      return IPC_OK();
+  }
+
+  constexpr uint32_t kBufferAlignmentMask = 0xff;
+  const auto bufferStrideWithMask = CheckedInt<uint32_t>(aDesc.size().width) *
+                                        gfx::BytesPerPixel(aDesc.format()) +
+                                    kBufferAlignmentMask;
+  if (!bufferStrideWithMask.isValid()) {
+    MOZ_ASSERT_UNREACHABLE("Invalid width / buffer stride!");
+    return IPC_OK();
+  }
+
+  const uint32_t bufferStride =
+      bufferStrideWithMask.value() & ~kBufferAlignmentMask;
+
+  const auto rows = CheckedInt<uint32_t>(aDesc.size().height);
+  if (!rows.isValid()) {
+    MOZ_ASSERT_UNREACHABLE("Invalid height!");
+    return IPC_OK();
+  }
+
+  if (!mRemoteTextureOwner) {
+    mRemoteTextureOwner =
+        MakeRefPtr<layers::RemoteTextureOwnerClient>(OtherPid());
+  }
+  // RemoteTextureMap::GetRemoteTextureForDisplayList() works synchronously.
+  mRemoteTextureOwner->RegisterTextureOwner(aOwnerId, /* aIsSyncMode */ true);
+
+  auto data = MakeRefPtr<PresentationData>(aDeviceId, aQueueId, aDesc,
+                                           bufferStride, aBufferIds);
+  if (!mCanvasMap.emplace(aOwnerId, data).second) {
+    NS_ERROR("External image is already registered as WebGPU canvas!");
+  }
+  return IPC_OK();
+}
+
+ipc::IPCResult WebGPUParent::RecvDeviceCreateShaderModule(
+    RawId aDeviceId, RawId aModuleId, const nsString& aLabel,
+    const nsCString& aCode, DeviceCreateShaderModuleResolver&& aOutMessage) {
+  // TODO: this should probably be an optional label in the IPC message.
+  const nsACString* label = nullptr;
+  NS_ConvertUTF16toUTF8 utf8Label(aLabel);
+  if (!utf8Label.IsEmpty()) {
+    label = &utf8Label;
+  }
+
+  ffi::WGPUShaderModuleCompilationMessage message;
+
+  bool ok = ffi::wgpu_server_device_create_shader_module(
+      mContext.get(), aDeviceId, aModuleId, label, &aCode, &message);
+
+  nsTArray<WebGPUCompilationMessage> messages;
+
+  if (!ok) {
+    WebGPUCompilationMessage msg;
+    msg.lineNum = message.line_number;
+    msg.linePos = message.line_pos;
+    msg.offset = message.utf16_offset;
+    msg.length = message.utf16_length;
+    msg.message = message.message;
+    // wgpu currently only returns errors.
+    msg.messageType = WebGPUCompilationMessageType::Error;
+
+    messages.AppendElement(msg);
+  }
+
+  aOutMessage(messages);
+
+  return IPC_OK();
+}
+
+struct PresentRequest {
+  PresentRequest(const ffi::WGPUGlobal* aContext,
+                 RefPtr<PresentationData>& aData,
+                 RefPtr<layers::RemoteTextureOwnerClient>& aRemoteTextureOwner,
+                 const layers::RemoteTextureId aTextureId,
+                 const layers::RemoteTextureOwnerId aOwnerId)
+      : mContext(aContext),
+        mData(aData),
+        mRemoteTextureOwner(aRemoteTextureOwner),
+        mTextureId(aTextureId),
+        mOwnerId(aOwnerId) {}
+
+  const ffi::WGPUGlobal* mContext;
+  RefPtr<PresentationData> mData;
+  RefPtr<layers::RemoteTextureOwnerClient> mRemoteTextureOwner;
+  const layers::RemoteTextureId mTextureId;
+  const layers::RemoteTextureOwnerId mOwnerId;
+};
+
+static void PresentCallback(ffi::WGPUBufferMapAsyncStatus status,
+                            uint8_t* userdata) {
+  UniquePtr<PresentRequest> req(reinterpret_cast<PresentRequest*>(userdata));
+
+  PresentationData* data = req->mData.get();
+  // get the buffer ID
+  RawId bufferId;
+  {
+    MutexAutoLock lock(data->mBuffersLock);
+    bufferId = data->mQueuedBufferIds.back();
+    data->mQueuedBufferIds.pop_back();
+    data->mAvailableBufferIds.push_back(bufferId);
+  }
+  MOZ_LOG(
+      sLogger, LogLevel::Info,
+      ("PresentCallback for buffer %" PRIu64 " status=%d\n", bufferId, status));
+  // copy the data
+  if (status == ffi::WGPUBufferMapAsyncStatus_Success) {
+    const auto bufferSize = data->mDesc.size().height * data->mSourcePitch;
+    const auto mapped = ffi::wgpu_server_buffer_get_mapped_range(
+        req->mContext, bufferId, 0, bufferSize);
+    MOZ_ASSERT(mapped.length >= bufferSize);
+    auto textureData =
+        req->mRemoteTextureOwner->CreateOrRecycleBufferTextureData(
+            req->mOwnerId, data->mDesc.size(), data->mDesc.format());
+    if (!textureData) {
+      gfxCriticalNoteOnce << "Failed to allocate BufferTextureData";
+      return;
+    }
+    layers::MappedTextureData mappedData;
+    if (textureData && textureData->BorrowMappedData(mappedData)) {
+      uint8_t* src = mapped.ptr;
+      uint8_t* dst = mappedData.data;
+      for (auto row = 0; row < data->mDesc.size().height; ++row) {
+        memcpy(dst, src, mappedData.stride);
+        dst += mappedData.stride;
+        src += data->mSourcePitch;
+      }
+      req->mRemoteTextureOwner->PushTexture(req->mTextureId, req->mOwnerId,
+                                            std::move(textureData),
+                                            /* aSharedSurface */ nullptr);
+    } else {
+      NS_WARNING("WebGPU present skipped: the swapchain is resized!");
+    }
+    ErrorBuffer error;
+    wgpu_server_buffer_unmap(req->mContext, bufferId, error.ToFFI());
+    if (auto errorString = error.GetError()) {
+      MOZ_LOG(
+          sLogger, LogLevel::Info,
+          ("WebGPU present: buffer unmap failed: %s\n", errorString->get()));
+    }
+  } else {
+    // TODO: better handle errors
+    NS_WARNING("WebGPU frame mapping failed!");
+  }
+}
+
+ipc::IPCResult WebGPUParent::GetFrontBufferSnapshot(
+    IProtocol* aProtocol, const layers::RemoteTextureOwnerId& aOwnerId,
+    Maybe<Shmem>& aShmem, gfx::IntSize& aSize) {
+  const auto& lookup = mCanvasMap.find(aOwnerId);
+  if (lookup == mCanvasMap.end() || !mRemoteTextureOwner) {
+    return IPC_OK();
+  }
+
+  RefPtr<PresentationData> data = lookup->second.get();
+  aSize = data->mDesc.size();
+  uint32_t stride = layers::ImageDataSerializer::ComputeRGBStride(
+      data->mDesc.format(), aSize.width);
+  uint32_t len = data->mDesc.size().height * stride;
+  Shmem shmem;
+  if (!AllocShmem(len, &shmem)) {
+    return IPC_OK();
+  }
+
+  mRemoteTextureOwner->GetLatestBufferSnapshot(aOwnerId, shmem, aSize);
+  aShmem.emplace(std::move(shmem));
+
+  return IPC_OK();
+}
+
+ipc::IPCResult WebGPUParent::RecvSwapChainPresent(
+    RawId aTextureId, RawId aCommandEncoderId,
+    const layers::RemoteTextureId& aRemoteTextureId,
+    const layers::RemoteTextureOwnerId& aOwnerId) {
+  // step 0: get the data associated with the swapchain
+  const auto& lookup = mCanvasMap.find(aOwnerId);
+  if (lookup == mCanvasMap.end() || !mRemoteTextureOwner ||
+      !mRemoteTextureOwner->IsRegistered(aOwnerId)) {
+    NS_WARNING("WebGPU presenting on a destroyed swap chain!");
+    return IPC_OK();
+  }
+
+  RefPtr<PresentationData> data = lookup->second.get();
+  RawId bufferId = 0;
+  const auto& size = data->mDesc.size();
+  const auto bufferSize = data->mDesc.size().height * data->mSourcePitch;
+
+  // step 1: find an available staging buffer, or create one
+  {
+    MutexAutoLock lock(data->mBuffersLock);
+    if (!data->mAvailableBufferIds.empty()) {
+      bufferId = data->mAvailableBufferIds.back();
+      data->mAvailableBufferIds.pop_back();
+    } else if (!data->mUnassignedBufferIds.empty()) {
+      bufferId = data->mUnassignedBufferIds.back();
+      data->mUnassignedBufferIds.pop_back();
+
+      ffi::WGPUBufferUsages usage =
+          WGPUBufferUsages_COPY_DST | WGPUBufferUsages_MAP_READ;
+
+      ErrorBuffer error;
+      ffi::wgpu_server_device_create_buffer(mContext.get(), data->mDeviceId,
+                                            bufferId, nullptr, bufferSize,
+                                            usage, false, error.ToFFI());
+      if (ForwardError(data->mDeviceId, error)) {
+        return IPC_OK();
+      }
+    } else {
+      bufferId = 0;
+    }
+
+    if (bufferId) {
+      data->mQueuedBufferIds.insert(data->mQueuedBufferIds.begin(), bufferId);
+    }
+  }
+
+  MOZ_LOG(sLogger, LogLevel::Info,
+          ("RecvSwapChainPresent with buffer %" PRIu64 "\n", bufferId));
+  if (!bufferId) {
+    // TODO: add a warning - no buffer are available!
+    return IPC_OK();
+  }
+
+  // step 3: submit a copy command for the frame
+  ffi::WGPUCommandEncoderDescriptor encoderDesc = {};
+  {
+    ErrorBuffer error;
+    ffi::wgpu_server_device_create_encoder(mContext.get(), data->mDeviceId,
+                                           &encoderDesc, aCommandEncoderId,
+                                           error.ToFFI());
+    if (ForwardError(data->mDeviceId, error)) {
+      return IPC_OK();
+    }
+  }
+
+  const ffi::WGPUImageCopyTexture texView = {
+      aTextureId,
+  };
+  const ffi::WGPUImageDataLayout bufLayout = {
+      0,
+      data->mSourcePitch,
+      0,
+  };
+  const ffi::WGPUImageCopyBuffer bufView = {
+      bufferId,
+      bufLayout,
+  };
+  const ffi::WGPUExtent3d extent = {
+      static_cast<uint32_t>(size.width),
+      static_cast<uint32_t>(size.height),
+      1,
+  };
+  ffi::wgpu_server_encoder_copy_texture_to_buffer(
+      mContext.get(), aCommandEncoderId, &texView, &bufView, &extent);
+  ffi::WGPUCommandBufferDescriptor commandDesc = {};
+  {
+    ErrorBuffer error;
+    ffi::wgpu_server_encoder_finish(mContext.get(), aCommandEncoderId,
+                                    &commandDesc, error.ToFFI());
+    if (ForwardError(data->mDeviceId, error)) {
+      return IPC_OK();
+    }
+  }
+
+  {
+    ErrorBuffer error;
+    ffi::wgpu_server_queue_submit(mContext.get(), data->mQueueId,
+                                  &aCommandEncoderId, 1, error.ToFFI());
+    if (ForwardError(data->mDeviceId, error)) {
+      return IPC_OK();
+    }
+  }
+
+  // step 4: request the pixels to be copied into the external texture
+  // TODO: this isn't strictly necessary. When WR wants to Lock() the external
+  // texture,
+  // we can just give it the contents of the last mapped buffer instead of the
+  // copy.
+  auto presentRequest = MakeUnique<PresentRequest>(
+      mContext.get(), data, mRemoteTextureOwner, aRemoteTextureId, aOwnerId);
+
+  ffi::WGPUBufferMapCallbackC callback = {
+      &PresentCallback, reinterpret_cast<uint8_t*>(presentRequest.release())};
+  ffi::wgpu_server_buffer_map(mContext.get(), bufferId, 0, bufferSize,
+                              ffi::WGPUHostMap_Read, callback);
+
+  return IPC_OK();
+}
+
+ipc::IPCResult WebGPUParent::RecvSwapChainDestroy(
+    const layers::RemoteTextureOwnerId& aOwnerId) {
+  if (mRemoteTextureOwner) {
+    mRemoteTextureOwner->UnregisterTextureOwner(aOwnerId);
+  }
+  const auto& lookup = mCanvasMap.find(aOwnerId);
+  MOZ_ASSERT(lookup != mCanvasMap.end());
+  if (lookup == mCanvasMap.end()) {
+    NS_WARNING("WebGPU presenting on a destroyed swap chain!");
+    return IPC_OK();
+  }
+
+  RefPtr<PresentationData> data = lookup->second.get();
+  mCanvasMap.erase(lookup);
+
+  MutexAutoLock lock(data->mBuffersLock);
+  ipc::ByteBuf dropByteBuf;
+  for (const auto bid : data->mUnassignedBufferIds) {
+    wgpu_server_buffer_free(bid, ToFFI(&dropByteBuf));
+  }
+  if (dropByteBuf.mData && !SendDropAction(std::move(dropByteBuf))) {
+    NS_WARNING("Unable to free an ID for non-assigned buffer");
+  }
+  for (const auto bid : data->mAvailableBufferIds) {
+    ffi::wgpu_server_buffer_drop(mContext.get(), bid);
+  }
+  for (const auto bid : data->mQueuedBufferIds) {
+    ffi::wgpu_server_buffer_drop(mContext.get(), bid);
+  }
+  return IPC_OK();
+}
+
+void WebGPUParent::ActorDestroy(ActorDestroyReason aWhy) {
+  mTimer.Stop();
+  mCanvasMap.clear();
+  if (mRemoteTextureOwner) {
+    mRemoteTextureOwner->UnregisterAllTextureOwners();
+    mRemoteTextureOwner = nullptr;
+  }
+  ffi::wgpu_server_poll_all_devices(mContext.get(), true);
+  mContext = nullptr;
+}
+
+ipc::IPCResult WebGPUParent::RecvDeviceAction(RawId aDeviceId,
+                                              const ipc::ByteBuf& aByteBuf) {
+  ErrorBuffer error;
+  ffi::wgpu_server_device_action(mContext.get(), aDeviceId, ToFFI(&aByteBuf),
+                                 error.ToFFI());
+
+  ForwardError(aDeviceId, error);
+  return IPC_OK();
+}
+
+ipc::IPCResult WebGPUParent::RecvDeviceActionWithAck(
+    RawId aDeviceId, const ipc::ByteBuf& aByteBuf,
+    DeviceActionWithAckResolver&& aResolver) {
+  ErrorBuffer error;
+  ffi::wgpu_server_device_action(mContext.get(), aDeviceId, ToFFI(&aByteBuf),
+                                 error.ToFFI());
+
+  ForwardError(aDeviceId, error);
+  aResolver(true);
+  return IPC_OK();
+}
+
+ipc::IPCResult WebGPUParent::RecvTextureAction(RawId aTextureId,
+                                               RawId aDeviceId,
+                                               const ipc::ByteBuf& aByteBuf) {
+  ErrorBuffer error;
+  ffi::wgpu_server_texture_action(mContext.get(), aTextureId, ToFFI(&aByteBuf),
+                                  error.ToFFI());
+
+  ForwardError(aDeviceId, error);
+  return IPC_OK();
+}
+
+ipc::IPCResult WebGPUParent::RecvCommandEncoderAction(
+    RawId aEncoderId, RawId aDeviceId, const ipc::ByteBuf& aByteBuf) {
+  ErrorBuffer error;
+  ffi::wgpu_server_command_encoder_action(mContext.get(), aEncoderId,
+                                          ToFFI(&aByteBuf), error.ToFFI());
+  ForwardError(aDeviceId, error);
+  return IPC_OK();
+}
+
+ipc::IPCResult WebGPUParent::RecvBumpImplicitBindGroupLayout(RawId aPipelineId,
+                                                             bool aIsCompute,
+                                                             uint32_t aIndex,
+                                                             RawId aAssignId) {
+  ErrorBuffer error;
+  if (aIsCompute) {
+    ffi::wgpu_server_compute_pipeline_get_bind_group_layout(
+        mContext.get(), aPipelineId, aIndex, aAssignId, error.ToFFI());
+  } else {
+    ffi::wgpu_server_render_pipeline_get_bind_group_layout(
+        mContext.get(), aPipelineId, aIndex, aAssignId, error.ToFFI());
+  }
+
+  ForwardError(0, error);
+  return IPC_OK();
+}
+
+ipc::IPCResult WebGPUParent::RecvDevicePushErrorScope(RawId aDeviceId) {
+  const auto& lookup = mErrorScopeMap.find(aDeviceId);
+  if (lookup == mErrorScopeMap.end()) {
+    NS_WARNING("WebGPU error scopes on a destroyed device!");
+    return IPC_OK();
+  }
+
+  lookup->second.mStack.EmplaceBack();
+  return IPC_OK();
+}
+
+ipc::IPCResult WebGPUParent::RecvDevicePopErrorScope(
+    RawId aDeviceId, DevicePopErrorScopeResolver&& aResolver) {
+  const auto& lookup = mErrorScopeMap.find(aDeviceId);
+  if (lookup == mErrorScopeMap.end()) {
+    NS_WARNING("WebGPU error scopes on a destroyed device!");
+    ScopedError error = {true};
+    aResolver(Some(error));
+    return IPC_OK();
+  }
+
+  if (lookup->second.mStack.IsEmpty()) {
+    NS_WARNING("WebGPU no error scope to pop!");
+    ScopedError error = {true};
+    aResolver(Some(error));
+    return IPC_OK();
+  }
+
+  auto scope = lookup->second.mStack.PopLastElement();
+  aResolver(scope);
+  return IPC_OK();
+}
+
+ipc::IPCResult WebGPUParent::RecvGenerateError(RawId aDeviceId,
+                                               const nsCString& aMessage) {
+  ReportError(aDeviceId, aMessage);
+  return IPC_OK();
+}
+
+}  // namespace mozilla::webgpu
diff --git a/dom/webgpu/ipc/WebGPUParent.h b/dom/webgpu/ipc/WebGPUParent.h
new file mode 100644
index 0000000000..384d560003
--- /dev/null
+++ b/dom/webgpu/ipc/WebGPUParent.h
@@ -0,0 +1,156 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef WEBGPU_PARENT_H_
+#define WEBGPU_PARENT_H_
+
+#include "mozilla/webgpu/ffi/wgpu.h"
+#include "mozilla/webgpu/PWebGPUParent.h"
+#include "mozilla/webrender/WebRenderAPI.h"
+#include "mozilla/ipc/RawShmem.h"
+#include "WebGPUTypes.h"
+#include "base/timer.h"
+
+namespace mozilla {
+
+namespace layers {
+class RemoteTextureOwnerClient;
+}  // namespace layers
+
+namespace webgpu {
+
+class ErrorBuffer;
+class PresentationData;
+
+struct ErrorScopeStack {
+  nsTArray<MaybeScopedError> mStack;
+};
+
+class WebGPUParent final : public PWebGPUParent {
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(WebGPUParent, override)
+
+ public:
+  explicit WebGPUParent();
+
+  ipc::IPCResult RecvInstanceRequestAdapter(
+      const dom::GPURequestAdapterOptions& aOptions,
+      const nsTArray<RawId>& aTargetIds,
+      InstanceRequestAdapterResolver&& resolver);
+  ipc::IPCResult RecvAdapterRequestDevice(
+      RawId aAdapterId, const ipc::ByteBuf& aByteBuf, RawId aDeviceId,
+      AdapterRequestDeviceResolver&& resolver);
+  ipc::IPCResult RecvAdapterDestroy(RawId aAdapterId);
+  ipc::IPCResult RecvDeviceDestroy(RawId aDeviceId);
+  ipc::IPCResult RecvCreateBuffer(RawId aDeviceId, RawId aBufferId,
+                                  dom::GPUBufferDescriptor&& aDesc,
+                                  ipc::UnsafeSharedMemoryHandle&& aShmem);
+  ipc::IPCResult RecvBufferMap(RawId aBufferId, uint32_t aMode,
+                               uint64_t aOffset, uint64_t size,
+                               BufferMapResolver&& aResolver);
+  ipc::IPCResult RecvBufferUnmap(RawId aDeviceId, RawId aBufferId, bool aFlush);
+  ipc::IPCResult RecvBufferDestroy(RawId aBufferId);
+  ipc::IPCResult RecvBufferDrop(RawId aBufferId);
+  ipc::IPCResult RecvTextureDestroy(RawId aTextureId);
+  ipc::IPCResult RecvTextureViewDestroy(RawId aTextureViewId);
+  ipc::IPCResult RecvSamplerDestroy(RawId aSamplerId);
+  ipc::IPCResult RecvCommandEncoderFinish(
+      RawId aEncoderId, RawId aDeviceId,
+      const dom::GPUCommandBufferDescriptor& aDesc);
+  ipc::IPCResult RecvCommandEncoderDestroy(RawId aEncoderId);
+  ipc::IPCResult RecvCommandBufferDestroy(RawId aCommandBufferId);
+  ipc::IPCResult RecvRenderBundleDestroy(RawId aBundleId);
+  ipc::IPCResult RecvQueueSubmit(RawId aQueueId, RawId aDeviceId,
+                                 const nsTArray<RawId>& aCommandBuffers);
+  ipc::IPCResult RecvQueueWriteAction(RawId aQueueId, RawId aDeviceId,
+                                      const ipc::ByteBuf& aByteBuf,
+                                      ipc::UnsafeSharedMemoryHandle&& aShmem);
+  ipc::IPCResult RecvBindGroupLayoutDestroy(RawId aBindGroupLayoutId);
+  ipc::IPCResult RecvPipelineLayoutDestroy(RawId aPipelineLayoutId);
+  ipc::IPCResult RecvBindGroupDestroy(RawId aBindGroupId);
+  ipc::IPCResult RecvShaderModuleDestroy(RawId aModuleId);
+  ipc::IPCResult RecvComputePipelineDestroy(RawId aPipelineId);
+  ipc::IPCResult RecvRenderPipelineDestroy(RawId aPipelineId);
+  ipc::IPCResult RecvImplicitLayoutDestroy(
+      RawId aImplicitPlId, const nsTArray<RawId>& aImplicitBglIds);
+  ipc::IPCResult RecvDeviceCreateSwapChain(
+      RawId aDeviceId, RawId aQueueId, const layers::RGBDescriptor& aDesc,
+      const nsTArray<RawId>& aBufferIds,
+      const layers::RemoteTextureOwnerId& aOwnerId);
+  ipc::IPCResult RecvDeviceCreateShaderModule(
+      RawId aDeviceId, RawId aModuleId, const nsString& aLabel,
+      const nsCString& aCode, DeviceCreateShaderModuleResolver&& aOutMessage);
+
+  ipc::IPCResult RecvSwapChainPresent(
+      RawId aTextureId, RawId aCommandEncoderId,
+      const layers::RemoteTextureId& aRemoteTextureId,
+      const layers::RemoteTextureOwnerId& aOwnerId);
+  ipc::IPCResult RecvSwapChainDestroy(
+      const layers::RemoteTextureOwnerId& aOwnerId);
+
+  ipc::IPCResult RecvDeviceAction(RawId aDeviceId,
+                                  const ipc::ByteBuf& aByteBuf);
+  ipc::IPCResult RecvDeviceActionWithAck(
+      RawId aDeviceId, const ipc::ByteBuf& aByteBuf,
+      DeviceActionWithAckResolver&& aResolver);
+  ipc::IPCResult RecvTextureAction(RawId aTextureId, RawId aDevice,
+                                   const ipc::ByteBuf& aByteBuf);
+  ipc::IPCResult RecvCommandEncoderAction(RawId aEncoderId, RawId aDeviceId,
+                                          const ipc::ByteBuf& aByteBuf);
+  ipc::IPCResult RecvBumpImplicitBindGroupLayout(RawId aPipelineId,
+                                                 bool aIsCompute,
+                                                 uint32_t aIndex,
+                                                 RawId aAssignId);
+
+  ipc::IPCResult RecvDevicePushErrorScope(RawId aDeviceId);
+  ipc::IPCResult RecvDevicePopErrorScope(
+      RawId aDeviceId, DevicePopErrorScopeResolver&& aResolver);
+  ipc::IPCResult RecvGenerateError(RawId aDeviceId, const nsCString& message);
+
+  ipc::IPCResult GetFrontBufferSnapshot(
+      IProtocol* aProtocol, const layers::RemoteTextureOwnerId& aOwnerId,
+      Maybe<Shmem>& aShmem, gfx::IntSize& aSize);
+
+  void ActorDestroy(ActorDestroyReason aWhy) override;
+
+  struct BufferMapData {
+    ipc::WritableSharedMemoryMapping mShmem;
+    // True if buffer's usage has MAP_READ or MAP_WRITE set.
+    bool mHasMapFlags;
+    uint64_t mMappedOffset;
+    uint64_t mMappedSize;
+  };
+
+  BufferMapData* GetBufferMapData(RawId aBufferId);
+
+ private:
+  void DeallocBufferShmem(RawId aBufferId);
+
+  virtual ~WebGPUParent();
+  void MaintainDevices();
+  bool ForwardError(RawId aDeviceId, ErrorBuffer& aError);
+  void ReportError(RawId aDeviceId, const nsCString& message);
+
+  UniquePtr<ffi::WGPUGlobal> mContext;
+  base::RepeatingTimer<WebGPUParent> mTimer;
+
+  /// A map from wgpu buffer ids to data about their shared memory segments.
+  /// Includes entries about mappedAtCreation, MAP_READ and MAP_WRITE buffers,
+  /// regardless of their state.
+  std::unordered_map<uint64_t, BufferMapData> mSharedMemoryMap;
+  /// Associated presentation data for each swapchain.
+  std::unordered_map<layers::RemoteTextureOwnerId, RefPtr<PresentationData>,
+                     layers::RemoteTextureOwnerId::HashFn>
+      mCanvasMap;
+
+  RefPtr<layers::RemoteTextureOwnerClient> mRemoteTextureOwner;
+
+  /// Associated stack of error scopes for each device.
+  std::unordered_map<uint64_t, ErrorScopeStack> mErrorScopeMap;
+};
+
+}  // namespace webgpu
+}  // namespace mozilla
+
+#endif  // WEBGPU_PARENT_H_
diff --git a/dom/webgpu/ipc/WebGPUSerialize.h b/dom/webgpu/ipc/WebGPUSerialize.h
new file mode 100644
index 0000000000..b130fc992e
--- /dev/null
+++ b/dom/webgpu/ipc/WebGPUSerialize.h
@@ -0,0 +1,50 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef WEBGPU_SERIALIZE_H_
+#define WEBGPU_SERIALIZE_H_
+
+#include "WebGPUTypes.h"
+#include "ipc/EnumSerializer.h"
+#include "ipc/IPCMessageUtils.h"
+#include "mozilla/dom/WebGPUBinding.h"
+#include "mozilla/webgpu/ffi/wgpu.h"
+
+namespace IPC {
+
+#define DEFINE_IPC_SERIALIZER_ENUM_GUARD(something, guard) \
+  template <>                                              \
+  struct ParamTraits<something>                            \
+      : public ContiguousEnumSerializer<something, something(0), guard> {}
+
+#define DEFINE_IPC_SERIALIZER_DOM_ENUM(something) \
+  DEFINE_IPC_SERIALIZER_ENUM_GUARD(something, something::EndGuard_)
+#define DEFINE_IPC_SERIALIZER_FFI_ENUM(something) \
+  DEFINE_IPC_SERIALIZER_ENUM_GUARD(something, something##_Sentinel)
+
+DEFINE_IPC_SERIALIZER_DOM_ENUM(mozilla::dom::GPUPowerPreference);
+
+DEFINE_IPC_SERIALIZER_FFI_ENUM(mozilla::webgpu::ffi::WGPUHostMap);
+
+DEFINE_IPC_SERIALIZER_WITHOUT_FIELDS(mozilla::dom::GPUCommandBufferDescriptor);
+
+DEFINE_IPC_SERIALIZER_WITH_FIELDS(mozilla::dom::GPURequestAdapterOptions,
+                                  mPowerPreference, mForceFallbackAdapter);
+
+DEFINE_IPC_SERIALIZER_WITH_FIELDS(mozilla::dom::GPUBufferDescriptor, mSize,
+                                  mUsage, mMappedAtCreation);
+
+DEFINE_IPC_SERIALIZER_WITH_FIELDS(mozilla::webgpu::ScopedError, operationError,
+                                  validationMessage);
+
+DEFINE_IPC_SERIALIZER_WITH_FIELDS(mozilla::webgpu::WebGPUCompilationMessage,
+                                  message, lineNum, linePos);
+
+#undef DEFINE_IPC_SERIALIZER_FFI_ENUM
+#undef DEFINE_IPC_SERIALIZER_DOM_ENUM
+#undef DEFINE_IPC_SERIALIZER_ENUM_GUARD
+
+}  // namespace IPC
+#endif  // WEBGPU_SERIALIZE_H_
diff --git a/dom/webgpu/ipc/WebGPUTypes.h b/dom/webgpu/ipc/WebGPUTypes.h
new file mode 100644
index 0000000000..e607e03b99
--- /dev/null
+++ b/dom/webgpu/ipc/WebGPUTypes.h
@@ -0,0 +1,69 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef WEBGPU_TYPES_H_
+#define WEBGPU_TYPES_H_
+
+#include <cstdint>
+#include "mozilla/Maybe.h"
+#include "nsString.h"
+#include "mozilla/dom/BindingDeclarations.h"
+
+namespace mozilla::webgpu {
+
+using RawId = uint64_t;
+using BufferAddress = uint64_t;
+
+struct ScopedError {
+  // Did an error occur as a result the attempt to retrieve an error
+  // (e.g. from a dead device, from an empty scope stack)?
+  bool operationError = false;
+
+  // If non-empty, the first error generated when this scope was on
+  // the top of the stack. This is interpreted as UTF-8.
+  nsCString validationMessage;
+};
+using MaybeScopedError = Maybe<ScopedError>;
+
+enum class WebGPUCompilationMessageType { Error, Warning, Info };
+
+// TODO: Better name? CompilationMessage alread taken by the dom object.
+/// The serializable counterpart of the dom object CompilationMessage.
+struct WebGPUCompilationMessage {
+  nsString message;
+  uint64_t lineNum = 0;
+  uint64_t linePos = 0;
+  // In utf16 code units.
+  uint64_t offset = 0;
+  // In utf16 code units.
+  uint64_t length = 0;
+  WebGPUCompilationMessageType messageType =
+      WebGPUCompilationMessageType::Error;
+};
+
+/// A helper to reduce the boiler plate of turning the many Optional<nsAString>
+/// we get from the dom to the nullable nsACString* we pass to the wgpu ffi.
+class StringHelper {
+ public:
+  explicit StringHelper(const dom::Optional<nsString>& aWide) {
+    if (aWide.WasPassed()) {
+      mNarrow = Some(NS_ConvertUTF16toUTF8(aWide.Value()));
+    }
+  }
+
+  const nsACString* Get() const {
+    if (mNarrow.isSome()) {
+      return mNarrow.ptr();
+    }
+    return nullptr;
+  }
+
+ private:
+  Maybe<NS_ConvertUTF16toUTF8> mNarrow;
+};
+
+}  // namespace mozilla::webgpu
+
+#endif  // WEBGPU_TYPES_H_
diff --git a/dom/webgpu/mochitest/mochitest-no-pref.ini b/dom/webgpu/mochitest/mochitest-no-pref.ini
new file mode 100644
index 0000000000..c1e2681367
--- /dev/null
+++ b/dom/webgpu/mochitest/mochitest-no-pref.ini
@@ -0,0 +1,4 @@
+[DEFAULT]
+subsuite = webgpu
+
+[test_disabled.html]
diff --git a/dom/webgpu/mochitest/mochitest.ini b/dom/webgpu/mochitest/mochitest.ini
new file mode 100644
index 0000000000..3bd5124a21
--- /dev/null
+++ b/dom/webgpu/mochitest/mochitest.ini
@@ -0,0 +1,32 @@
+[DEFAULT]
+subsuite = webgpu
+run-if = !release_or_beta
+prefs =
+  dom.webgpu.enabled=true
+  gfx.offscreencanvas.enabled=true
+support-files =
+  worker_wrapper.js
+  test_basic_canvas.worker.js
+  test_submit_render_empty.worker.js
+
+[test_enabled.html]
+[test_basic_canvas.worker.html]
+fail-if = (os == 'linux' && os_version == '18.04') || (os == 'win' && os_version == '6.1')
+[test_device_creation.html]
+fail-if = (os == 'linux' && os_version == '18.04') || (os == 'win' && os_version == '6.1')
+[test_buffer_mapping.html]
+fail-if = (os == 'linux' && os_version == '18.04') || (os == 'win' && os_version == '6.1')
+[test_command_buffer_creation.html]
+fail-if = (os == 'linux' && os_version == '18.04') || (os == 'win' && os_version == '6.1')
+[test_submit_compute_empty.html]
+fail-if = (os == 'linux' && os_version == '18.04') || (os == 'win' && os_version == '6.1')
+[test_submit_render_empty.html]
+fail-if = (os == 'linux' && os_version == '18.04') || (os == 'win' && os_version == '6.1')
+[test_submit_render_empty.worker.html]
+fail-if = (os == 'linux' && os_version == '18.04') || (os == 'win' && os_version == '6.1')
+[test_queue_copyExternalImageToTexture.html]
+fail-if = (os == 'linux' && os_version == '18.04') || (os == 'win' && os_version == '6.1')
+[test_queue_write.html]
+fail-if = (os == 'linux' && os_version == '18.04') || (os == 'win' && os_version == '6.1')
+[test_error_scope.html]
+fail-if = (os == 'linux' && os_version == '18.04') || (os == 'win' && os_version == '6.1')
diff --git a/dom/webgpu/mochitest/test_basic_canvas.worker.html b/dom/webgpu/mochitest/test_basic_canvas.worker.html
new file mode 100644
index 0000000000..f34ef8af24
--- /dev/null
+++ b/dom/webgpu/mochitest/test_basic_canvas.worker.html
@@ -0,0 +1,20 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+<meta charset='utf-8'>
+<script src="/tests/SimpleTest/SimpleTest.js"></script>
+<script src="worker_wrapper.js"></script>
+<link rel="stylesheet" href="/tests/SimpleTest/test.css">
+</head>
+<body>
+<canvas id="canvas"></canvas>
+<script>
+
+const canvas = document.getElementById("canvas");
+const offscreen = canvas.transferControlToOffscreen();
+
+runWorkerTest('test_basic_canvas.worker.js', {offscreen}, [offscreen]);
+
+</script>
+</body>
+</html>
diff --git a/dom/webgpu/mochitest/test_basic_canvas.worker.js b/dom/webgpu/mochitest/test_basic_canvas.worker.js
new file mode 100644
index 0000000000..ddbc15c512
--- /dev/null
+++ b/dom/webgpu/mochitest/test_basic_canvas.worker.js
@@ -0,0 +1,32 @@
+self.addEventListener("message", async function(event) {
+  try {
+    const offscreen = event.data.offscreen;
+    const context = offscreen.getContext("webgpu");
+
+    const adapter = await navigator.gpu.requestAdapter();
+    const device = await adapter.requestDevice();
+    const swapChainFormat = context.getPreferredFormat(adapter);
+
+    context.configure({
+      device,
+      format: swapChainFormat,
+      size: { width: 100, height: 100, depth: 1 },
+    });
+
+    const texture = context.getCurrentTexture();
+
+    self.postMessage([
+      {
+        value: texture !== undefined,
+        message: "texture !== undefined",
+      },
+    ]);
+  } catch (e) {
+    self.postMessage([
+      {
+        value: false,
+        message: "Unhandled exception " + e,
+      },
+    ]);
+  }
+});
diff --git a/dom/webgpu/mochitest/test_buffer_mapping.html b/dom/webgpu/mochitest/test_buffer_mapping.html
new file mode 100644
index 0000000000..a3f59d0caf
--- /dev/null
+++ b/dom/webgpu/mochitest/test_buffer_mapping.html
@@ -0,0 +1,59 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+<meta charset='utf-8'>
+<script src="/tests/SimpleTest/SimpleTest.js"></script>
+<link rel="stylesheet" href="/tests/SimpleTest/test.css">
+</head>
+<body>
+<script>
+
+ok(SpecialPowers.getBoolPref('dom.webgpu.enabled'), 'Pref should be enabled.');
+
+async function testBody() {
+  const adapter = await navigator.gpu.requestAdapter();
+  const device = await adapter.requestDevice();
+
+  const bufferRead = device.createBuffer({ size:4, usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST });
+  const bufferWrite = device.createBuffer({ size:4, usage: GPUBufferUsage.COPY_SRC, mappedAtCreation: true });
+  (new Float32Array(bufferWrite.getMappedRange())).set([1.0]);
+  bufferWrite.unmap();
+
+  const encoder = device.createCommandEncoder();
+  encoder.copyBufferToBuffer(bufferWrite, 0, bufferRead, 0, 4);
+  device.queue.submit([encoder.finish()]);
+
+  await bufferRead.mapAsync(GPUMapMode.READ);
+
+  try {
+    bufferRead.getMappedRange(0, 5);
+    ok(false, 'mapped with size outside buffer should throw');
+  } catch(e) {
+    ok(true, 'mapped with size outside buffer should throw OperationError');
+  }
+
+  try {
+    bufferRead.getMappedRange(4, 1);
+    ok(false, 'mapped with offset outside buffer should throw');
+  } catch(e) {
+    ok(true, 'mapped with offset outside buffer should throw OperationError');
+  }
+
+  const data = bufferRead.getMappedRange();
+  is(data.byteLength, 4, 'array should be 4 bytes long');
+
+  const value = (new Float32Array(data))[0];
+  ok(value == 1.0, 'value == 1.0');
+
+  bufferRead.unmap();
+  is(data.byteLength, 0, 'array should be detached after explicit unmap');
+};
+
+SimpleTest.waitForExplicitFinish();
+testBody()
+  .catch((e) => ok(false, "Unhandled exception " + e))
+  .finally(() => SimpleTest.finish());
+
+</script>
+</body>
+</html>
diff --git a/dom/webgpu/mochitest/test_command_buffer_creation.html b/dom/webgpu/mochitest/test_command_buffer_creation.html
new file mode 100644
index 0000000000..e4f7356e0a
--- /dev/null
+++ b/dom/webgpu/mochitest/test_command_buffer_creation.html
@@ -0,0 +1,28 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+<meta charset='utf-8'>
+<script src="/tests/SimpleTest/SimpleTest.js"></script>
+<link rel="stylesheet" href="/tests/SimpleTest/test.css">
+</head>
+<body>
+<script>
+
+ok(SpecialPowers.getBoolPref('dom.webgpu.enabled'), 'Pref should be enabled.');
+
+const func = async function() {
+  const adapter = await navigator.gpu.requestAdapter();
+  const device = await adapter.requestDevice();
+  const encoder = device.createCommandEncoder();
+  const command_buffer = encoder.finish();
+  ok(command_buffer !== undefined, 'command_buffer !== undefined');
+};
+
+SimpleTest.waitForExplicitFinish();
+func()
+  .catch((e) => ok(false, "Unhandled exception " + e))
+  .finally(() => SimpleTest.finish());
+
+</script>
+</body>
+</html>
diff --git a/dom/webgpu/mochitest/test_device_creation.html b/dom/webgpu/mochitest/test_device_creation.html
new file mode 100644
index 0000000000..8e14ac2760
--- /dev/null
+++ b/dom/webgpu/mochitest/test_device_creation.html
@@ -0,0 +1,28 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+<meta charset='utf-8'>
+<script src="/tests/SimpleTest/SimpleTest.js"></script>
+<link rel="stylesheet" href="/tests/SimpleTest/test.css">
+</head>
+<body>
+<script>
+
+ok(SpecialPowers.getBoolPref('dom.webgpu.enabled'), 'Pref should be enabled.');
+
+const func = async function() {
+  const adapter = await navigator.gpu.requestAdapter();
+  const limits = adapter.limits;
+  const features = adapter.features;
+  const device = await adapter.requestDevice();
+  ok(device !== undefined, 'device !== undefined');
+};
+
+SimpleTest.waitForExplicitFinish();
+func()
+  .catch((e) => ok(false, "Unhandled exception " + e))
+  .finally(() => SimpleTest.finish());
+
+</script>
+</body>
+</html>
diff --git a/dom/webgpu/mochitest/test_disabled.html b/dom/webgpu/mochitest/test_disabled.html
new file mode 100644
index 0000000000..e96b8d7ecf
--- /dev/null
+++ b/dom/webgpu/mochitest/test_disabled.html
@@ -0,0 +1,16 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+<meta charset='utf-8'>
+<script src="/tests/SimpleTest/SimpleTest.js"></script>
+<link rel="stylesheet" href="/tests/SimpleTest/test.css">
+</head>
+<body>
+<script>
+
+ok(!SpecialPowers.getBoolPref('dom.webgpu.enabled'), 'Pref should be disabled.');
+ok(navigator.gpu === undefined, 'navigator.gpu === undefined');
+
+</script>
+</body>
+</html>
diff --git a/dom/webgpu/mochitest/test_enabled.html b/dom/webgpu/mochitest/test_enabled.html
new file mode 100644
index 0000000000..3f4af2177b
--- /dev/null
+++ b/dom/webgpu/mochitest/test_enabled.html
@@ -0,0 +1,16 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+<meta charset='utf-8'>
+<script src="/tests/SimpleTest/SimpleTest.js"></script>
+<link rel="stylesheet" href="/tests/SimpleTest/test.css">
+</head>
+<body>
+<script>
+
+ok(SpecialPowers.getBoolPref('dom.webgpu.enabled'), 'Pref should be enabled.');
+ok(navigator.gpu !== undefined, 'navigator.gpu !== undefined');
+
+</script>
+</body>
+</html>
diff --git a/dom/webgpu/mochitest/test_error_scope.html b/dom/webgpu/mochitest/test_error_scope.html
new file mode 100644
index 0000000000..c59996d39e
--- /dev/null
+++ b/dom/webgpu/mochitest/test_error_scope.html
@@ -0,0 +1,38 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+<meta charset='utf-8'>
+<script src="/tests/SimpleTest/SimpleTest.js"></script>
+<link rel="stylesheet" href="/tests/SimpleTest/test.css">
+</head>
+<body>
+<script>
+
+ok(SpecialPowers.getBoolPref('dom.webgpu.enabled'), 'Pref should be enabled.');
+
+const func = async function() {
+  const adapter = await navigator.gpu.requestAdapter();
+  const device = await adapter.requestDevice();
+
+  device.pushErrorScope("validation");
+  const buffer = device.createBuffer({ size:0, usage: 0 });
+  const error = await device.popErrorScope();
+
+  isnot(error, null)
+
+  try {
+    await device.popErrorScope();
+    ok(false, "Should have thrown")
+  } catch (ex) {
+    ok(ex.name == 'OperationError', "Should throw an OperationError")
+  }
+};
+
+SimpleTest.waitForExplicitFinish();
+func()
+  .catch((e) => ok(false, "Unhandled exception " + e))
+  .finally(() => SimpleTest.finish());
+
+</script>
+</body>
+</html>
diff --git a/dom/webgpu/mochitest/test_queue_copyExternalImageToTexture.html b/dom/webgpu/mochitest/test_queue_copyExternalImageToTexture.html
new file mode 100644
index 0000000000..0224620e85
--- /dev/null
+++ b/dom/webgpu/mochitest/test_queue_copyExternalImageToTexture.html
@@ -0,0 +1,181 @@
+<!DOCTYPE html>
+<html>
+
+<head>
+  <meta charset='utf-8'>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" href="/tests/SimpleTest/test.css">
+</head>
+
+<body>
+  <script type='text/javascript'>
+'use strict';
+
+ok(
+  SpecialPowers.getBoolPref("dom.webgpu.enabled"),
+  "WebGPU pref should be enabled."
+);
+ok(
+  SpecialPowers.getBoolPref("gfx.offscreencanvas.enabled"),
+  "OffscreenCanvas pref should be enabled."
+);
+
+SimpleTest.waitForExplicitFinish();
+
+function requestAnimationFramePromise() {
+  return new Promise(requestAnimationFrame);
+}
+
+function createSourceCanvasWebgl() {
+  const offscreenCanvas = new OffscreenCanvas(200, 200);
+  const gl = offscreenCanvas.getContext("webgl");
+
+  const COLOR_VALUE = 127.0 / 255.0;
+  const ALPHA_VALUE = 127.0 / 255.0;
+
+  gl.enable(gl.SCISSOR_TEST);
+
+  gl.scissor(0, 0, 100, 100);
+  gl.clearColor(COLOR_VALUE, 0.0, 0.0, ALPHA_VALUE);
+  gl.clear(gl.COLOR_BUFFER_BIT);
+
+  gl.scissor(100, 0, 100, 100);
+  gl.clearColor(0.0, COLOR_VALUE, 0.0, ALPHA_VALUE);
+  gl.clear(gl.COLOR_BUFFER_BIT);
+
+  gl.scissor(0, 100, 100, 100);
+  gl.clearColor(0.0, 0.0, COLOR_VALUE, ALPHA_VALUE);
+  gl.clear(gl.COLOR_BUFFER_BIT);
+
+  gl.scissor(100, 100, 100, 100);
+  gl.clearColor(0.0, 0.0, 0.0, ALPHA_VALUE);
+  gl.clear(gl.COLOR_BUFFER_BIT);
+
+  return {
+    source: offscreenCanvas,
+    origin: { x: 0, y: 0 },
+    flipY: true,
+  };
+}
+
+function createSourceCanvas2d() {
+  const offscreenCanvas = new OffscreenCanvas(200, 200);
+  const context = offscreenCanvas.getContext("2d");
+
+  context.fillStyle = "rgba(255,0,0,0.498)";
+  context.fillRect(0, 0, 100, 100);
+
+  context.fillStyle = "rgba(0,255,0,0.498)";
+  context.fillRect(100, 0, 100, 100);
+
+  context.fillStyle = "rgba(0,0,255,0.498)";
+  context.fillRect(0, 100, 100, 100);
+
+  context.fillStyle = "rgba(0,0,0,0.498)";
+  context.fillRect(100, 100, 100, 100);
+
+  return {
+    source: offscreenCanvas,
+    origin: { x: 0, y: 0 },
+    flipY: false,
+  };
+}
+
+function createSourceImageBitmap() {
+  const sourceCanvas = createSourceCanvas2d();
+  return {
+    source: sourceCanvas.source.transferToImageBitmap(),
+    origin: { x: 0, y: 0 },
+    flipY: false,
+  };
+}
+
+async function mapDestTexture(device, source, destFormat, premultiply, copySize) {
+  const bytesPerRow = 256 * 4; // 256 aligned for 200 pixels
+  const texture = device.createTexture({
+    format: destFormat,
+    size: copySize,
+    usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.COPY_DST,
+  });
+
+  device.queue.copyExternalImageToTexture(
+    source,
+    { texture, premultipliedAlpha: premultiply },
+    copySize,
+  );
+
+  const buffer = device.createBuffer({
+    size: 1024 * 200,
+    usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST,
+  });
+
+  const encoder = device.createCommandEncoder();
+  encoder.copyTextureToBuffer(
+    { texture },
+    { buffer, bytesPerRow },
+    copySize,
+  );
+  device.queue.submit([encoder.finish()]);
+
+  await buffer.mapAsync(GPUMapMode.READ);
+  return buffer;
+}
+
+async function verifyBuffer(test, device, source, format, premultiply, copyDim, topLeftPixelData) {
+  try {
+    const buffer = await mapDestTexture(device, source, format, premultiply, copyDim);
+    const arrayBuffer = buffer.getMappedRange();
+    const view = new Uint8Array(arrayBuffer);
+    for (let i = 0; i < topLeftPixelData.length; ++i) {
+      is(view[i], topLeftPixelData[i], test + " " + format + " (" + source.origin.x + "," + source.origin.y + ") channel " + i);
+    }
+  } catch(e) {
+    ok(false, "WebGPU exception: " + e);
+  }
+}
+
+async function verifySourceCanvas(test, device, source) {
+  await verifyBuffer(test, device, source, "rgba8unorm", /* premultiply */ true,  { width: 200, height: 200 }, [127, 0, 0, 127]);
+  await verifyBuffer(test, device, source, "bgra8unorm", /* premultiply */ true,  { width: 200, height: 200 }, [0, 0, 127, 127]);
+  await verifyBuffer(test, device, source, "rgba8unorm", /* premultiply */ false, { width: 200, height: 200 }, [255, 0, 0, 127]);
+  await verifyBuffer(test, device, source, "bgra8unorm", /* premultiply */ false, { width: 200, height: 200 }, [0, 0, 255, 127]);
+
+  // The copy is flipped but the origin is relative to the original source data,
+  // so we need to invert for WebGL.
+  const topRightPixelData = test === "webgl" ? [0, 0, 0, 127] : [0, 127, 0, 127];
+  const topRightOrigin = { origin: { x: 100, y: 0 } };
+  await verifyBuffer(test, device, { ...source, ...topRightOrigin }, "bgra8unorm", /* premultiply */ true, { width: 100, height: 100 }, topRightPixelData);
+
+  const bottomLeftPixelData = test === "webgl" ? [0, 0, 127, 127] : [127, 0, 0, 127];
+  const bottomLeftOrigin = { origin: { x: 0, y: 100 } };
+  await verifyBuffer(test, device, { ...source, ...bottomLeftOrigin }, "bgra8unorm", /* premultiply */ true, { width: 100, height: 100 }, bottomLeftPixelData);
+}
+
+async function writeDestCanvas(source2d, sourceWebgl, sourceImageBitmap) {
+  const adapter = await navigator.gpu.requestAdapter();
+  const device = await adapter.requestDevice();
+  await verifySourceCanvas("2d", device, source2d);
+  await verifySourceCanvas("imageBitmap", device, sourceImageBitmap);
+  await verifySourceCanvas("webgl", device, sourceWebgl);
+}
+
+async function runTest() {
+  try {
+    const source2d = createSourceCanvas2d();
+    const sourceWebgl = createSourceCanvasWebgl();
+    const sourceImageBitmap = createSourceImageBitmap();
+    await requestAnimationFramePromise();
+    await requestAnimationFramePromise();
+    await writeDestCanvas(source2d, sourceWebgl, sourceImageBitmap);
+  } catch(e) {
+    ok(false, "Uncaught exception: " + e);
+  } finally {
+    SimpleTest.finish();
+  }
+}
+
+runTest();
+  </script>
+</body>
+
+</html>
diff --git a/dom/webgpu/mochitest/test_queue_write.html b/dom/webgpu/mochitest/test_queue_write.html
new file mode 100644
index 0000000000..bcc8a104df
--- /dev/null
+++ b/dom/webgpu/mochitest/test_queue_write.html
@@ -0,0 +1,33 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+<meta charset='utf-8'>
+<script src="/tests/SimpleTest/SimpleTest.js"></script>
+<link rel="stylesheet" href="/tests/SimpleTest/test.css">
+</head>
+<body>
+<script>
+
+ok(SpecialPowers.getBoolPref('dom.webgpu.enabled'), 'Pref should be enabled.');
+
+const func = async function() {
+  const adapter = await navigator.gpu.requestAdapter();
+  const device = await adapter.requestDevice();
+  const buffer = device.createBuffer({size:16, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.VERTEX});
+  const arrayBuf = new ArrayBuffer(16);
+  (new Int32Array(arrayBuf)).fill(5)
+  device.queue.writeBuffer(buffer, 0, arrayBuf, 0);
+  const texture = device.createTexture({size: [2,2,1], dimension: "2d", format: "rgba8unorm", usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC });
+  device.queue.writeTexture({ texture }, arrayBuf, { bytesPerRow:8 }, [2,2,1]);
+  // this isn't a process check, we need to read back the contents and verify the writes happened
+  ok(device !== undefined, '');
+};
+
+SimpleTest.waitForExplicitFinish();
+func()
+  .catch((e) => ok(false, "Unhandled exception " + e))
+  .finally(() => SimpleTest.finish());
+
+</script>
+</body>
+</html>
diff --git a/dom/webgpu/mochitest/test_submit_compute_empty.html b/dom/webgpu/mochitest/test_submit_compute_empty.html
new file mode 100644
index 0000000000..e5a9eabfc1
--- /dev/null
+++ b/dom/webgpu/mochitest/test_submit_compute_empty.html
@@ -0,0 +1,31 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+<meta charset='utf-8'>
+<script src="/tests/SimpleTest/SimpleTest.js"></script>
+<link rel="stylesheet" href="/tests/SimpleTest/test.css">
+</head>
+<body>
+<script>
+
+ok(SpecialPowers.getBoolPref('dom.webgpu.enabled'), 'Pref should be enabled.');
+
+const func = async function() {
+  const adapter = await navigator.gpu.requestAdapter();
+  const device = await adapter.requestDevice();
+  const encoder = device.createCommandEncoder();
+  const pass = encoder.beginComputePass();
+  pass.endPass();
+  const command_buffer = encoder.finish();
+  device.queue.submit([command_buffer]);
+  ok(command_buffer !== undefined, 'command_buffer !== undefined');
+};
+
+SimpleTest.waitForExplicitFinish();
+func()
+  .catch((e) => ok(false, "Unhandled exception " + e))
+  .finally(() => SimpleTest.finish());
+
+</script>
+</body>
+</html>
diff --git a/dom/webgpu/mochitest/test_submit_render_empty.html b/dom/webgpu/mochitest/test_submit_render_empty.html
new file mode 100644
index 0000000000..aec2a606ef
--- /dev/null
+++ b/dom/webgpu/mochitest/test_submit_render_empty.html
@@ -0,0 +1,53 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+<meta charset='utf-8'>
+<script src="/tests/SimpleTest/SimpleTest.js"></script>
+<link rel="stylesheet" href="/tests/SimpleTest/test.css">
+</head>
+<body>
+<script>
+
+ok(SpecialPowers.getBoolPref('dom.webgpu.enabled'), 'Pref should be enabled.');
+
+const func = async function() {
+  const adapter = await navigator.gpu.requestAdapter();
+  const device = await adapter.requestDevice();
+
+  const swapChainFormat = "rgba8unorm";
+  const bundleEncoder = device.createRenderBundleEncoder({
+    colorFormats: [swapChainFormat],
+  });
+  const bundle = bundleEncoder.finish({});
+
+  const texture = device.createTexture({
+    size: { width: 100, height: 100, depth: 1 },
+    format: swapChainFormat,
+    usage: GPUTextureUsage.RENDER_ATTACHMENT,
+  });
+  const view = texture.createView();
+
+  const encoder = device.createCommandEncoder();
+  const pass = encoder.beginRenderPass({
+    colorAttachments: [{
+      view,
+      loadValue: { r: 0, g: 0, b: 0, a: 0 },
+      storeOp: "store",
+    }],
+  });
+  pass.executeBundles([bundle]);
+  pass.endPass();
+  const command_buffer = encoder.finish();
+
+  device.queue.submit([command_buffer]);
+  ok(command_buffer !== undefined, 'command_buffer !== undefined');
+};
+
+SimpleTest.waitForExplicitFinish();
+func()
+  .catch((e) => ok(false, "Unhandled exception " + e))
+  .finally(() => SimpleTest.finish());
+
+</script>
+</body>
+</html>
diff --git a/dom/webgpu/mochitest/test_submit_render_empty.worker.html b/dom/webgpu/mochitest/test_submit_render_empty.worker.html
new file mode 100644
index 0000000000..100f866ecc
--- /dev/null
+++ b/dom/webgpu/mochitest/test_submit_render_empty.worker.html
@@ -0,0 +1,16 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+<meta charset='utf-8'>
+<script src="/tests/SimpleTest/SimpleTest.js"></script>
+<script src="worker_wrapper.js"></script>
+<link rel="stylesheet" href="/tests/SimpleTest/test.css">
+</head>
+<body>
+<script>
+
+runWorkerTest('test_submit_render_empty.worker.js', {}, []);
+
+</script>
+</body>
+</html>
diff --git a/dom/webgpu/mochitest/test_submit_render_empty.worker.js b/dom/webgpu/mochitest/test_submit_render_empty.worker.js
new file mode 100644
index 0000000000..1d922d38d5
--- /dev/null
+++ b/dom/webgpu/mochitest/test_submit_render_empty.worker.js
@@ -0,0 +1,48 @@
+self.addEventListener("message", async function(event) {
+  try {
+    const adapter = await navigator.gpu.requestAdapter();
+    const device = await adapter.requestDevice();
+
+    const swapChainFormat = "rgba8unorm";
+    const bundleEncoder = device.createRenderBundleEncoder({
+      colorFormats: [swapChainFormat],
+    });
+    const bundle = bundleEncoder.finish({});
+
+    const texture = device.createTexture({
+      size: { width: 100, height: 100, depth: 1 },
+      format: swapChainFormat,
+      usage: GPUTextureUsage.RENDER_ATTACHMENT,
+    });
+    const view = texture.createView();
+
+    const encoder = device.createCommandEncoder();
+    const pass = encoder.beginRenderPass({
+      colorAttachments: [
+        {
+          view,
+          loadValue: { r: 0, g: 0, b: 0, a: 0 },
+          storeOp: "store",
+        },
+      ],
+    });
+    pass.executeBundles([bundle]);
+    pass.endPass();
+    const command_buffer = encoder.finish();
+
+    device.queue.submit([command_buffer]);
+    self.postMessage([
+      {
+        value: command_buffer !== undefined,
+        message: "command_buffer !== undefined",
+      },
+    ]);
+  } catch (e) {
+    self.postMessage([
+      {
+        value: false,
+        message: "Unhandled exception " + e,
+      },
+    ]);
+  }
+});
diff --git a/dom/webgpu/mochitest/worker_wrapper.js b/dom/webgpu/mochitest/worker_wrapper.js
new file mode 100644
index 0000000000..19ce6dd21e
--- /dev/null
+++ b/dom/webgpu/mochitest/worker_wrapper.js
@@ -0,0 +1,33 @@
+ok(
+  SpecialPowers.getBoolPref("dom.webgpu.enabled"),
+  "WebGPU pref should be enabled."
+);
+ok(
+  SpecialPowers.getBoolPref("gfx.offscreencanvas.enabled"),
+  "OffscreenCanvas pref should be enabled."
+);
+SimpleTest.waitForExplicitFinish();
+
+const workerWrapperFunc = async function(worker_path, data, transfer) {
+  const worker = new Worker(worker_path);
+
+  const results = new Promise((resolve, reject) => {
+    worker.addEventListener("message", event => {
+      resolve(event.data);
+    });
+  });
+
+  worker.postMessage(data, transfer);
+  for (const result of await results) {
+    ok(result.value, result.message);
+  }
+};
+
+async function runWorkerTest(worker_path, data, transfer) {
+  try {
+    await workerWrapperFunc(worker_path, data, transfer);
+  } catch (e) {
+    ok(false, "Unhandled exception " + e);
+  }
+  SimpleTest.finish();
+}
diff --git a/dom/webgpu/moz.build b/dom/webgpu/moz.build
new file mode 100644
index 0000000000..9ff27f6dd4
--- /dev/null
+++ b/dom/webgpu/moz.build
@@ -0,0 +1,74 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+with Files("**"):
+    BUG_COMPONENT = ("Core", "Graphics: WebGPU")
+
+MOCHITEST_MANIFESTS += [
+    "mochitest/mochitest-no-pref.ini",
+    "mochitest/mochitest.ini",
+]
+
+DIRS += []
+
+h_and_cpp = [
+    "Adapter",
+    "BindGroup",
+    "BindGroupLayout",
+    "Buffer",
+    "CanvasContext",
+    "CommandBuffer",
+    "CommandEncoder",
+    "CompilationInfo",
+    "CompilationMessage",
+    "ComputePassEncoder",
+    "ComputePipeline",
+    "Device",
+    "DeviceLostInfo",
+    "Instance",
+    "ObjectModel",
+    "OutOfMemoryError",
+    "PipelineLayout",
+    "QuerySet",
+    "Queue",
+    "RenderBundle",
+    "RenderBundleEncoder",
+    "RenderPassEncoder",
+    "RenderPipeline",
+    "Sampler",
+    "ShaderModule",
+    "SupportedFeatures",
+    "SupportedLimits",
+    "Texture",
+    "TextureView",
+    "ValidationError",
+]
+EXPORTS.mozilla.webgpu += [x + ".h" for x in h_and_cpp]
+UNIFIED_SOURCES += [x + ".cpp" for x in h_and_cpp]
+
+IPDL_SOURCES += [
+    "ipc/PWebGPU.ipdl",
+    "ipc/PWebGPUTypes.ipdlh",
+]
+
+EXPORTS.mozilla.webgpu += [
+    "ipc/WebGPUChild.h",
+    "ipc/WebGPUParent.h",
+    "ipc/WebGPUSerialize.h",
+    "ipc/WebGPUTypes.h",
+]
+
+UNIFIED_SOURCES += [
+    "ipc/WebGPUChild.cpp",
+    "ipc/WebGPUParent.cpp",
+]
+
+if CONFIG["CC_TYPE"] in ("clang", "clang-cl"):
+    CXXFLAGS += ["-Werror=implicit-int-conversion"]
+
+include("/ipc/chromium/chromium-config.mozbuild")
+
+FINAL_LIBRARY = "xul"