Open-source project
gpuweb/gpuweb avatar
gpuweb/gpuweb

gpuweb/gpuweb: the repository where the WebGPU and WGSL specifications are written

Where the GPU for the Web work happens!

5,531 stars394 forksBikeshedNOASSERTION

At a glance

What is it?
This is not a library you install. It is the W3C GPU for the Web group's specification repository, holding the WebGPU API and WGSL source, the build tooling behind them, and the place where issues are filed. Here is what is actually in it and who it is for.
Who is it for?
Adopt this repository if you are reviewing or editing the WebGPU or WGSL specifications, or if you need the normative text and the design and proposals directories as a reference; file issues against it if you find a spec bug, since the README states that anyone with a GitHub account can do so without joining the group.
Can I use it commercially?
Check first. The repository uses a licence we do not classify automatically, so read its LICENSE file before any commercial use.
Is it still maintained?
Yes. The repository last received commits 5 days ago.
What is it written in?
Mainly Bikeshed, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 13, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • gpuweb/gpuweb5,531 ★ · +52
Star history
Repository2026-09-232026-11-13
gpuweb/gpuweb5.5k5.5k

52 Stars in the last 51 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

What gpuweb/gpuweb actually contains, and who it is written for

The README opens by describing the repository as the home of the W3C GPU for the Web Community Group's WebGPU API and WebGPU Shading Language (WGSL) specifications, and notes that the specification is formally standardized by the W3C GPU for the Web Working Group. That single sentence sets the audience. This is a standards repository: the primary artefact is prose that defines an API, not code that implements one. The README also states that the wiki and the issue tracker are the main sources of information related to the work, which tells you where discussion lives rather than in the tree itself.

The top-level listing backs that up. Alongside spec/ and wgsl/ you find design/, explainer/, proposals/, correspondence/ and process/, plus a Makefile and a tools/ directory. Those are the working surfaces of a specification effort: design notes, an explainer aimed at people outside the group, formal proposals for changes, and correspondence. If you came here looking for a shader compiler or a browser binding, you are in the wrong repository. If you came here to read or change the normative text, everything you need is in the tree.

The README is explicit that membership is not a gate for participation. It says you are not required to be a member of the Community Group or Working Group in order to file issues, errors, fixes or make suggestions, and that anyone with a GitHub account can do so. Membership in the Community Group is open to anyone, with a W3C account required to join, and hardware vendors, browser engine developers, 3D software engineers and web developers with graphics expertise are named as especially encouraged. All participants agree to the Contributor License Agreement, and the README points at CONTRIBUTING.md for technical guidance.

How the specification is built: Bikeshed sources, a Makefile, and a wgsl target that runs alone

The repository's primary language is listed as Bikeshed, which is the preprocessor used to turn specification source into publishable HTML. The Makefile is short and worth reading closely, because it encodes the actual build graph. It defines a variable named targets holding spec, explainer and correspondence, declares all as depending on those plus wgsl, and provides an out target that runs all and then calls bash ./tools/populate-out.sh to copy results into out/.

The interesting part is the comment above the targets variable, which says the Makefile should be invoked with make -j for full parallelism, and then immediately records a TODO: to include wgsl as a target once dependencies respect wgsl.so creation, and until then to execute make without -j. The wgsl target is therefore separate and runs as make -C wgsl rather than through the parallel path. That is a real constraint, not a stylistic one. If you run a parallel build across everything, you are working against what the file documents about itself.

A clean target exists and is deliberately blunt: it pipes the same targets list through xargs -n1 make clean -C and then removes out/. The data flow is therefore source in spec/, explainer/, correspondence/ and wgsl/, processed by Bikeshed through per-directory Makefiles, with an optional copy step into out/. Note what is absent: the Makefile does not run tests, does not validate examples, and does not publish anything to the live specification URLs given in the README. Those URLs point at gpuweb.github.io/gpuweb/ and gpuweb.github.io/gpuweb/wgsl/, which are built elsewhere.

Building the spec locally: what the Makefile lets you do

The README does not give installation steps, because this is not an installable package. The closest thing to a getting-started path is the Makefile in the repository root. The targets variable names three directories that build in parallel, and the all target adds wgsl on top. To build everything the file describes, you would run the default target from the repository root.

bash
make -j

The comment at the top of the Makefile states that this should be invoked with make -j for full parallelism, but the TODO immediately below it says wgsl is not yet part of the parallel set and that until then make should be executed without -j. The safe reading is that the parallel invocation applies to spec, explainer and correspondence, and that wgsl is built separately. To build only the WGSL specification, the file provides a dedicated target.

bash
make wgsl

If you want the generated output collected in one place rather than left in the individual directories, the out target runs the full build and then copies it.

bash
make out

That target depends on all and then executes bash ./tools/populate-out.sh, which is the step that populates the out/ directory. To undo a build, the clean target walks the same three directories and removes out/ as well.

bash
make clean

What you should see after a successful build is generated specification output in the respective directories, or in out/ if you used the out target. What the README does not document is which Bikeshed version to use, how to install it, or what the expected output filenames are. Those answers are not in the repository's front page, so treat the first build as an exercise in reading the per-directory Makefiles rather than following a documented recipe.

The limits: no runtime, no compiler, and a build that the Makefile itself flags as fragile

The most important limitation is categorical. Nothing in the README or the file listing provides a WebGPU implementation. There is no adapter, no device, no queue, no shader compiler binary. If you want to run WebGPU code, you need a browser or an implementation, and this repository is not that. Cloning it to get a working GPU stack is the wrong move.

The second limitation is the build. The Makefile's own TODO records that the wgsl target cannot yet join the parallel build because dependencies do not respect wgsl.so creation. A specification repository whose build has a documented ordering hazard around a generated file is a repository where a clean parallel build is not guaranteed. That is a maintenance cost you inherit if you build the text yourself.

The third is documentation scope. The README points to the wiki and the issue tracker as the main sources of information, and to CONTRIBUTING.md for technical guidance, but the README itself gives no build prerequisites, no Bikeshed version pin, and no description of what the generated files are named. For a project of this size, the front page is thin on operational detail and pushes you into other surfaces. That is a deliberate choice about where the work happens, but it means a newcomer cannot go from README to a successful build without reading the Makefiles and the contributing guide.

Alternatives: the specification versus the implementations it describes

The natural alternative is not another specification repository. It is an implementation. If your goal is to write and run WGSL shaders or to call a WebGPU device, you want a browser engine's WebGPU support or a native implementation that tracks the same specification, and the difference in approach is total: those projects consume the text that gpuweb/gpuweb produces. They ship binaries and expose an API; this repository ships normative prose and a Bikeshed build. Choosing between them is not a matter of preference, it is a matter of whether you are producing the standard or using it.

Within the standards world, the closest structural alternative is the group's own administrative repository, which the README names when it says the charter for this group is maintained in a separate repository at github.com/gpuweb/admin. That is a meaningful split: governance, the charter and the contribution guidelines live outside this tree, while the specification, design notes and proposals live inside it. If you are trying to understand how the group is constituted rather than what the API says, the admin repository is the one to read. The README also points at the Community Group page on w3.org and the Working Group page for the formal standardization track, both of which are outside this repository.

A third comparison is against the specification's own published output. The README gives two work-in-progress URLs, one for WebGPU and one for WGSL. If you only need to read the current text, those pages are the faster path and require no build at all. Cloning the repository makes sense when you need history, when you want to search the source for the exact wording, or when you intend to propose a change.

Maintenance, licence and the cost of tracking a moving specification

The repository is not archived, and the last push was on 2026-10-30, so the tree is current. That recency matters for a different reason than usual: a specification repository's value is partly that it reflects the state of the debate. A stale copy of a spec is worse than no copy, because it reads as authoritative while missing later resolutions. If you vendor any part of this text into your own documentation, you are taking on the job of re-syncing it.

Upgrade cost here is not a version bump. The repository has no published GitHub releases, and the README describes the specification as work in progress, with two live URLs for the WebGPU and WGSL drafts. Your integration point is therefore a commit or a date, not a tag. Anyone building documentation from this source should record which commit they built from, because the text changes continuously and there is no release artefact to pin against.

The licence situation needs care rather than a summary. The repository's licence field is NOASSERTION and a LICENSE.md is present, while the README separately requires participants to agree to the W3C Contributor License Agreement. Those are two different things: the CLA governs contributions you make, and LICENSE.md governs the text as distributed. The README does not spell out redistribution terms for the specification itself, so read LICENSE.md before republishing any of it. None of this is legal advice; it is a pointer to the file that actually answers the question.

Editorial conclusion

Adopt this repository if you are reviewing or editing the WebGPU or WGSL specifications, or if you need the normative text and the design and proposals directories as a reference; file issues against it if you find a spec bug, since the README states that anyone with a GitHub account can do so without joining the group. Do not clone it expecting a runnable WebGPU runtime, a shader compiler, or a browser polyfill, because the repository holds the specification and its tooling, not an implementation. Before you invest time in a local build, verify three things: that the spec/ and wgsl/ subdirectories each build with their own Makefile, that the Makefile's own note about not running with -j still applies to the wgsl target, and that the licence terms in LICENSE.md match how you intend to redistribute the text.

Frequently asked questions

Which is better, WebGPU or Vulkan?

The repository does not compare the two, and it is the WebGPU and WGSL specification rather than an implementation of either API. What the README does establish is that WebGPU is specified by the W3C GPU for the Web Community Group and formally standardized by the Working Group, so any comparison would be between a web-exposed API specification and a native one, which is outside what this repository documents.

What does GPU stand for?

The README does not expand the acronym. It uses GPU only in the group's name, the W3C GPU for the Web Community Group, and in the repository's title, and it does not define the term anywhere in the text.

What is replacing WebGL?

The README does not discuss WebGL or describe WebGPU as its replacement. It states only that this repository holds the WebGPU API and WebGPU Shading Language specifications for the W3C GPU for the Web Community Group, with work-in-progress drafts published at the two gpuweb.github.io URLs.

How do I enable WebGPU features in Chrome?

The repository does not cover browser flags or Chrome configuration. It contains the specification text, design notes and proposals, not a browser or an implementation, so enabling features in a browser is outside what it documents.

Official sources

  1. gpuweb/gpuweb on GitHub
  2. Issues
  3. Project website
  4. README
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/gpuweb-gpuweb.svg)](https://hysenlabs.com/projects/gpuweb-gpuweb)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/gpuweb-gpuweb.svg)](https://hysenlabs.com/projects/gpuweb-gpuweb)

Was this useful?