webgpu-headers - GitLite

KO | EN

gitlite — search

#hacktoberfest #react #ai #typescript #llm #rust #docker #nodejs #java #windows #kubernetes #pytorch #ios #openai

webgpu-headers

(★ 581)

webgpu.h - C version of the JS API, for both native and Wasm. A multi-vendor standard between Dawn/Emdawnwebgpu and wgpu-native. Designed primarily for binding into higher-level languages.

File Explorer

Download Latest Version (.zip)

- - compile.yml
  - gen-check.yml
  - gen-docs.yml
- - Asynchronous Operations.md
  - BufferMapping.md
  - Errors.md
  - Extensions.md
  - FloatingPointNumbers.md
  - index.md
  - Multithreading.md
  - Ownership.md
  - SentinelValues.md
  - Strings.md
  - StructChaining.md
  - Surfaces.md
- .gitignore
- main.go
- cheader.tmpl
- gen.go
- main.go
- README.md
- utils.go
- validator.go
- yml.go
- - .gitignore
  - init_tests_autogen.inl
  - main.c
  - main.cpp
  - main.inl
  - Makefile
- - extension.json
  - extension.yml
  - webgpu_extension.h
.gitattributes
.gitignore
Doxyfile
go.mod
go.sum
LICENSE
Makefile
README.md
schema.json
webgpu.h
webgpu.json
webgpu.yml

# Installation Guide

1. Get the code

git clone https://github.com/webgpu-native/webgpu-headers

Downloads the entire project code from GitHub to your computer.

cd webgpu-headers

Moves into the project folder you just downloaded.

2. Go

Medium Recommended

Prerequisites

Git Needed to download the project code from GitHub.
Go The Go compiler and toolchain.

go build ./...

Compiles the Go program into an executable.

go run .

Runs the Go program directly without a separate build step.

✅ If the build finishes without errors, it worked. If you used go run ., check the terminal output.

3. Make

Medium

Prerequisites

Git Needed to download the project code from GitHub.
Make Usually pre-installed on Linux/macOS. On Windows, install separately (e.g. via MSYS2 or WSL).

make

Compiles the code based on the generated build configuration to produce an executable.

✅ If it finishes without errors, it worked. Try running the generated executable directly.

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# WebGPU Headers

This repository contains the stable C header `webgpu.h`, a C API equivalent of
the [WebGPU](https://gpuweb.github.io/gpuweb/) API for JavaScript.

All of the C API is defined in the [`webgpu.h`](./webgpu.h) header file.
This header, its documentation, and the attached documentation articles
describe the native specifities of the C API;
for everything else, refer to the WebGPU specification.
Together, these form a rough "specification" for `webgpu.h`.

Multiple implementations strive to implement this "specification" compatibly,
in addition to their own extensions which are not specified here.
For access to those extensions, use your implementation's extended headers.

### [Read the documentation here!](https://webgpu-native.github.io/webgpu-headers/)

## Why?

While WebGPU is a JavaScript API made for the Web, it is a good tradeoff of ergonomic, efficient and portable graphics API.
Almost all of its concepts are not specific to the Web platform and the headers replicate them exactly, while adding capabilities to interact with native concepts (like windowing).

Implementations of this header include:

- [Dawn](https://dawn.googlesource.com/dawn), the C++ WebGPU implementation used in Chromium
 - [Emdawnwebgpu](https://dawn.googlesource.com/dawn/+/refs/heads/main/src/emdawnwebgpu/pkg/README.md) for Emscripten translates `webgpu.h` calls to JavaScript WebGPU calls when compiling to WebAssembly.
 - [wgpu-native](https://github.com/gfx-rs/wgpu-native), C bindings to [wgpu](https://github.com/gfx-rs/wgpu), the Rust WebGPU implementation used in Firefox.
    - **wgpu-native does not yet implement the stable version of this header. Contributions needed!**

## `webgpu.yml` and `webgpu.json`

`webgpu.yml` and `webgpu.json` (same contents, different formats) are the main machine-readable source of truth for the C API and its documentation. This data is used to generate the official `webgpu.h` header present in this repository to generate the official documentation, and may be used by any other third party to design tools and wrappers around WebGPU-Native, especially bindings into other languages.

**If you are developing bindings of `webgpu.h` into another language and find that any additional high-level/semantic information would be useful in `webgpu.yml`, please contribute it!**

## Contributing to this project

**Important:** When submitting a change, one must modify `webgpu.yml`, `webgpu.json`, and `webgpu.h` files in a consistent way. One should first edit `webgpu.yml` (the source of truth), then run `make gen` to update `webgpu.json` and `webgpu.h`, and finally commit all changes together.

Here are some details about the structure of this repository.

### Main files

- `webgpu.h` is the one and only header file that defines the WebGPU C API. Only this needs to be integrated in a C project that links against a WebGPU implementation. (But be sure to use the headers from your implementation if you need any extensions, or if the implementation doesn't match this header exactly.)

- `webgpu.yml` and `webgpu.json` - see above.

- `schema.json` is the [JSON schema](https://json-schema.org/) that formally specifies the structure of `webgpu.yml`.

### Generator

- `Makefile` defines the rules to automatically generate `webgpu.h` from `webgpu.yml` and check the result.

- `gen/` and the `go.*` files are the source code of the generator called by the `Makefile`.

- `tests/compile` is used to check that the generated C header is indeed valid C/C++ code.

### Workflows

- `.github/workflows` defines the automated processes that run upon new commits/PR, to check that changes in `webgpu.yml` and `webgpu.h` are consistent.