GoGPU: A Pure Go Graphics Library for GPU Programming

Last updated: 2026-02-12

Join the Discussion: Help shape the future of Go graphics! Share your ideas, report issues, and discuss features at our GitHub Discussions.

Finally, a graphics framework that feels like Go.

TL;DR

• Problem: Go lacks a professional graphics ecosystem
• Solution: GoGPU — Pure Go, Zero-CGO, WebGPU-based
• Result: 380K+ lines of Pure Go code, no Rust, no C
• GPU: SDF accelerator, compute shaders, 5 WebGPU backends
• 2D: Vello-inspired rasterizer, 29 blend modes, PDF/SVG export
• UI: 54K LOC GUI toolkit with signals, layout, Material 3 theme
• Repo: github.com/gogpu

The Problem: Go and Graphics Don't Mix (Until Now)

If you've ever tried graphics programming in Go, you know the pain:

• CGO hell — Most libraries require a C compiler
• Abandoned projects — Promising repos with no updates since 2019+
• "Just use Rust/C++" — The default answer in every forum

I saw this frustration firsthand in a Reddit thread: "Go deserves more support in GUI development".

So I built it.

The Ecosystem (February 2026)

What started as a simple triangle demo has grown into a complete graphics stack:

Total: 380K+ lines of Pure Go — no CGO, no Rust, no C.

Show Me the Code

High-Level: 2D Graphics (gogpu/gg)

package main

import (
    "github.com/gogpu/gg"
    "github.com/gogpu/gg/text"
)

func main() {
    // dc = "drawing context" — the convention from fogleman/gg
    dc := gg.NewContext(512, 512)
    dc.ClearWithColor(gg.White)

    // Draw a filled circle
    dc.SetHexColor("#3498db")
    dc.DrawCircle(256, 256, 100)
    dc.Fill()

    // Stroke a rounded rectangle
    dc.SetHexColor("#e74c3c")
    dc.SetLineWidth(3)
    dc.DrawRoundedRectangle(156, 156, 200, 200, 20)
    dc.Stroke()

    // Load font and draw text
    source, _ := text.NewFontSourceFromFile("arial.ttf")
    defer source.Close()

    dc.SetFont(source.Face(32))
    dc.SetRGB(0, 0, 0)
    dc.DrawString("Hello, GoGPU!", 180, 270)

    dc.SavePNG("output.png")
}

GPU Acceleration (opt-in)

import _ "github.com/gogpu/gg/gpu" // opt-in GPU acceleration

dc := gg.NewContext(800, 600)
dc.DrawCircle(400, 300, 100)
dc.Fill() // GPU renders via SDF if shape detected, CPU fallback otherwise

The SDF accelerator auto-detects circles, ellipses, rectangles, and rounded rectangles from path data. Everything else falls back to the CPU rasterizer — transparently, with ~17ns overhead when no GPU is registered.

Low-Level: Triangle (gogpu/gogpu)

package main

import (
    "log"
    "github.com/gogpu/gogpu"
    "github.com/gogpu/gogpu/gmath"
)

func main() {
    app := gogpu.NewApp(gogpu.DefaultConfig().
        WithTitle("GoGPU Triangle").
        WithSize(800, 600))

    app.OnDraw(func(dc *gogpu.Context) {
        dc.DrawTriangleColor(gmath.DarkGray)
    })

    if err := app.Run(); err != nil {
        log.Fatal(err)
    }
}

15 lines vs 400-500 lines of raw WebGPU boilerplate.

Architecture

┌─────────────────────────────────────────────┐
│             Your Application                │
├─────────────────────────────────────────────┤
│         gogpu/ui (GUI Toolkit)              │
│   Signals, Flexbox/Grid, Material 3 Theme   │  ← 54K LOC
├─────────────────────────────────────────────┤
│        gogpu/gg (2D Graphics)               │
│   CPU Rasterizer + GPU SDF Accelerator      │  ← 155K LOC
│   29 Blend Modes, PDF/SVG Export            │
├─────────────────────────────────────────────┤
│        gogpu/gogpu (Framework)              │
│   Windowing, Input, Lifecycle, Textures     │
│   Win32 │ X11 │ Wayland │ Cocoa             │
├─────────────────────────────────────────────┤
│        gogpu/wgpu (Pure Go WebGPU)          │
│   Vulkan │ DX12 │ Metal │ GLES │ Software   │  ← 97K LOC
├─────────────────────────────────────────────┤
│        gogpu/naga (Shader Compiler)         │
│   WGSL → SPIR-V │ MSL │ GLSL │ HLSL         │  ← 39K LOC
└─────────────────────────────────────────────┘

Key innovation: Everything is Pure Go. No CGO, no wgpu-native dependency.

CPU Core + GPU Accelerator

Based on analysis of 8 enterprise 2D engines (Skia, Cairo, Vello, Blend2D, tiny-skia, piet, Qt RHI, Pathfinder):

CPU rasterization is the core. GPU is an optional accelerator.

gg.Fill() / gg.Stroke()
    │
    ├── GPUAccelerator (if registered via import _ "gg/gpu")
    │      ├── SDF: circles, rects, rrects (hardware-accelerated)
    │      └── Stencil-Then-Cover: general paths (coming soon)
    │
    └── SoftwareRenderer → internal/raster/ (always available)
            ├── Vello-inspired tile rasterizer
            ├── Analytic anti-aliasing
            └── Parallel tile processing

Platform Support

Pure Go WebGPU Backends

Shader Compiler (naga)

WGSL source compiles to all major GPU targets:

60+ WGSL built-in functions, atomics, barriers, compute shaders.

GUI Toolkit: gogpu/ui (54K LOC)

No longer just a plan — gogpu/ui is 54K lines of working code with 1,400+ tests.

What's next for UI: Text Input, Scroll Container, Data Table, Accessibility (AccessKit).

2D Graphics Highlights (gogpu/gg)

What's Next?

GPU Path Rendering

Three-tier architecture for rendering all path types on GPU:

Roadmap

The GoGPU Series

All articles documenting the GoGPU journey:

1. GoGPU: A Pure Go Graphics Library for GPU Programming — You are here
2. GoGPU: From Idea to 100K Lines in Two Weeks — The rapid development story
3. Building a Shader Compiler in Pure Go: naga — WGSL to SPIR-V/MSL/GLSL/HLSL
4. Pure Go 2D Graphics Library with GPU Acceleration: Introducing gogpu/gg — 2D graphics API
5. GPU Compute Shaders in Pure Go: gogpu/gg v0.15.3 — Sparse Strips GPU compute
6. Go 1.26 Meets 2026 with a Professional Graphics Ecosystem — February 2026 update

Join Us — While You Can Shape the Future

This is the perfect time to get involved.

The API is still evolving. Before v1.0.0 freezes the interface, your feedback directly shapes the project:

• Your ideas matter — Share in Discussions
• Cross-platform testers needed — Help us validate on real hardware
• UI development — Signals, widgets, layouts — contributions welcome
• Your name in history — Be part of building Go's GPU ecosystem

How You Can Help

Test on Your Platform

git clone https://github.com/gogpu/gogpu
cd gogpu
go build ./examples/triangle/
./triangle

Report issues at github.com/gogpu/gogpu/issues

Star the Repos

• gogpu/gogpu — Framework
• gogpu/gg — 2D Graphics
• gogpu/wgpu — Pure Go WebGPU
• gogpu/naga — Shader Compiler
• gogpu/ui — GUI Toolkit

Contribute

PRs welcome! Especially needed:

• Cross-platform testing (especially macOS, Linux Wayland, NVIDIA GPUs)
• UI widget development (signals, widgets, layouts)
• Documentation and tutorials
• Real-world usage examples
• Compute shader examples

Links

• Organization: github.com/gogpu
• Discussion: Join the conversation
• Latest Releases:
  • gogpu v0.17.0
  • gg v0.27.1
  • wgpu v0.15.0
  • naga v0.12.0
  • ui

Go deserves a great graphics ecosystem. We're building it.

Questions? Drop them in the comments or join the discussion.