Pure Go GPU Computing Ecosystem
1.27M+ lines of code. GPU power, Go simplicity. Zero CGO.

GoGPU is to Go what Flutter is to Dart, Qt is to C++, and JavaFX is to Java — a professional, complete GPU computing ecosystem, not just a single library. From shader compilation and GPU abstraction to 2D/3D rendering, GUI toolkit with themed widgets, and platform integration — all in Pure Go with zero CGO.

Inspired by this discussion on r/golang. Go waited 17 years for a professional graphics ecosystem. We're building it — together with you.

	Library	Purpose	Version	Stars	Issues	PRs
		Foundation
🧱	gputypes	WebGPU types (webgpu.h spec compliant)
🧱	naga	WGSL → SPIR-V/MSL/GLSL/HLSL/DXIL shader compiler (~324K LOC)
		GPU Core
⚙️	wgpu	Unified Go WebGPU — Pure Go + Rust FFI + Browser (Vulkan/Metal/DX12/GLES/Software, ~254K LOC)
⚙️	gpucontext	Shared interfaces (DeviceProvider, EventSource)
⚙️	galloc	O(1) offset allocator for GPU memory sub-allocation (~2.5K LOC)
		Framework
🖥️	gogpu	Graphics framework, windowing, compositor (ADR-067, ~104K LOC)
		Graphics
🎨	gg	2D graphics, 5-engine smart rasterizer, GPU acceleration (~312K LOC)
🎨	g3d	Pure Go 3D rendering (scene graph, PBR materials, forward renderer, ~15K LOC)
🎨	gg-pdf	PDF export backend for gg recording
🎨	gg-svg	SVG export backend for gg recording
		Application
📱	ui	Enterprise GUI toolkit (27 widgets, 4 design systems, Layer Tree compositor, ~220K LOC)
📱	editor	Text/Code editor widget — GPU-accelerated, embeddable (like Monaco)
		Platform Services
🔧	systray	Pure Go system tray (Win32/macOS/Linux, zero CGO, ~8K LOC)
🔧	audio	Pure Go audio engine (WASAPI/CoreAudio/PulseAudio, zero CGO)
🔧	compose	Multi-process composition (Unix socket IPC, LZ4, ~10K LOC)
🎮	gamepad	Pure Go gamepad/joystick input — XInput, evdev, IOKit, W3C

Pure Go | Zero CGO | Cross-platform

┌─────────────────────────────────────────────────────────────┐
│ Your Application │
├─────────────────────────────────────────────────────────────┤
│ gogpu/ui (GUI) │ born-ml/born │ Your Framework │
├─────────────────────────────────────────────────────────────┤
│ gogpu/gg (2D Graphics) │ gogpu/g3d (3D Rendering) │
│ Smart Rasterizer: Scanline│4×4 Tiles│16×16│SDF│Compute │
│ ↓ export to ↓ │
│ gg-pdf (PDF) gg-svg (SVG) │
├─────────────────────────────────────────────────────────────┤
│ gogpu/gogpu (Graphics Framework) │
│ Windowing, compositor (ADR-067), damage overlay, input │
│ gogpu/systray gogpu/audio gogpu/gamepad (🚧) │
├─────────────────────────────────────────────────────────────┤
│ gogpu/gpucontext (Shared Interfaces) │
│ DeviceProvider, SurfaceCompositor, DamageSource, EventSource│
├─────────────────────────────────────────────────────────────┤
│ gogpu/gputypes (WebGPU Types, webgpu.h compliant) │
│ TextureFormat, BufferUsage, PresentMode, etc. │
├─────────────────────────────────────────────────────────────┤
│ gogpu/wgpu (Unified WebGPU: Pure Go │ Rust FFI │ WASM)│
├─────────────────────────────────────────────────────────────┤
│ gogpu/naga (Shader Compiler) │
│ (WGSL → SPIR-V/MSL/GLSL/HLSL/DXIL) │
├─────────────────────────────────────────────────────────────┤
│ Vulkan │ Metal │ DX12 │ OpenGL │ Software │
└─────────────────────────────────────────────────────────────┘

package main
import (
"github.com/gogpu/gogpu""github.com/gogpu/gogpu/gmath"
)
funcmain() {
app:=gogpu.NewApp(gogpu.DefaultConfig().
WithTitle("Hello GoGPU").
WithSize(800, 600))
app.OnDraw(func(dc*gogpu.Context) {
dc.DrawTriangleColor(gmath.DarkGray)
})
app.Run()
}

Result: A window with a rendered triangle in ~20 lines of code.

Use 2D graphics from gg directly in gogpu windows — with smart rasterizer auto-selection and GPU-direct rendering (zero CPU readback):

package main
import (
"log""github.com/gogpu/gg"
_ "github.com/gogpu/gg/gpu"// Register GPU accelerator"github.com/gogpu/gg/integration/ggcanvas""github.com/gogpu/gogpu"
)
funcmain() {
app:=gogpu.NewApp(gogpu.DefaultConfig().
WithTitle("gg + gogpu").
WithSize(800, 600))
varcanvas*ggcanvas.Canvasapp.OnDraw(func(dc*gogpu.Context) {
w, h:=dc.Width(), dc.Height()
ifcanvas==nil {
varerrerrorcanvas, err=ggcanvas.New(app.GPUContextProvider(), w, h)
iferr!=nil {
log.Fatal(err)
}
}
canvas.Draw(func(cc*gg.Context) {
cc.SetRGB(1, 0, 0)
cc.DrawCircle(400, 300, 100)
cc.Fill()
})
canvas.Render(dc.RenderTarget()) // GPU-direct, zero-copy
})
app.Run()
}

Project	Organization	Purpose	Version	Stars	Issues	PRs
webgpu	go-webgpu	Zero-CGO WebGPU bindings (wgpu-native FFI)
goffi	go-webgpu	Pure Go FFI library (88-114ns overhead)
born	born-ml	Pure Go ML framework (97%+ MNIST)

We haven't had time to write comprehensive tutorials yet — we've been focused on building the ecosystem itself. But the community has started filling that gap:

🇨🇿 Pavel Tišnovský (root.cz — Czech Republic's leading tech portal) wrote two in-depth tutorials covering the gg 2D graphics library with 54 working examples:

1. Creating 2D/3D Graphics and Animations in Go with GoGPU — 49 min read. Paths, Bézier curves, transforms, text, animations.
2. GoGPU Part 2: Gradients, SVG & PDF Export — 39 min read. Gradients, vector export, GUI integration.
3. Interactive Applications with GUI using GoGPU — ~40 min read. Windowing, ggcanvas, keyboard/mouse input, interactive Bezier editor.

Articles are in Czech — use Google Translate for other languages. The code examples are universal.

• Google Says Go Is Ideal for AI-Assisted Engineering. We've Been Proving It for a Year. — Dev.to
• Extracting a GPU Compositor in Pure Go — Patterns from Flutter and Chromium — Dev.to
• GoGPU: From Idea to 100K Lines — Dev.to
• GoGPU Announcement — Dev.to
• First Pure Go DXIL Generator — Dev.to

See individual project ROADMAP.md files for detailed roadmaps.

GoGPU is free and open source. If you find it useful, please consider supporting continued development:

🥇 First Sponsor:Inkflow (@omer316) — the person who asked "is there a way to support this project?" and then became the answer!

We welcome contributions! See individual repository CONTRIBUTING.md files.

Areas where we need help:

• GUI widgets and themes for gogpu/ui
• Cross-platform testing (macOS, Linux)
• WebGPU examples and tutorials
• Documentation

All projects are licensed under the MIT License.

_{Building the GPU computing ecosystem Go deserves}
gogpu.io · info@gogpu.io · GitHub