# gpuweb/gpuweb: The WebGPU and WGSL Specification Repository

> gpuweb/gpuweb is the W3C working repository for the WebGPU API and WebGPU Shading Language (WGSL) specifications. It is not a library to install but the source of the specifications that browser engines implement, along with the issue tracker, design documents, and proposals that shape how the GPU is exposed to web applications.

**gpuweb/gpuweb** — Where the GPU for the Web work happens!

- Repository: https://github.com/gpuweb/gpuweb
- Website: https://webgpu.org
- Stars: 5,488 · Forks: 385
- Language: Bikeshed
- License: NOASSERTION
- Published: 2026-09-22 · Updated: 2026-09-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/gpuweb-gpuweb

## What This Repository Contains

The gpuweb/gpuweb repository holds the Bikeshed source files for two related specifications: the WebGPU API specification and the WebGPU Shading Language (WGSL) specification. Bikeshed is a document format used by W3C groups to write specifications; it produces HTML output that becomes the published specification text at gpuweb.github.io/gpuweb/ and gpuweb.github.io/gpuweb/wgsl/. The repository also contains design documents in the design/ directory, an explainer aimed at non-specialist readers in explainer/, proposals for new features in proposals/, and correspondence records in correspondence/. The tools/ directory holds build scripts that automate parts of the specification generation process. The wiki and issue tracker on GitHub serve as the main coordination surfaces for the working group.

The repository root also includes a w3c.json file that declares the group affiliation and repository type as required by W3C tooling, a .devcontainer/ configuration for development containers, and a .vscode/ configuration for contributors who use Visual Studio Code. The logo/ directory holds the WebGPU logo assets. The spec/ directory contains the main WebGPU API specification source, and the wgsl/ directory is a separate subdirectory with its own Makefile for the shading language specification. These two are built independently because WGSL evolves somewhat separately from the API surface and has its own dedicated subgroup within the working group.

## How the Standardization Process Works

The specification is developed in two overlapping groups. The W3C GPU for the Web Community Group (CG) is where the work originates and is open to anyone with a W3C account, including individuals not affiliated with a W3C member organization. The W3C GPU for the Web Working Group (WG) formally standardizes the output. All participants must agree to a Contributor License Agreement before submitting changes. Issues, errors, and suggestions can be filed by any GitHub user without joining the Community Group or Working Group, which makes it straightforward to report a mistake in the spec or propose a clarification. Design discussions happen in the issue tracker and in the Matrix channel at #WebGPU:matrix.org. Both groups also have W3C email lists for administrative matters, though the README notes these are largely administrative.

## Building the Specification Locally

The repository uses a Makefile to build the HTML specification output. Building all targets in parallel:

```bash
make -j
```

This builds the spec, explainer, and correspondence directories. The WGSL specification has its own build process and must be built separately:

```bash
make -C wgsl
```

To build everything and copy the output to the out/ directory:

```bash
make out
```

The build depends on the Bikeshed toolchain and other utilities documented in CONTRIBUTING.md. The .devcontainer/ directory in the repository provides a development container configuration that sets up the necessary toolchain without a manual install. Cleaning all generated files:

```bash
make clean
```

For most readers, building the spec locally is unnecessary since the rendered output is continuously published at gpuweb.github.io.

## WebGPU as a Replacement for WebGL

WebGL, the previous standard for GPU access on the web, is built on OpenGL ES 2.0 and 3.0, which are APIs from 2007 and 2012 respectively. WebGL exposes a single-threaded rendering API that does not map well to modern GPU architectures, which are designed around lower-level control, explicit synchronization, and compute pipelines. WebGPU is designed to expose those modern GPU capabilities: it covers both rendering and general-purpose compute, uses an explicit resource and command model, and aligns with the design of Vulkan, Metal, and Direct3D 12 at the API level rather than the OpenGL level. Vulkan itself is a lower-level native API not available in web browsers; WebGPU occupies the layer above it, providing a web-safe interface with the same architectural assumptions. The WebGPU Shading Language (WGSL) replaces GLSL as the shading language, with stricter syntax and type rules suited to a web security model.

The design/ directory in the repository documents the rationale behind specific API choices, including error handling models, buffer mapping strategies, and the pipeline state object design. These documents are useful for understanding why the API looks the way it does, not just what it does. The proposals/ directory holds extensions and additions that are under active discussion but have not yet entered the main specification. Proposals vary widely in maturity: some have implementations in browsers, others are early-stage ideas. The explainer/ directory contains prose written for a general engineering audience, describing the motivation for WebGPU and its high-level design without the normative language of the specification itself. The specification's normative text uses Bikeshed's algorithm notation and type definitions, which differ from both the explainer and the proposals in their precision and legal force.

## Who the Repository Is For

This repository is primarily useful to four groups. Browser engine implementors (Chromium, Firefox, WebKit) track specification changes here to keep their implementations aligned with the working group's intent. Specification contributors participate in the issue tracker and submit pull requests to the Bikeshed source. Researchers and standards followers read the design documents and proposals to understand how specific features were designed and what trade-offs were considered. Web developers working on WebGPU applications can use the specification as the authoritative reference for API behavior, though the rendered output at gpuweb.github.io is more accessible than the raw Bikeshed source. The README explicitly encourages hardware vendors, browser engine developers, 3D software engineers, and web developers with graphics expertise to participate.

## Limitations of the Specification Repository

The repository does not contain a runnable implementation of WebGPU. It has no npm package, no JavaScript library, and no binary to download. Developers who want to use WebGPU in a web application write against the API in a browser that already implements it, such as Chrome. The specification text describes what browser implementations must do; it does not perform any computation itself. Proposals in the proposals/ directory represent ideas under discussion and are not necessarily implemented in any browser. The CONTRIBUTING.md and wiki pages document the process for bringing a proposal to the point where it enters the specification. Features may take months or years to move from proposal to specification text to browser implementation, so checking browser compatibility tables separately from the specification is necessary for production web development.

The Contributor License Agreement requirement is a real barrier for some contributors. W3C's CLA transfers patent rights relevant to the specification to the working group's patent pool, which is necessary for the specification to be freely implementable by browser vendors. Individual contributors who are employed by companies need to confirm that their employer's W3C membership and IP policies cover the contribution. Someone affiliated with a W3C member organization needs their W3C representative to confirm participation. The process is documented in the Community Group membership pages but can slow down first-time contributions from engineers at large organizations. Filing issues does not require joining or signing the CLA, so reporting errors or asking questions has no prerequisite beyond a GitHub account.

## Conclusion

gpuweb/gpuweb is the right place to track the WebGPU specification if you are implementing a browser engine, writing a polyfill, contributing to the standard, or simply want to read the authoritative specification text. It is not a library or SDK to install in a project. Web developers who want to write WebGPU code should target the implemented specification in Chrome, Firefox, or Safari rather than building from this repository. Specification contributors need a W3C account and must agree to the Contributor License Agreement before submitting changes. The specification text is generated from the Bikeshed source in the spec/ and wgsl/ directories using the Makefile.

## FAQ

### Which is better, WebGPU or Vulkan?

WebGPU and Vulkan serve different contexts. Vulkan is a native API for desktop and mobile applications with direct hardware access. WebGPU is a web standard designed to run safely in a browser, translating to Vulkan, Metal, or Direct3D 12 depending on the platform. They are not interchangeable: use Vulkan for native apps, WebGPU for web applications.

### What is replacing WebGL?

WebGPU is the W3C standard intended to succeed WebGL. It is based on modern GPU API design principles from Vulkan, Metal, and Direct3D 12, covering both rendering and compute workloads. The specification is developed in this repository.

### How do I enable WebGPU features in Chrome?

The gpuweb/gpuweb repository does not document browser flags or experimental feature toggles. WebGPU is enabled by default in recent Chrome versions; for experimental features listed in proposals/, check the Chromium issue tracker or Chrome's chrome://flags page.

## Sources

- [gpuweb/gpuweb on GitHub](https://github.com/gpuweb/gpuweb)
- [Issues](https://github.com/gpuweb/gpuweb/issues)
- [Project website](https://webgpu.org)
- [README](https://github.com/gpuweb/gpuweb/blob/main/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/gpuweb-gpuweb