wgpu

README

wgpu

Pure Go WebGPU Implementation
No Rust, No CGO, Just Go.

_{Part of the GoGPU ecosystem}

Status: v0.1.0-alpha — Types, Core, HAL, OpenGL ES and Vulkan backends complete!

---

Vision

A complete WebGPU implementation in pure Go:

• No wgpu-native dependency — Standalone Go library
• Direct GPU access — Vulkan, Metal, DX12 backends
• WebGPU compliant — Following the W3C specification
• WASM compatible — Run in browsers via WebAssembly

Installation

go get github.com/gogpu/wgpu

Usage (Preview)

import (
    "github.com/gogpu/wgpu/core"
    "github.com/gogpu/wgpu/types"
)

// Create instance for GPU discovery
instance := core.NewInstance(&types.InstanceDescriptor{
    Backends: types.BackendsVulkan | types.BackendsMetal,
})

// Request high-performance GPU
adapterID, _ := instance.RequestAdapter(&types.RequestAdapterOptions{
    PowerPreference: types.PowerPreferenceHighPerformance,
})

// Get adapter info
info, _ := core.GetAdapterInfo(adapterID)
fmt.Printf("GPU: %s\n", info.Name)

// Create device
deviceID, _ := core.RequestDevice(adapterID, &types.DeviceDescriptor{
    Label: "My Device",
})

// Get queue for command submission
queueID, _ := core.GetDeviceQueue(deviceID)

Architecture

wgpu/
├── types/         # WebGPU type definitions ✓
├── core/          # Validation, state tracking ✓
├── hal/           # Hardware abstraction layer ✓
│   ├── noop/      # No-op backend (testing) ✓
│   ├── gles/      # OpenGL ES backend ✓ (Pure Go, ~3500 LOC)
│   ├── vulkan/    # Vulkan backend ✓ (Pure Go, ~27K LOC)
│   │   ├── vk/        # Generated Vulkan bindings (~20K LOC)
│   │   └── memory/    # GPU memory allocator (~1.8K LOC)
│   ├── metal/     # Metal backend (planned)
│   └── dx12/      # DirectX 12 backend (planned)
└── cmd/
    ├── vk-gen/           # Vulkan bindings generator from vk.xml
    └── vulkan-triangle/  # Vulkan integration test (red triangle) ✓

Roadmap

Phase 1: Types Package ✓

• Backend types (Vulkan, Metal, DX12, GL)
• Adapter and device types
• Feature flags
• GPU limits with presets
• Texture formats (100+)
• Buffer, sampler, shader types
• Bind group and render state types
• Vertex formats with size calculations

Phase 2: Core Validation ✓

• Type-safe ID system with generics
• Epoch-based use-after-free prevention
• Instance, Adapter, Device, Queue management
• Hub with 17 resource registries
• Comprehensive error handling
• 127 tests with 95% coverage

Phase 3: HAL Interface ✓

• Backend abstraction layer (Backend, Instance, Adapter, Device, Queue)
• Resource interfaces (Buffer, Texture, Surface, Sampler, etc.)
• Command encoding (CommandEncoder, RenderPassEncoder, ComputePassEncoder)
• Backend registration system
• Noop backend for testing
• 54 tests with 94% coverage

Phase 4: Pure Go Backends (In Progress)

• OpenGL ES backend (hal/gles/) — Pure Go via goffi, Windows (WGL)
• Vulkan backend (hal/vulkan/) — Pure Go via goffi, cross-platform (Windows/Linux/macOS), ~27K LOC
• Metal backend (hal/metal/) — Required for macOS/iOS
• DX12 backend (hal/dx12/) — Windows high-performance

Pure Go Approach

All backends implemented without CGO:

Backend	Status	Approach	Platforms
OpenGL ES	Done	goffi + WGL	Windows
Vulkan	Done	goffi + vk-gen from vk.xml	Windows, Linux, macOS
Metal	Planned	goffi (Obj-C bridge)	macOS, iOS
DX12	Planned	goffi + COM	Windows

Vulkan Backend Features

• Auto-generated bindings from official Vulkan XML specification
• Memory allocator with buddy allocation (O(log n), minimal fragmentation)
• Vulkan 1.3 dynamic rendering — No render pass objects needed
• Swapchain management with automatic recreation
• Semaphore synchronization for frame presentation
• Complete HAL implementation:
  • Buffer, Texture, TextureView, Sampler
  • ShaderModule, BindGroupLayout, BindGroup
  • PipelineLayout, RenderPipeline, ComputePipeline
  • CommandEncoder, RenderPassEncoder, ComputePassEncoder
  • Fence synchronization, WriteTexture immediate upload
• Comprehensive unit tests (93 tests, 2200+ LOC):
  • Conversion functions (formats, usage, blend modes)
  • Descriptor allocator logic
  • Resource structures
  • Memory allocator (buddy allocation)

References

• wgpu (Rust) — Reference implementation
• WebGPU Specification
• Dawn (C++) — Google's implementation

Related Projects

Project	Description
gogpu/gogpu	Graphics framework
gogpu/naga	Pure Go shader compiler
go-webgpu/webgpu	FFI bindings (current solution)

Contributing

We welcome contributions! See CONTRIBUTING.md for guidelines.

License

MIT License — see LICENSE for details.

---

wgpu — WebGPU in Pure Go