GoGPU: A Pure Go Graphics Library for GPU Programming

Finally, a graphics framework that feels like Go.

TL;DR

• 
  Problem: Go lacks a professional graphics library


• 
  Solution: GoGPU — Pure Go, Zero-CGO, WebGPU-based


• 
  Result: 15 lines of code instead of 500


• 
  Status: Working triangle demo, Windows support


• 
  Repo: github.com/gogpu/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".

Hundreds of upvotes. Dozens of comments. All saying the same thing:

"Why can't we have nice things in Go?"

So I decided to build it.

Introducing GoGPU

GoGPU is a Pure Go GPU Computing Ecosystem designed to make graphics programming accessible to every Go developer.

Show Me the Code

Here's a complete program that opens a window and draws a colored triangle:

package main



import (

    "log"

    "github.com/gogpu/gogpu"

    "github.com/gogpu/gogpu/math"

)



func main() {

    app := gogpu.NewApp(gogpu.DefaultConfig().

        WithTitle("GoGPU Triangle").

        WithSize(800, 600))



    app.OnDraw(func(ctx *gogpu.Context) {

        ctx.DrawTriangleColor(math.DarkGray)

    })



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

        log.Fatal(err)

    }

}

That's 15 lines.

The equivalent raw WebGPU code? 400-500 lines of boilerplate.

GoGPU handles:

• Window creation and event loop


• GPU device initialization


• Surface configuration


• Shader compilation


• Render pipeline setup


• Frame presentation

You focus on what to draw. GoGPU handles how.

How It Works

┌─────────────────────────────────────────┐

│           Your Application              │

│         (15 lines of code)              │

├─────────────────────────────────────────┤

│             gogpu/gogpu                 │

│         Graphics Framework              │

├─────────────────────────────────────────┤

│             gogpu/naga                  │

│    Shader Compiler (WGSL → SPIR-V)      │

├─────────────────────────────────────────┤

│          go-webgpu/webgpu               │

│       Pure Go WebGPU Bindings           │

├─────────────────────────────────────────┤

│          go-webgpu/goffi                │

│        Pure Go FFI (Zero-CGO)           │

├─────────────────────────────────────────┤

│            wgpu-native                  │

│       Vulkan / Metal / DX12             │

└─────────────────────────────────────────┘

The key innovation is goffi — a Pure Go FFI library that lets us call native code without CGO. No C compiler. No build complexity. Just go build.

My Background

This project builds on years of work in the Go ecosystem:

GPU & Graphics:

• 
  Born ML — Machine learning framework with GPU compute


• 
  go-webgpu/webgpu — The WebGPU bindings powering GoGPU

Systems & Libraries:

• 
  Phoenix TUI — Terminal UI framework


• 
  scigolib/hdf5 — Scientific computing bindings


• 
  scigolib/matlab — MATLAB-like operations


• 
  coregx/signals — Reactive signals


• 
  coregx/relica — State replication


• 
  coregx/fursy — Functional reactive streams


• 
  coregx/coregex — Regex utilities


• 
  kolkov/racedetector — Race condition tools

The foundation is battle-tested. GoGPU is the next step.

Roadmap

The Ecosystem

Why WebGPU?

WebGPU is the future:

1. 
   Cross-platform by design — Same API on Windows, macOS, Linux, and browsers


2. 
   Modern architecture — Built on lessons from Vulkan, Metal, and DX12


3. 
   Safe by default — Validation prevents common GPU programming errors


4. 
   Browser-ready — Your code can run in WASM (future goal)

Current Status

Let's be honest:

Version: v0.1.0-alpha (Early Development)

Platform: Windows (macOS/Linux stubs ready)

API: Will change. Things will break.

But:

• ✅ The architecture is solid


• ✅ The triangle renders


• ✅ The foundation is proven (go-webgpu powers Born ML)

How You Can Help

⭐ Star the Repo

github.com/gogpu/gogpu

🧪 Try It Out

git clone https://github.com/gogpu/gogpu

cd gogpu

go run ./examples/triangle

🐛 Report Issues

Open an issue

💻 Contribute Code

PRs welcome! Especially needed:

• macOS platform support


• Linux platform support


• Documentation


• More examples

Links

• 
  Repository: github.com/gogpu/gogpu
  


• 
  Organization: github.com/gogpu
  


• 
  Foundation: github.com/go-webgpu
  

Go deserves a great graphics library. Let's build it together.

Questions? Drop them in the comments.