GPUDevice

The GPUDevice interface of the WebGPU API represents a logical GPU device. This is the main interface through which the majority of WebGPU functionality is accessed.

A GPUDevice object is requested using the GPUAdapter.requestDevice() method.

Instance properties

Inherits properties from its parent, EventTarget.

adapterInfo Read only

A GPUAdapterInfo object containing identifying information about the device's originating adapter.

features Read only

A GPUSupportedFeatures object that describes additional functionality supported by the device.

label

A string providing a label that can be used to identify the object, for example in GPUError messages or console warnings.

limits Read only

A GPUSupportedLimits object that describes the limits supported by the device.

lost Read only

Contains a Promise that remains pending throughout the device's lifetime and resolves with a GPUDeviceLostInfo object when the device is lost.

queue Read only

Returns the primary GPUQueue for the device.

Instance methods

Inherits methods from its parent, EventTarget.

createBindGroup()

Creates a GPUBindGroup based on a GPUBindGroupLayout that defines a set of resources to be bound together in a group and how those resources are used in shader stages.

createBindGroupLayout()

Creates a GPUBindGroupLayout that defines the structure and purpose of related GPU resources such as buffers that will be used in a pipeline, and is used as a template when creating GPUBindGroups.

createBuffer()

Creates a GPUBuffer in which to store raw data to use in GPU operations.

createCommandEncoder()

Creates a GPUCommandEncoder, which is used to encode commands to be issued to the GPU.

createComputePipeline()

Creates a GPUComputePipeline that can control the compute shader stage and be used in a GPUComputePassEncoder.

createComputePipelineAsync()

Returns a Promise that fulfills with a GPUComputePipeline, which can control the compute shader stage and be used in a GPUComputePassEncoder, once the pipeline can be used without any stalling.

createPipelineLayout()

Creates a GPUPipelineLayout that defines the GPUBindGroupLayouts used by a pipeline. GPUBindGroups used with the pipeline during command encoding must have compatible GPUBindGroupLayouts.

createQuerySet()

Creates a GPUQuerySet that can be used to record the results of queries on passes, such as occlusion or timestamp queries.

createRenderBundleEncoder()

Creates a GPURenderBundleEncoder that can be used to pre-record bundles of commands. These can be reused in GPURenderPassEncoders via the executeBundles() method, as many times as required.

createRenderPipeline()

Creates a GPURenderPipeline that can control the vertex and fragment shader stages and be used in a GPURenderPassEncoder or GPURenderBundleEncoder.

createRenderPipelineAsync()

Returns a Promise that fulfills with a GPURenderPipeline, which can control the vertex and fragment shader stages and be used in a GPURenderPassEncoder or GPURenderBundleEncoder, once the pipeline can be used without any stalling.

createSampler()

Creates a GPUSampler, which controls how shaders transform and filter texture resource data.

createShaderModule()

Creates a GPUShaderModule from a string of WGSL source code.

createTexture()

Creates a GPUTexture in which to store texture data to use in GPU rendering operations.

destroy()

Destroys the device, preventing further operations on it.

importExternalTexture()

Takes an HTMLVideoElement as an input and returns a GPUExternalTexture wrapper object containing a snapshot of the video that can be used in GPU rendering operations.

popErrorScope()

Pops an existing GPU error scope from the error scope stack and returns a Promise that resolves to an object (GPUInternalError, GPUOutOfMemoryError, or GPUValidationError) describing the first error captured in the scope, or null if no error occurred.

pushErrorScope()

Pushes a new GPU error scope onto the device's error scope stack, allowing you to capture errors of a particular type.

Events

uncapturederror

Fired when an error is thrown that has not been observed by a GPU error scope, to provide a way to report unexpected errors. Known error cases should be handled using pushErrorScope() and popErrorScope().

Examples

async function init() {
  if (!navigator.gpu) {
    throw Error("WebGPU not supported.");
  }

  const adapter = await navigator.gpu.requestAdapter();
  if (!adapter) {
    throw Error("Couldn't request WebGPU adapter.");
  }

  const device = await adapter.requestDevice();

  const shaderModule = device.createShaderModule({
    code: shaders,
  });

  // …
}

See the individual member pages listed above and the following demo sites for a lot more examples of GPUDevice usage:

• Basic compute demo
• Basic render demo
• WebGPU samples

Specifications

Browser compatibility

See also

• The WebGPU API