What's New in WebGPU (Chrome 149-150)

François Beaufort
François Beaufort
GitHub

Published: June 17, 2026

Immediates

Immediates, also known as push constants or root constants, let you pass small amounts of frequently changing data directly to shaders. This process bypasses the overhead of creating GPU buffers and managing bind groups.

Updating uniform buffer bindings for data that changes every draw call—such as a unique object ID or a 3D transformation matrix for hundreds of objects—creates CPU overhead. Inject raw values directly into the pass encoder to avoid writing data to memory and managing GPU lookups.

Immediates provide a fast path for tiny, highly dynamic variables. Use uniform buffers or storage buffers for large arrays of data, complex lighting structures, or massive matrices.

In your WGSL shader, the <immediate> address space lets you define immediate data that can be passed directly to the pass encoder. Call setImmediates() in JavaScript before a draw call to provide this data without binding a group. To check for support, feature-detect the immediate_address_space WGSL language extension through navigator.gpu.wgslLanguageFeatures. See the following example and the intent to ship.

if (!navigator.gpu.wgslLanguageFeatures.has('immediate_address_space')) {
   throw new Error(`WGSL immediate address space is not available`);
}

const adapter = await navigator.gpu.requestAdapter();
const device = await adapter.requestDevice();

const module = device.createShaderModule({ code: `
  requires immediate_address_space;

  var<immediate> color: vec4f;

  @vertex fn vertexMain(@builtin(vertex_index) i : u32) -> @builtin(position) vec4f {
    const pos = array(vec2f(0, 1), vec2f(-1, -1), vec2f(1, -1));
    return vec4f(pos[i], 0, 1);
  }

  @fragment fn fragmentMain() -> @location(0) vec4f {
    return color;
  }`,
});

// Create render pass encoder (omitted)...

// By using layout: 'auto', WebGPU will automatically infer the `immediateSize`
// required by the pipeline layout from the WGSL module.
const pipeline = device.createRenderPipeline({
  layout: 'auto',
  vertex: { module },
  fragment: { module, targets: [{ format }] },
});
myRenderPassEncoder.setPipeline(pipeline);

// Send immediate data to the GPU, then issue a draw call
myRenderPassEncoder.setImmediates(/*rangeOffset=*/0, new Float32Array([255, 0, 0, 255]));
myRenderPassEncoder.draw(3);
myRenderPassEncoder.end();

For a deeper dive into this feature, take a look at WebGPUFundamentals Immediates.

Kudos to the team at Microsoft for their contributions!

Stricter validation for transient attachments

WebGPU recently introduced the TRANSIENT_ATTACHMENT GPUTextureUsage flag, which lets developers create temporary render attachments, such as depth-stencil buffers or multisampled targets. These attachments stay in fast, on-chip tile memory without allocating main VRAM.

Recent updates (#6248 and #6267) refine validation rules to prevent misuse of these memory-efficient texture attachments:

  • Due to platform limitations, viewFormats must be an empty array when creating transient textures. Alternative view formats are not needed because transient textures are only for rendering.
  • Creating a texture view does not narrow down usage flags. When calling createView() on a transient texture, the view cannot change its usage.
  • Transient attachments cannot be used as a resolveTarget inside a render pass.

Dawn updates

This covers only some of the key highlights. Check out the exhaustive list of commits.

What's New in WebGPU

A list of everything that has been covered in the What's New in WebGPU series.

Chrome 149-150

Chrome 147-148

Chrome 146

Chrome 145

Chrome 144

Chrome 143

Chrome 142

Chrome 141

Chrome 140

Chrome 139

Chrome 138

Chrome 137

Chrome 136

Chrome 135

Chrome 134

Chrome 133

Chrome 132

Chrome 131

Chrome 130

Chrome 129

Chrome 128

Chrome 127

Chrome 126

Chrome 125

Chrome 124

Chrome 123

Chrome 122

Chrome 121

Chrome 120

Chrome 119

Chrome 118

Chrome 117

Chrome 116

Chrome 115

Chrome 114

Chrome 113