English for WebGPU Developers

WebGPU replaces WebGL with an API that mirrors modern native graphics APIs like Vulkan and Metal — which means the English vocabulary around it is precise about pipelines, binding layouts, and synchronization rather than the looser “shader and draw call” language of the WebGL era. Getting this vocabulary right matters in code review, where a vague description of a pipeline or a buffer layout can hide a real performance bug. This guide covers the English used when discussing WebGPU code with a team.

Key Vocabulary

Pipeline — a precompiled, immutable object that bundles a shader, vertex layout, and render state together, created once and reused across draw calls. “We’re recreating the render pipeline every frame — let’s hoist that out and cache it, since pipeline creation is expensive.”

Bind group — a set of resources (buffers, textures, samplers) bound to a shader at specific slots, matched against a bind group layout declared up front. “The bind group layout expects a uniform buffer at binding zero, but we’re passing a storage buffer — that’s the mismatch causing the validation error.”

Command encoder — an object used to record GPU commands (draw calls, compute dispatches, copies) into a command buffer before submitting them to the queue. “Batch all of this frame’s draw calls into a single command encoder instead of submitting one buffer per draw — submission has overhead.”

Compute shader — a shader stage used for general-purpose parallel computation, not tied to rendering pixels, dispatched in workgroups. “Let’s move the particle simulation into a compute shader so it runs entirely on the GPU instead of round-tripping data to the CPU each frame.”

Uniform buffer — a small, read-only buffer passed to shaders for values like transformation matrices or constants, updated per frame or per draw. “The uniform buffer is only 64 bytes — we can pack the view and projection matrices into it and skip the separate storage buffer.”

Adapter and device — the adapter represents the physical GPU; the device is the logical interface you request from it and use to create resources. “Request a high-performance adapter explicitly — on laptops with a discrete GPU, the default request can silently return the integrated one.”

Common Phrases

• “Is this pipeline being recreated every frame, or is it cached across frames?”
• “What’s in this bind group, and does it match the layout the shader expects?”
• “Are we submitting one command buffer per draw call, or batching them?”
• “This should run as a compute shader — there’s no reason to touch the render pipeline for this.”
• “Did we request the discrete GPU adapter, or are we falling back to integrated graphics?”

Example Sentences

Reviewing a pull request: “This bind group layout declares a sampler at binding two, but the shader never samples a texture there — can we remove the unused binding before this merges?”

Explaining a design decision: “We split the particle update into a compute pass and the particle rendering into a separate render pass, so the two can be profiled and optimized independently.”

Describing a bug: “The validation layer flagged a buffer usage mismatch — we created the buffer without the STORAGE usage flag, so the compute shader can’t write to it.”

Professional Tips

• Say “pipeline” to mean the whole compiled render or compute configuration, not just “the shader” — conflating the two confuses discussions about caching and performance.
• When reviewing GPU code, ask “is this resource re-created every frame?” — pipeline and bind group creation are expensive, and English reviewers flag this explicitly as a “per-frame allocation” concern.
• Distinguish “adapter” (the physical GPU) from “device” (your logical handle to it) when explaining a GPU selection bug.
• Use “dispatch” for compute shaders and “draw call” for render pipelines — mixing the terms signals unfamiliarity with the API’s mental model.

Practice Exercise

1. Explain in two sentences why recreating a pipeline every frame is a performance problem.
2. Write a one-sentence code review comment flagging a bind group that doesn’t match its declared layout.
3. Describe, in your own words, the difference between a compute shader dispatch and a render pipeline draw call.