wgpu

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

_{Part of the GoGPU ecosystem}

Overview

wgpu is a complete WebGPU implementation written entirely in Go. It provides direct GPU access through multiple hardware abstraction layer (HAL) backends without requiring Rust, CGO, or any external dependencies.

Key Features

Installation

go get github.com/gogpu/wgpu

Requirements: Go 1.25+

Quick Start

package main

import (
    "fmt"

    "github.com/gogpu/wgpu/core"
    "github.com/gogpu/wgpu/types"
    _ "github.com/gogpu/wgpu/hal/allbackends" // Auto-register platform backends
)

func main() {
    // Create instance with platform-appropriate backends
    instance := core.NewInstance(&types.InstanceDescriptor{
        Backends: types.BackendsAll,
    })

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

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

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

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

Compute Shaders

// Create compute pipeline
pipelineID, _ := core.DeviceCreateComputePipeline(deviceID, &core.ComputePipelineDescriptor{
    Label:  "Compute Pipeline",
    Layout: layoutID,
    Compute: core.ProgrammableStage{
        Module:     shaderModuleID,
        EntryPoint: "main",
    },
})

// Begin compute pass
encoder, _ := core.DeviceCreateCommandEncoder(deviceID, nil)
computePass := encoder.BeginComputePass(nil)

// Dispatch workgroups
computePass.SetPipeline(pipelineID)
computePass.SetBindGroup(0, bindGroupID, nil)
computePass.Dispatch(64, 1, 1)
computePass.End()

// Submit commands
commands := encoder.Finish(nil)
core.QueueSubmit(queueID, []types.CommandBuffer{commands})

Architecture

wgpu/
├── types/              # WebGPU type definitions
├── core/               # Validation, state tracking, resource management
├── hal/                # Hardware Abstraction Layer
│   ├── allbackends/    # Platform-specific backend auto-registration
│   ├── noop/           # No-op backend (testing)
│   ├── software/       # CPU software rasterizer (~10K LOC)
│   ├── gles/           # OpenGL ES 3.0+ (~7.5K LOC)
│   ├── vulkan/         # Vulkan 1.3 (~27K LOC)
│   ├── metal/          # Metal (~3K LOC)
│   └── dx12/           # DirectX 12 (~12K LOC)
└── cmd/
    ├── vk-gen/         # Vulkan bindings generator
    └── vulkan-triangle/# Integration test

HAL Backend Integration

The HAL Backend Integration layer provides unified multi-backend support:

import _ "github.com/gogpu/wgpu/hal/allbackends"

// Platform-specific backends auto-registered:
// - Windows: Vulkan, DX12, GLES
// - Linux:   Vulkan, GLES
// - macOS:   Metal, Vulkan

Backend Details

Platform Support

Vulkan Backend

Full Vulkan 1.3 implementation with:

• Auto-generated bindings from official vk.xml
• Buddy allocator for GPU memory (O(log n), minimal fragmentation)
• Dynamic rendering (VK_KHR_dynamic_rendering)
• Classic render pass fallback for Intel compatibility
• wgpu-style swapchain synchronization
• Complete resource management (Buffer, Texture, Pipeline, BindGroup)

Metal Backend

Native Apple GPU access via:

• Pure Go Objective-C bridge (goffi)
• Metal API via runtime message dispatch
• CAMetalLayer integration for surface presentation
• MSL shader compilation via naga

DirectX 12 Backend

Windows GPU access via:

• Pure Go COM bindings (syscall, no CGO)
• DXGI integration for swapchain and adapters
• Flip model with VRR support
• Descriptor heap management

Software Backend

Full-featured CPU rasterizer for headless rendering:

import _ "github.com/gogpu/wgpu/hal/software"

// Use cases:
// - CI/CD testing without GPU
// - Server-side image generation
// - Reference implementation
// - Fallback when GPU unavailable

Rasterization Features:

• Edge function triangle rasterization (Pineda algorithm)
• Perspective-correct interpolation
• Depth buffer (8 compare functions)
• Stencil buffer (8 operations)
• Blending (13 factors, 5 operations)
• 6-plane frustum clipping (Sutherland-Hodgman)
• 8x8 tile-based parallel rendering

Ecosystem

wgpu is the foundation of the GoGPU ecosystem.

Documentation

• ROADMAP.md — Development milestones
• CHANGELOG.md — Release notes
• CONTRIBUTING.md — Contribution guidelines
• pkg.go.dev — API reference

References

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

Contributing

Contributions welcome! See CONTRIBUTING.md for guidelines.

Priority areas:

• Cross-platform testing
• Performance benchmarks
• Documentation improvements
• Bug reports and fixes

License

MIT License — see LICENSE for details.

wgpu — WebGPU in Pure Go