wgpu

package module
v0.19.4 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 2, 2026 License: MIT Imports: 7 Imported by: 0

README

wgpu

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

CI codecov Go Reference Go Report Card License Latest Release Go Version Zero CGO

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

Category Capabilities
Backends Vulkan, Metal, DirectX 12, OpenGL ES, Software
Platforms Windows, Linux, macOS, iOS
API WebGPU-compliant (W3C specification)
Shaders WGSL via gogpu/naga compiler
Compute Full compute shader support, GPU→CPU readback
Debug Leak detection, error scopes, validation layers, structured logging (log/slog)
Build Zero CGO, simple go build

Installation

go get github.com/gogpu/wgpu

Requirements: Go 1.25+

Build:

CGO_ENABLED=0 go build

Note: wgpu uses Pure Go FFI via cgo_import_dynamic, which requires CGO_ENABLED=0. This enables zero C compiler dependency and easy cross-compilation.

Quick Start

package main

import (
    "fmt"

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

func main() {
    // Create instance
    instance, _ := wgpu.CreateInstance(nil)
    defer instance.Release()

    // Request high-performance GPU
    adapter, _ := instance.RequestAdapter(&wgpu.RequestAdapterOptions{
        PowerPreference: wgpu.PowerPreferenceHighPerformance,
    })
    defer adapter.Release()

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

    // Create device
    device, _ := adapter.RequestDevice(nil)
    defer device.Release()

    // Create a GPU buffer
    buffer, _ := device.CreateBuffer(&wgpu.BufferDescriptor{
        Label: "My Buffer",
        Size:  1024,
        Usage: wgpu.BufferUsageStorage | wgpu.BufferUsageCopyDst,
    })
    defer buffer.Release()

    // Write data to buffer
    if err := device.Queue().WriteBuffer(buffer, 0, []byte{1, 2, 3, 4}); err != nil {
        panic(err)
    }
}

Compute Shaders

// Create shader module from WGSL
shader, _ := device.CreateShaderModule(&wgpu.ShaderModuleDescriptor{
    Label: "Compute Shader",
    WGSL:  wgslSource,
})
defer shader.Release()

// Create compute pipeline
pipeline, _ := device.CreateComputePipeline(&wgpu.ComputePipelineDescriptor{
    Label:      "Compute Pipeline",
    Layout:     pipelineLayout,
    Module:     shader,
    EntryPoint: "main",
})
defer pipeline.Release()

// Record and submit commands
encoder, _ := device.CreateCommandEncoder(nil)
pass, _ := encoder.BeginComputePass(nil)
pass.SetPipeline(pipeline)
pass.SetBindGroup(0, bindGroup, nil)
pass.Dispatch(64, 1, 1)
pass.End()

cmdBuffer, _ := encoder.Finish()
device.Queue().Submit(cmdBuffer)

Guides: Getting Started | Backend Differences

Features: WGSL compute shaders, storage/uniform buffers, indirect dispatch, GPU timestamp queries (Vulkan), GPU-to-CPU readback.

Architecture

wgpu/
├── *.go                # Public API (import "github.com/gogpu/wgpu")
├── 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 (~11K LOC)
│   ├── gles/           # OpenGL ES 3.0+ (~10K LOC)
│   ├── vulkan/         # Vulkan 1.3 (~38K LOC)
│   ├── metal/          # Metal (~5K LOC)
│   └── dx12/           # DirectX 12 (~14K LOC)
├── examples/
│   ├── compute-copy/   # GPU buffer copy with compute shader
│   └── compute-sum/    # Parallel reduction on GPU
└── cmd/
    ├── vk-gen/         # Vulkan bindings generator
    └── ...             # Backend integration tests

Public API

The root package (import "github.com/gogpu/wgpu") provides a safe, ergonomic API aligned with the W3C WebGPU specification. It wraps core/ and hal/ into user-friendly types:

User Application
  ↓ import "github.com/gogpu/wgpu"
Root Package (public API)
  ↓ wraps
core/ (validation) + hal/ (backend interfaces)
  ↓
vulkan/ | metal/ | dx12/ | gles/ | software/

HAL Backend Integration

Backends auto-register via blank imports:

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

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

Backend Details

Platform Support

Backend Windows Linux macOS iOS Notes
Vulkan Yes Yes Yes - MoltenVK on macOS
Metal - - Yes Yes Native Apple GPU
DX12 Yes - - - Windows 10+
GLES Yes Yes - - OpenGL ES 3.0+
Software Yes Yes Yes Yes CPU fallback

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
  • MSAA render pass with automatic resolve
  • Complete resource management (Buffer, Texture, Pipeline, BindGroup)
  • Surface creation: Win32, X11, Wayland, Metal (MoltenVK)
  • Debug messenger for validation layer error capture (VK_EXT_debug_utils)
  • Structured diagnostic logging via log/slog

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
  • WGSL shader compilation (WGSL → HLSL via naga → DXBC via d3dcompiler_47.dll)
  • Staging buffer GPU data transfer (WriteBuffer, WriteTexture)

OpenGL ES Backend

Cross-platform GPU access via OpenGL ES 3.0+:

  • Pure Go EGL/GL bindings (goffi)
  • Full rendering pipeline: VAO, FBO, MSAA, blend, stencil, depth
  • WGSL shader compilation (WGSL → GLSL via naga)
  • CopyTextureToBuffer readback for GPU → CPU data transfer
  • Platform detection: X11, Wayland, Surfaceless (headless CI)
  • Works with Mesa llvmpipe for software-only environments

Software Backend

Full-featured CPU rasterizer for headless rendering. Always compiled — no build tags or GPU hardware required.

// Software backend auto-registers via init().
// No explicit import needed when using hal/allbackends.
// For standalone usage:
import _ "github.com/gogpu/wgpu/hal/software"

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

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.

Project Description
gogpu/gogpu GPU framework with windowing and input
gogpu/wgpu Pure Go WebGPU (this repo)
gogpu/naga Shader compiler (WGSL to SPIR-V, HLSL, MSL, GLSL)
gogpu/gg 2D graphics library
go-webgpu/webgpu wgpu-native FFI bindings
go-webgpu/goffi Pure Go FFI library

Documentation

References

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

Documentation

Overview

Package wgpu provides a safe, ergonomic WebGPU API for Go applications.

This package wraps the lower-level hal/ and core/ packages into a user-friendly API aligned with the W3C WebGPU specification.

Quick Start

Import this package and a backend registration package: 

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

instance, err := wgpu.CreateInstance(nil)
// ...

Resource Lifecycle

All GPU resources must be explicitly released with Release(). Resources are reference-counted internally. Using a released resource panics.

Backend Registration

Backends are registered via blank imports: 

_ "github.com/gogpu/wgpu/hal/allbackends"  // all available backends
_ "github.com/gogpu/wgpu/hal/vulkan"        // Vulkan only
_ "github.com/gogpu/wgpu/hal/noop"           // testing

Thread Safety

Instance, Adapter, and Device are safe for concurrent use. Encoders (CommandEncoder, RenderPassEncoder, ComputePassEncoder) are NOT thread-safe.

Index

Constants

View Source 
const (
	ErrorFilterValidation  = core.ErrorFilterValidation
	ErrorFilterOutOfMemory = core.ErrorFilterOutOfMemory
	ErrorFilterInternal    = core.ErrorFilterInternal
)
View Source 
const (
	BackendVulkan = gputypes.BackendVulkan
	BackendMetal  = gputypes.BackendMetal
	BackendDX12   = gputypes.BackendDX12
	BackendGL     = gputypes.BackendGL
)

Backend constants

View Source 
const (
	BackendsAll     = gputypes.BackendsAll
	BackendsPrimary = gputypes.BackendsPrimary
	BackendsVulkan  = gputypes.BackendsVulkan
	BackendsMetal   = gputypes.BackendsMetal
	BackendsDX12    = gputypes.BackendsDX12
	BackendsGL      = gputypes.BackendsGL
)

Backends masks

View Source 
const (
	BufferUsageMapRead      = gputypes.BufferUsageMapRead
	BufferUsageMapWrite     = gputypes.BufferUsageMapWrite
	BufferUsageCopySrc      = gputypes.BufferUsageCopySrc
	BufferUsageCopyDst      = gputypes.BufferUsageCopyDst
	BufferUsageIndex        = gputypes.BufferUsageIndex
	BufferUsageVertex       = gputypes.BufferUsageVertex
	BufferUsageUniform      = gputypes.BufferUsageUniform
	BufferUsageStorage      = gputypes.BufferUsageStorage
	BufferUsageIndirect     = gputypes.BufferUsageIndirect
	BufferUsageQueryResolve = gputypes.BufferUsageQueryResolve
)
View Source 
const (
	TextureUsageCopySrc          = gputypes.TextureUsageCopySrc
	TextureUsageCopyDst          = gputypes.TextureUsageCopyDst
	TextureUsageTextureBinding   = gputypes.TextureUsageTextureBinding
	TextureUsageStorageBinding   = gputypes.TextureUsageStorageBinding
	TextureUsageRenderAttachment = gputypes.TextureUsageRenderAttachment
)
View Source 
const (
	TextureFormatRGBA8Unorm     = gputypes.TextureFormatRGBA8Unorm
	TextureFormatRGBA8UnormSrgb = gputypes.TextureFormatRGBA8UnormSrgb
	TextureFormatBGRA8Unorm     = gputypes.TextureFormatBGRA8Unorm
	TextureFormatBGRA8UnormSrgb = gputypes.TextureFormatBGRA8UnormSrgb
	TextureFormatDepth24Plus    = gputypes.TextureFormatDepth24Plus
	TextureFormatDepth32Float   = gputypes.TextureFormatDepth32Float
)

Commonly used texture format constants

View Source 
const (
	ShaderStageVertex   = gputypes.ShaderStageVertex
	ShaderStageFragment = gputypes.ShaderStageFragment
	ShaderStageCompute  = gputypes.ShaderStageCompute
)
View Source 
const (
	PresentModeImmediate   = gputypes.PresentModeImmediate
	PresentModeMailbox     = gputypes.PresentModeMailbox
	PresentModeFifo        = gputypes.PresentModeFifo
	PresentModeFifoRelaxed = gputypes.PresentModeFifoRelaxed
)
View Source 
const (
	PowerPreferenceNone            = gputypes.PowerPreferenceNone
	PowerPreferenceLowPower        = gputypes.PowerPreferenceLowPower
	PowerPreferenceHighPerformance = gputypes.PowerPreferenceHighPerformance
)

Variables

View Source 
var (
	ErrDeviceLost      = hal.ErrDeviceLost
	ErrOutOfMemory     = hal.ErrDeviceOutOfMemory
	ErrSurfaceLost     = hal.ErrSurfaceLost
	ErrSurfaceOutdated = hal.ErrSurfaceOutdated
	ErrTimeout         = hal.ErrTimeout
)

Sentinel errors re-exported from HAL.

View Source 
var (
	// ErrReleased is returned when operating on a released resource.
	ErrReleased = errors.New("wgpu: resource already released")

	// ErrNoAdapters is returned when no GPU adapters are found.
	ErrNoAdapters = errors.New("wgpu: no GPU adapters available")

	// ErrNoBackends is returned when no backends are registered.
	ErrNoBackends = errors.New("wgpu: no backends registered (import a backend package)")
)

Public API sentinel errors.

View Source 
var (
	DefaultLimits             = gputypes.DefaultLimits
	DefaultInstanceDescriptor = gputypes.DefaultInstanceDescriptor
)

Default functions (re-exported for convenience)

Functions

This section is empty.

Types

type Adapter 

type Adapter struct {
	// contains filtered or unexported fields
}

Adapter represents a physical GPU.

func (*Adapter) Features 

func (a *Adapter) Features() Features

Features returns supported features.

func (*Adapter) Info 

func (a *Adapter) Info() AdapterInfo

Info returns adapter metadata.

func (*Adapter) Limits 

func (a *Adapter) Limits() Limits

Limits returns the adapter's resource limits.

func (*Adapter) Release 

func (a *Adapter) Release()

Release releases the adapter.

func (*Adapter) RequestDevice 

func (a *Adapter) RequestDevice(desc *DeviceDescriptor) (*Device, error)

RequestDevice creates a logical device from this adapter. If desc is nil, default features and limits are used.

type AdapterInfo 

type AdapterInfo = gputypes.AdapterInfo

Adapter types

type AddressMode 

type AddressMode = gputypes.AddressMode

Sampler types

type Backend 

type Backend = gputypes.Backend

Backend types

type Backends 

type Backends = gputypes.Backends

type BindGroup 

type BindGroup struct {
	// contains filtered or unexported fields
}

BindGroup represents bound GPU resources for shader access.

func (*BindGroup) Release 

func (g *BindGroup) Release()

Release destroys the bind group.

type BindGroupDescriptor 

type BindGroupDescriptor struct {
	Label   string
	Layout  *BindGroupLayout
	Entries []BindGroupEntry
}

BindGroupDescriptor describes a bind group.

type BindGroupEntry 

type BindGroupEntry struct {
	Binding     uint32
	Buffer      *Buffer      // For buffer bindings
	Offset      uint64       // Buffer offset
	Size        uint64       // Buffer binding size (0 = rest of buffer)
	Sampler     *Sampler     // For sampler bindings
	TextureView *TextureView // For texture bindings
}

BindGroupEntry describes a single resource binding in a bind group. Exactly one of Buffer, Sampler, or TextureView must be set.

type BindGroupLayout 

type BindGroupLayout struct {
	// contains filtered or unexported fields
}

BindGroupLayout defines the structure of resource bindings for shaders.

func (*BindGroupLayout) Release 

func (l *BindGroupLayout) Release()

Release destroys the bind group layout.

type BindGroupLayoutDescriptor 

type BindGroupLayoutDescriptor struct {
	Label   string
	Entries []BindGroupLayoutEntry
}

BindGroupLayoutDescriptor describes a bind group layout.

type BindGroupLayoutEntry 

type BindGroupLayoutEntry = gputypes.BindGroupLayoutEntry

Bind group types

type Buffer 

type Buffer struct {
	// contains filtered or unexported fields
}

Buffer represents a GPU buffer.

func (*Buffer) Label 

func (b *Buffer) Label() string

Label returns the buffer's debug label.

func (*Buffer) Release 

func (b *Buffer) Release()

Release destroys the buffer.

func (*Buffer) Size 

func (b *Buffer) Size() uint64

Size returns the buffer size in bytes.

func (*Buffer) Usage 

func (b *Buffer) Usage() BufferUsage

Usage returns the buffer's usage flags.

type BufferDescriptor 

type BufferDescriptor struct {
	Label            string
	Size             uint64
	Usage            BufferUsage
	MappedAtCreation bool
}

BufferDescriptor describes buffer creation parameters.

type BufferUsage 

type BufferUsage = gputypes.BufferUsage

Buffer usage

type Color 

type Color = gputypes.Color

type ColorTargetState 

type ColorTargetState = gputypes.ColorTargetState

type CommandBuffer 

type CommandBuffer struct {
	// contains filtered or unexported fields
}

CommandBuffer holds recorded GPU commands ready for submission. Created by CommandEncoder.Finish().

type CommandEncoder 

type CommandEncoder struct {
	// contains filtered or unexported fields
}

CommandEncoder records GPU commands for later submission.

A command encoder is single-use. After calling Finish(), the encoder cannot be used again. Call Device.CreateCommandEncoder() to create a new one.

NOT thread-safe - do not use from multiple goroutines.

func (*CommandEncoder) BeginComputePass 

func (e *CommandEncoder) BeginComputePass(desc *ComputePassDescriptor) (*ComputePassEncoder, error)

BeginComputePass begins a compute pass. The returned ComputePassEncoder records dispatch commands. Call ComputePassEncoder.End() when done.

func (*CommandEncoder) BeginRenderPass 

func (e *CommandEncoder) BeginRenderPass(desc *RenderPassDescriptor) (*RenderPassEncoder, error)

BeginRenderPass begins a render pass. The returned RenderPassEncoder records draw commands. Call RenderPassEncoder.End() when done.

func (*CommandEncoder) CopyBufferToBuffer 

func (e *CommandEncoder) CopyBufferToBuffer(src *Buffer, srcOffset uint64, dst *Buffer, dstOffset uint64, size uint64)

CopyBufferToBuffer copies data between buffers.

func (*CommandEncoder) Finish 

func (e *CommandEncoder) Finish() (*CommandBuffer, error)

Finish completes command recording and returns a CommandBuffer. After calling Finish(), the encoder cannot be used again.

type CommandEncoderDescriptor 

type CommandEncoderDescriptor struct {
	Label string
}

CommandEncoderDescriptor describes command encoder creation.

type CompareFunction 

type CompareFunction = gputypes.CompareFunction

type CompositeAlphaMode 

type CompositeAlphaMode = gputypes.CompositeAlphaMode

type ComputePassDescriptor 

type ComputePassDescriptor struct {
	Label string
}

ComputePassDescriptor describes a compute pass.

type ComputePassEncoder 

type ComputePassEncoder struct {
	// contains filtered or unexported fields
}

ComputePassEncoder records compute dispatch commands.

Created by CommandEncoder.BeginComputePass(). Must be ended with End() before the CommandEncoder can be finished.

NOT thread-safe.

func (*ComputePassEncoder) Dispatch 

func (p *ComputePassEncoder) Dispatch(x, y, z uint32)

Dispatch dispatches compute work.

func (*ComputePassEncoder) DispatchIndirect 

func (p *ComputePassEncoder) DispatchIndirect(buffer *Buffer, offset uint64)

DispatchIndirect dispatches compute work with GPU-generated parameters.

func (*ComputePassEncoder) End 

func (p *ComputePassEncoder) End() error

End ends the compute pass.

func (*ComputePassEncoder) SetBindGroup 

func (p *ComputePassEncoder) SetBindGroup(index uint32, group *BindGroup, offsets []uint32)

SetBindGroup sets a bind group for the given index.

func (*ComputePassEncoder) SetPipeline 

func (p *ComputePassEncoder) SetPipeline(pipeline *ComputePipeline)

SetPipeline sets the active compute pipeline.

type ComputePipeline 

type ComputePipeline struct {
	// contains filtered or unexported fields
}

ComputePipeline represents a configured compute pipeline.

func (*ComputePipeline) Release 

func (p *ComputePipeline) Release()

Release destroys the compute pipeline.

type ComputePipelineDescriptor 

type ComputePipelineDescriptor struct {
	Label      string
	Layout     *PipelineLayout
	Module     *ShaderModule
	EntryPoint string
}

ComputePipelineDescriptor describes a compute pipeline.

type CullMode 

type CullMode = gputypes.CullMode

type DepthStencilState 

type DepthStencilState = hal.DepthStencilState

DepthStencilState describes depth/stencil testing configuration.

type Device 

type Device struct {
	// contains filtered or unexported fields
}

Device represents a logical GPU device. It is the main interface for creating GPU resources.

Device methods are safe for concurrent use, except Release() which must not be called concurrently with other methods.

func (*Device) CreateBindGroup 

func (d *Device) CreateBindGroup(desc *BindGroupDescriptor) (*BindGroup, error)

CreateBindGroup creates a bind group.

func (*Device) CreateBindGroupLayout 

func (d *Device) CreateBindGroupLayout(desc *BindGroupLayoutDescriptor) (*BindGroupLayout, error)

CreateBindGroupLayout creates a bind group layout.

func (*Device) CreateBuffer 

func (d *Device) CreateBuffer(desc *BufferDescriptor) (*Buffer, error)

CreateBuffer creates a GPU buffer.

func (*Device) CreateCommandEncoder 

func (d *Device) CreateCommandEncoder(desc *CommandEncoderDescriptor) (*CommandEncoder, error)

CreateCommandEncoder creates a command encoder for recording GPU commands.

func (*Device) CreateComputePipeline 

func (d *Device) CreateComputePipeline(desc *ComputePipelineDescriptor) (*ComputePipeline, error)

CreateComputePipeline creates a compute pipeline.

func (*Device) CreatePipelineLayout 

func (d *Device) CreatePipelineLayout(desc *PipelineLayoutDescriptor) (*PipelineLayout, error)

CreatePipelineLayout creates a pipeline layout.

func (*Device) CreateRenderPipeline 

func (d *Device) CreateRenderPipeline(desc *RenderPipelineDescriptor) (*RenderPipeline, error)

CreateRenderPipeline creates a render pipeline.

func (*Device) CreateSampler 

func (d *Device) CreateSampler(desc *SamplerDescriptor) (*Sampler, error)

CreateSampler creates a texture sampler.

func (*Device) CreateShaderModule 

func (d *Device) CreateShaderModule(desc *ShaderModuleDescriptor) (*ShaderModule, error)

CreateShaderModule creates a shader module.

func (*Device) CreateTexture 

func (d *Device) CreateTexture(desc *TextureDescriptor) (*Texture, error)

CreateTexture creates a GPU texture.

func (*Device) CreateTextureView 

func (d *Device) CreateTextureView(texture *Texture, desc *TextureViewDescriptor) (*TextureView, error)

CreateTextureView creates a view into a texture.

func (*Device) Features 

func (d *Device) Features() Features

Features returns the device's enabled features.

func (*Device) Limits 

func (d *Device) Limits() Limits

Limits returns the device's resource limits.

func (*Device) PopErrorScope 

func (d *Device) PopErrorScope() *GPUError

PopErrorScope pops the most recently pushed error scope. Returns the captured error, or nil if no error occurred.

func (*Device) PushErrorScope 

func (d *Device) PushErrorScope(filter ErrorFilter)

PushErrorScope pushes a new error scope onto the device's error scope stack.

func (*Device) Queue 

func (d *Device) Queue() *Queue

Queue returns the device's command queue.

func (*Device) Release 

func (d *Device) Release()

Release releases the device and all associated resources.

func (*Device) WaitIdle 

func (d *Device) WaitIdle() error

WaitIdle waits for all GPU work to complete.

type DeviceDescriptor 

type DeviceDescriptor struct {
	Label            string
	RequiredFeatures Features
	RequiredLimits   Limits
}

DeviceDescriptor configures device creation.

type DeviceType 

type DeviceType = gputypes.DeviceType

type ErrorFilter 

type ErrorFilter = core.ErrorFilter

type Extent3D 

type Extent3D = hal.Extent3D

Extent3D is a 3D size.

type Features 

type Features = gputypes.Features

Feature and limit types

type FilterMode 

type FilterMode = gputypes.FilterMode

type FragmentState 

type FragmentState struct {
	Module     *ShaderModule
	EntryPoint string
	Targets    []ColorTargetState
}

FragmentState describes the fragment shader stage.

type FrontFace 

type FrontFace = gputypes.FrontFace

type GPUError 

type GPUError = core.GPUError

Re-export error types from core.

type IndexFormat 

type IndexFormat = gputypes.IndexFormat

type Instance 

type Instance struct {
	// contains filtered or unexported fields
}

Instance is the entry point for GPU operations.

Instance methods are safe for concurrent use, except Release() which must not be called concurrently with other methods.

func CreateInstance 

func CreateInstance(desc *InstanceDescriptor) (*Instance, error)

CreateInstance creates a new GPU instance. If desc is nil, all available backends are used.

func (*Instance) CreateSurface 

func (i *Instance) CreateSurface(displayHandle, windowHandle uintptr) (*Surface, error)

CreateSurface creates a rendering surface from platform-specific handles. displayHandle and windowHandle are platform-specific:

  • Windows: displayHandle=0, windowHandle=HWND
  • macOS: displayHandle=0, windowHandle=NSView*
  • Linux/X11: displayHandle=Display*, windowHandle=Window
  • Linux/Wayland: displayHandle=wl_display*, windowHandle=wl_surface*

func (*Instance) Release 

func (i *Instance) Release()

Release releases the instance and all associated resources.

func (*Instance) RequestAdapter 

func (i *Instance) RequestAdapter(opts *RequestAdapterOptions) (*Adapter, error)

RequestAdapter requests a GPU adapter matching the options. If opts is nil, the best available adapter is returned.

type InstanceDescriptor 

type InstanceDescriptor struct {
	Backends Backends
}

InstanceDescriptor configures instance creation.

type Limits 

type Limits = gputypes.Limits

type LoadOp 

type LoadOp = gputypes.LoadOp

Render types

type MultisampleState 

type MultisampleState = gputypes.MultisampleState

type Origin3D 

type Origin3D = hal.Origin3D

Origin3D is a 3D origin point.

type PipelineLayout 

type PipelineLayout struct {
	// contains filtered or unexported fields
}

PipelineLayout defines the resource layout for a pipeline.

func (*PipelineLayout) Release 

func (l *PipelineLayout) Release()

Release destroys the pipeline layout.

type PipelineLayoutDescriptor 

type PipelineLayoutDescriptor struct {
	Label            string
	BindGroupLayouts []*BindGroupLayout
}

PipelineLayoutDescriptor describes a pipeline layout.

type PowerPreference 

type PowerPreference = gputypes.PowerPreference

type PresentMode 

type PresentMode = gputypes.PresentMode

Surface/presentation types

type PrimitiveState 

type PrimitiveState = gputypes.PrimitiveState

type PrimitiveTopology 

type PrimitiveTopology = gputypes.PrimitiveTopology

Primitive types

type Queue 

type Queue struct {
	// contains filtered or unexported fields
}

Queue handles command submission and data transfers.

func (*Queue) ReadBuffer 

func (q *Queue) ReadBuffer(buffer *Buffer, offset uint64, data []byte) error

ReadBuffer reads data from a GPU buffer.

func (*Queue) Submit 

func (q *Queue) Submit(commandBuffers ...*CommandBuffer) error

Submit submits command buffers for execution. This is a synchronous operation - it blocks until the GPU has completed all submitted work.

func (*Queue) WriteBuffer 

func (q *Queue) WriteBuffer(buffer *Buffer, offset uint64, data []byte) error

WriteBuffer writes data to a buffer.

type RenderPassColorAttachment 

type RenderPassColorAttachment struct {
	View          *TextureView
	ResolveTarget *TextureView
	LoadOp        LoadOp
	StoreOp       StoreOp
	ClearValue    Color
}

RenderPassColorAttachment describes a color attachment.

type RenderPassDepthStencilAttachment 

type RenderPassDepthStencilAttachment struct {
	View              *TextureView
	DepthLoadOp       LoadOp
	DepthStoreOp      StoreOp
	DepthClearValue   float32
	DepthReadOnly     bool
	StencilLoadOp     LoadOp
	StencilStoreOp    StoreOp
	StencilClearValue uint32
	StencilReadOnly   bool
}

RenderPassDepthStencilAttachment describes a depth/stencil attachment.

type RenderPassDescriptor 

type RenderPassDescriptor struct {
	Label                  string
	ColorAttachments       []RenderPassColorAttachment
	DepthStencilAttachment *RenderPassDepthStencilAttachment
}

RenderPassDescriptor describes a render pass.

type RenderPassEncoder 

type RenderPassEncoder struct {
	// contains filtered or unexported fields
}

RenderPassEncoder records draw commands within a render pass.

Created by CommandEncoder.BeginRenderPass(). Must be ended with End() before the CommandEncoder can be finished.

NOT thread-safe.

func (*RenderPassEncoder) Draw 

func (p *RenderPassEncoder) Draw(vertexCount, instanceCount, firstVertex, firstInstance uint32)

Draw draws primitives.

func (*RenderPassEncoder) DrawIndexed 

func (p *RenderPassEncoder) DrawIndexed(indexCount, instanceCount, firstIndex uint32, baseVertex int32, firstInstance uint32)

DrawIndexed draws indexed primitives.

func (*RenderPassEncoder) DrawIndexedIndirect 

func (p *RenderPassEncoder) DrawIndexedIndirect(buffer *Buffer, offset uint64)

DrawIndexedIndirect draws indexed primitives with GPU-generated parameters.

func (*RenderPassEncoder) DrawIndirect 

func (p *RenderPassEncoder) DrawIndirect(buffer *Buffer, offset uint64)

DrawIndirect draws primitives with GPU-generated parameters.

func (*RenderPassEncoder) End 

func (p *RenderPassEncoder) End() error

End ends the render pass. After this call, the encoder cannot be used again.

func (*RenderPassEncoder) SetBindGroup 

func (p *RenderPassEncoder) SetBindGroup(index uint32, group *BindGroup, offsets []uint32)

SetBindGroup sets a bind group for the given index.

func (*RenderPassEncoder) SetBlendConstant 

func (p *RenderPassEncoder) SetBlendConstant(color *Color)

SetBlendConstant sets the blend constant color.

func (*RenderPassEncoder) SetIndexBuffer 

func (p *RenderPassEncoder) SetIndexBuffer(buffer *Buffer, format IndexFormat, offset uint64)

SetIndexBuffer sets the index buffer.

func (*RenderPassEncoder) SetPipeline 

func (p *RenderPassEncoder) SetPipeline(pipeline *RenderPipeline)

SetPipeline sets the active render pipeline.

func (*RenderPassEncoder) SetScissorRect 

func (p *RenderPassEncoder) SetScissorRect(x, y, width, height uint32)

SetScissorRect sets the scissor rectangle for clipping.

func (*RenderPassEncoder) SetStencilReference 

func (p *RenderPassEncoder) SetStencilReference(reference uint32)

SetStencilReference sets the stencil reference value.

func (*RenderPassEncoder) SetVertexBuffer 

func (p *RenderPassEncoder) SetVertexBuffer(slot uint32, buffer *Buffer, offset uint64)

SetVertexBuffer sets a vertex buffer for the given slot.

func (*RenderPassEncoder) SetViewport 

func (p *RenderPassEncoder) SetViewport(x, y, width, height, minDepth, maxDepth float32)

SetViewport sets the viewport transformation.

type RenderPipeline 

type RenderPipeline struct {
	// contains filtered or unexported fields
}

RenderPipeline represents a configured render pipeline.

func (*RenderPipeline) Release 

func (p *RenderPipeline) Release()

Release destroys the render pipeline.

type RenderPipelineDescriptor 

type RenderPipelineDescriptor struct {
	Label        string
	Layout       *PipelineLayout
	Vertex       VertexState
	Primitive    PrimitiveState
	DepthStencil *DepthStencilState
	Multisample  MultisampleState
	Fragment     *FragmentState
}

RenderPipelineDescriptor describes a render pipeline.

type RequestAdapterOptions 

type RequestAdapterOptions = gputypes.RequestAdapterOptions

type Sampler 

type Sampler struct {
	// contains filtered or unexported fields
}

Sampler represents a texture sampler.

func (*Sampler) Release 

func (s *Sampler) Release()

Release destroys the sampler.

type SamplerDescriptor 

type SamplerDescriptor struct {
	Label        string
	AddressModeU AddressMode
	AddressModeV AddressMode
	AddressModeW AddressMode
	MagFilter    FilterMode
	MinFilter    FilterMode
	MipmapFilter FilterMode
	LodMinClamp  float32
	LodMaxClamp  float32
	Compare      CompareFunction
	Anisotropy   uint16
}

SamplerDescriptor describes sampler creation parameters.

type ShaderModule 

type ShaderModule struct {
	// contains filtered or unexported fields
}

ShaderModule represents a compiled shader module.

func (*ShaderModule) Release 

func (m *ShaderModule) Release()

Release destroys the shader module.

type ShaderModuleDescriptor 

type ShaderModuleDescriptor struct {
	Label string
	WGSL  string   // WGSL source code
	SPIRV []uint32 // SPIR-V bytecode (alternative to WGSL)
}

ShaderModuleDescriptor describes shader module creation parameters.

type ShaderStages 

type ShaderStages = gputypes.ShaderStages

Shader types

type StoreOp 

type StoreOp = gputypes.StoreOp

type Surface 

type Surface struct {
	// contains filtered or unexported fields
}

Surface represents a platform rendering surface (e.g., a window).

func (*Surface) Configure 

func (s *Surface) Configure(device *Device, config *SurfaceConfiguration) error

Configure configures the surface for presentation. Must be called before GetCurrentTexture().

func (*Surface) GetCurrentTexture 

func (s *Surface) GetCurrentTexture() (*SurfaceTexture, bool, error)

GetCurrentTexture acquires the next texture for rendering. Returns the surface texture and whether the surface is suboptimal.

func (*Surface) Present 

func (s *Surface) Present(texture *SurfaceTexture) error

Present presents a surface texture to the screen.

func (*Surface) Release 

func (s *Surface) Release()

Release releases the surface.

func (*Surface) Unconfigure 

func (s *Surface) Unconfigure()

Unconfigure removes the surface configuration.

type SurfaceConfiguration 

type SurfaceConfiguration struct {
	Width       uint32
	Height      uint32
	Format      TextureFormat
	Usage       TextureUsage
	PresentMode PresentMode
	AlphaMode   CompositeAlphaMode
}

SurfaceConfiguration describes surface settings.

type SurfaceTexture 

type SurfaceTexture struct {
	// contains filtered or unexported fields
}

SurfaceTexture is a texture acquired from a surface for rendering.

func (*SurfaceTexture) CreateView 

func (st *SurfaceTexture) CreateView(desc *TextureViewDescriptor) (*TextureView, error)

CreateView creates a texture view of this surface texture.

type Texture 

type Texture struct {
	// contains filtered or unexported fields
}

Texture represents a GPU texture.

func (*Texture) Format 

func (t *Texture) Format() TextureFormat

Format returns the texture format.

func (*Texture) Release 

func (t *Texture) Release()

Release destroys the texture.

type TextureAspect 

type TextureAspect = gputypes.TextureAspect

type TextureDescriptor 

type TextureDescriptor struct {
	Label         string
	Size          Extent3D
	MipLevelCount uint32
	SampleCount   uint32
	Dimension     TextureDimension
	Format        TextureFormat
	Usage         TextureUsage
	ViewFormats   []TextureFormat
}

TextureDescriptor describes texture creation parameters.

type TextureDimension 

type TextureDimension = gputypes.TextureDimension

type TextureFormat 

type TextureFormat = gputypes.TextureFormat

type TextureUsage 

type TextureUsage = gputypes.TextureUsage

Texture types

type TextureView 

type TextureView struct {
	// contains filtered or unexported fields
}

TextureView represents a view into a texture.

func (*TextureView) Release 

func (v *TextureView) Release()

Release destroys the texture view.

type TextureViewDescriptor 

type TextureViewDescriptor struct {
	Label           string
	Format          TextureFormat
	Dimension       TextureViewDimension
	Aspect          TextureAspect
	BaseMipLevel    uint32
	MipLevelCount   uint32
	BaseArrayLayer  uint32
	ArrayLayerCount uint32
}

TextureViewDescriptor describes texture view creation parameters.

type TextureViewDimension 

type TextureViewDimension = gputypes.TextureViewDimension

type VertexBufferLayout 

type VertexBufferLayout = gputypes.VertexBufferLayout

type VertexState 

type VertexState struct {
	Module     *ShaderModule
	EntryPoint string
	Buffers    []VertexBufferLayout
}

VertexState describes the vertex shader stage.

Source Files

View all Source files

Directories

Path Synopsis
cmd
dx12-test command
Command dx12-test is an integration test for the DX12 backend.
 Command dx12-test is an integration test for the DX12 backend.
gles-test command
Command gles-test is an integration test for the Pure Go GLES backend.
 Command gles-test is an integration test for the Pure Go GLES backend.
vk-gen command
Command vk-gen generates Pure Go Vulkan bindings from vk.xml specification.
 Command vk-gen generates Pure Go Vulkan bindings from vk.xml specification.
vk-test command
Command vk-test is an integration test for the Pure Go Vulkan backend.
 Command vk-test is an integration test for the Pure Go Vulkan backend.
vulkan-renderpass-test command
Command vulkan-renderpass-test validates the hypothesis that Intel Iris Xe driver bug is specific to VK_KHR_dynamic_rendering, not vkCreateGraphicsPipelines.
 Command vulkan-renderpass-test validates the hypothesis that Intel Iris Xe driver bug is specific to VK_KHR_dynamic_rendering, not vkCreateGraphicsPipelines.
vulkan-triangle command
Command vulkan-triangle is a full integration test for the Pure Go Vulkan backend.
 Command vulkan-triangle is a full integration test for the Pure Go Vulkan backend.
Package core provides validation and state management for WebGPU resources.
 Package core provides validation and state management for WebGPU resources.
track
Package track provides resource state tracking infrastructure.
 Package track provides resource state tracking infrastructure.
examples
compute-copy command
Command compute-copy demonstrates GPU buffer copying via a compute shader.
 Command compute-copy demonstrates GPU buffer copying via a compute shader.
compute-sum command
Command compute-sum demonstrates a parallel reduction (sum) using a GPU compute shader.
 Command compute-sum demonstrates a parallel reduction (sum) using a GPU compute shader.
hal
Package hal provides the Hardware Abstraction Layer for WebGPU implementations.
 Package hal provides the Hardware Abstraction Layer for WebGPU implementations.
allbackends
Package allbackends imports all HAL backend implementations.
 Package allbackends imports all HAL backend implementations.
dx12
Package dx12 provides a DirectX 12 backend for the HAL.
 Package dx12 provides a DirectX 12 backend for the HAL.
dx12/d3d12
Package d3d12 provides low-level Direct3D 12 COM bindings for Windows.
 Package d3d12 provides low-level Direct3D 12 COM bindings for Windows.
dx12/d3dcompile
Package d3dcompile provides Pure Go bindings to d3dcompiler_47.dll.
 Package d3dcompile provides Pure Go bindings to d3dcompiler_47.dll.
dx12/dxgi
Package dxgi provides low-level DXGI (DirectX Graphics Infrastructure) COM bindings for Windows.
 Package dxgi provides low-level DXGI (DirectX Graphics Infrastructure) COM bindings for Windows.
gles
Package gles implements the HAL backend for OpenGL ES 3.0 / OpenGL 3.3+.
 Package gles implements the HAL backend for OpenGL ES 3.0 / OpenGL 3.3+.
gles/egl
Package egl provides EGL (EGL) context management for OpenGL ES on Linux.
 Package egl provides EGL (EGL) context management for OpenGL ES on Linux.
gles/gl
Package gl provides OpenGL constants and types for the GLES backend.
 Package gl provides OpenGL constants and types for the GLES backend.
gles/wgl
Package wgl provides Windows OpenGL (WGL) context management.
 Package wgl provides Windows OpenGL (WGL) context management.
metal
Package metal provides a Metal backend for the HAL.
 Package metal provides a Metal backend for the HAL.
noop
Package noop provides a no-operation GPU backend.
 Package noop provides a no-operation GPU backend.
software
Package software provides a CPU-based software rendering backend.
 Package software provides a CPU-based software rendering backend.
software/raster
Package raster provides CPU-based triangle rasterization for the software backend.
 Package raster provides CPU-based triangle rasterization for the software backend.
software/shader
Package shader provides callback-based shader execution for the software backend.
 Package shader provides callback-based shader execution for the software backend.
vulkan
Package vulkan provides Pure Go Vulkan backend for the HAL.
 Package vulkan provides Pure Go Vulkan backend for the HAL.
vulkan/memory
Package memory provides GPU memory allocation for Vulkan backend.
 Package memory provides GPU memory allocation for Vulkan backend.
vulkan/vk
Package vk provides Pure Go Vulkan bindings using goffi for FFI calls.
 Package vk provides Pure Go Vulkan bindings using goffi for FFI calls.
internal
thread
Package thread provides thread abstraction for GPU operations.
 Package thread provides thread abstraction for GPU operations.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.