bufferView

syntax

Two overloads (verbatim from WGSL §17.14.1) — one for runtime-sized, one for fixed-size buffer pointers; both are @must_use:

@must_use fn bufferView<T>(p : ptr<AS, buffer, AM>, offset : I) -> ptr<AS, T, AM>

@must_use fn bufferView<T>(p : ptr<AS, buffer<N>, AM>, offset : I) -> ptr<AS, T, AM>

The helper definition that drives validation (§17.14):

• ArrayOffset(T) = OffsetOfMember(T, lastMemberIndex) if T is a structure whose last member is a runtime-sized array, else 0.
• MinTypeSize(T) = SizeOf(T) if T has a fixed footprint; StrideOf(T) if T is a runtime-sized array; ArrayOffset(T) + StrideOf(array<E>) if T is a structure ending in a runtime-sized array.

inputs

outputs

A ptr<AS, T, AM> usable like any other pointer. Formally: if the memory locations associated with p are in the range [0, bufferLength(p)), then the memory locations associated with the result are in the range [offset, bufferLength(p)) with store type T. When T has no fixed footprint (a runtime-sized array or a struct ending in one), the runtime element count derives from the buffer binding per WGSL §13.3.4, and arrayLength on the result reports it (arrayLength's AS may be uniform or workgroup only when its argument derives from bufferView/bufferArrayView — §17.4.1 note).

errors

Size checks are performed interprocedurally, so user size reductions through function parameters are respected; the check also computes the minimum buffer size the binding must provide. The alignment-rounding rule interacts with the uniform_buffer_standard_layout language feature.

context and exposure

• Available in any shader stage; requires the buffer_view language extension (automatic when supported; document with requires buffer_view;).
• Operates on pointers in the storage, uniform, or workgroup address spaces. Passing a buffer pointer obtained from a helper function's formal parameter additionally requires unrestricted_pointer_parameters (see conversions); without it, the root identifier of the argument must be the originating variable.
• Because T cannot be a buffer type, the cast is single-shot: you always cast from an unmodified root identifier (modulo let unpacking) and only once before a memory access.

lifecycle

1. Declaration — a buffer variable is declared in storage/uniform/workgroup (see type rules); for storage/uniform it binds a GPUBuffer via a bind group.
2. Reinterpretation — bufferView converts the buffer pointer at a byte offset; validation happens at shader creation (const), pipeline creation (override), or produces an invalid pointer (runtime).
3. Use — the result pointer is dereferenced/read/written like any pointer of ptr<AS, T, AM>; subsequent arrayLength calls account for the view's offset.
4. No state, cancellation, or cleanup: the function is a pure pointer reinterpretation with @must_use semantics.

examples

Reading a packed header word and then viewing the tail as a typed array (pattern from the proposal):

requires buffer_view;

@group(0) @binding(0) var<storage> packed_data : buffer;

fn read_header_and_tail() {
  // View byte 0 as a u32 count.
  let count = *bufferView<u32>(&packed_data, 0);

  // View the remainder as an array of f32 starting at byte 4.
  let values = bufferView<array<f32>>(&packed_data, 4);

  let first = values[0];       // normal pointer indexing
  let n = arrayLength(&*values); // runtime element count from the binding
}

browser compatibility

Interim table (no BCD key for the feature or this built-in; compiled from primary sources, 2026-07-29):

security and privacy

• Out-of-contract offsets produce an invalid pointer (WebGPU out-of-bounds behavior), not raw memory access; the reinterpretation stays within the shader's own binding.
• Single-shot, non-atomic reinterpretation preserves WGSL's memory and atomicity guarantees; alignment is enforced or conservatively rounded down.
• No new JavaScript, storage, network, or fingerprinting surface (see the overview security section).

see also

• WebGPU: buffer_view feature — overview
• bufferArrayView · bufferLength
• WGSL §17.14 Buffer View Built-in Functions
• CTS execution tests · CTS validation tests
• Chrome Platform Status — WebGPU: buffer_view feature