gogpu/ui

Enterprise-Grade GUI Toolkit for Go
Modern widgets, reactive state, GPU-accelerated rendering — zero CGO

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

Overview

gogpu/ui is an enterprise-grade GUI toolkit for Go, designed for building:

IDEs (GoLand, VS Code class)
Design Tools (Photoshop, Figma class)
CAD Applications
Professional Dashboards
Chrome/Electron Replacement Apps

Key Differentiators

Feature	gogpu/ui	Fyne	Gio
CGO-free	Yes	No	Yes
WebGPU rendering	Yes	OpenGL	Direct GPU
Reactive state	Signals	Binding	Events
Layout engine	Flexbox + Grid	Custom	Flex
Accessibility	Day 1 (ARIA roles)	Limited	Limited
Plugin system	Yes	No	No

Screenshot

gogpu/ui Widget Demo

examples/hello — Checkboxes, Radio Buttons, ListView (1000 items), Material Design 3

Quick Start

Important: The gogpu ecosystem is pure Go with zero CGO. You must set CGO_ENABLED=0 (the Go default) — do not enable CGO.

The fastest way to get started is to clone and run one of the included examples:

git clone https://github.com/gogpu/ui.git
cd ui/examples/hello
go run .

Here is a minimal example showing the widget toolkit:

package main

import (
    "log"

    "github.com/gogpu/gg"
    _ "github.com/gogpu/gg/gpu"
    "github.com/gogpu/gg/integration/ggcanvas"
    "github.com/gogpu/gogpu"
    "github.com/gogpu/ui/app"
    "github.com/gogpu/ui/primitives"
    "github.com/gogpu/ui/render"
    "github.com/gogpu/ui/widget"
)

func main() {
    gogpuApp := gogpu.NewApp(gogpu.DefaultConfig().
        WithTitle("My App").
        WithSize(800, 600).
        WithContinuousRender(false)) // Event-driven: 0% CPU when idle

    uiApp := app.New(
        app.WithWindowProvider(gogpuApp),
        app.WithPlatformProvider(gogpuApp),
        app.WithEventSource(gogpuApp.EventSource()),
    )

    uiApp.SetRoot(
        primitives.Box(
            primitives.Text("Hello gogpu/ui!").
                FontSize(24).Bold().
                Color(widget.RGBA8(33, 33, 33, 255)),
            primitives.Text("Enterprise-grade GUI for Go").
                FontSize(16).
                Color(widget.RGBA8(100, 100, 100, 255)),
        ).Padding(24).Gap(12).Background(widget.RGBA8(255, 255, 255, 255)),
    )

    var canvas *ggcanvas.Canvas
    gogpuApp.OnDraw(func(dc *gogpu.Context) {
        w, h := dc.Width(), dc.Height()
        if canvas == nil {
            var err error
            canvas, err = ggcanvas.New(gogpuApp.GPUContextProvider(), w, h)
            if err != nil {
                log.Fatal(err)
            }
        }
        uiApp.Frame()
        sv := dc.SurfaceView()
        sw, sh := dc.SurfaceSize()
        gg.SetAcceleratorSurfaceTarget(sv, sw, sh)
        canvas.Draw(func(cc *gg.Context) {
            cc.SetRGBA(0.94, 0.94, 0.94, 1)
            cc.DrawRectangle(0, 0, float64(w), float64(h))
            cc.Fill()
            uiApp.Window().DrawTo(render.NewCanvas(cc, w, h))
        })
        _ = canvas.RenderDirect(sv, sw, sh)
    })
    gogpuApp.OnClose(func() { gg.CloseAccelerator() })

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

Packages

Core (Phase 0)

Package	Description	Coverage
`geometry`	Point, Size, Rect, Constraints, Insets	98.8%
`event`	MouseEvent, KeyEvent, WheelEvent, FocusEvent, Modifiers	100%
`widget`	Widget, WidgetBase, Context, Canvas, Lifecycle (mount/unmount), SchedulerRef	100%
`internal/render`	Canvas, SceneCanvas (tile-parallel), Renderer using gogpu/gg	96.5%
`internal/layout`	Flex, Stack, Grid layout engines	89.9%

MVP (Phase 1)

Package	Description	Coverage
`a11y`	Accessibility: 35+ ARIA roles, Accessible interface, Tree, Announcer	99.1%
`state`	Reactive signals, Binding, Scheduler with push-based invalidation	100%
`primitives`	Box, Text, Image widgets with fluent builder API	94.4%
`app`	Window integration via gpucontext interfaces (dependency inversion)	98.6%

Extensibility (Phase 1.5)

Package	Description	Coverage
`layout`	Public layout API with custom algorithms	89.5%
`registry`	Widget factory registration for third-party widgets	100%
`theme`	Theme system with Extensions and Registry	100%
`plugin`	Plugin bundling with dependency resolution	99.4%

Interactive Widgets (Phase 2 — Complete)

Package	Description	Coverage
`cdk`	Component Development Kit — Content[C] polymorphic pattern	100%
`core/button`	Generic button with pluggable Painter, 4 variants, 3 sizes, signal bindings	96%+
`core/checkbox`	Toggleable checkbox with checked/unchecked/indeterminate states, signal bindings	96%+
`core/radio`	Mutually exclusive radio group with vertical/horizontal layout, signal bindings	96%+
`core/textfield`	Text input with cursor, selection, clipboard, validation, signal bindings	96%+
`core/slider`	Slider: continuous/discrete, horizontal/vertical, drag+keyboard, signal bindings	94.6%
`core/dialog`	Modal dialog: backdrop overlay, action buttons, focus trapping, Alert/Confirm	96.9%
`core/dropdown`	Dropdown/select with overlay menu, keyboard navigation, signal bindings	96%+
`overlay`	Overlay/popup stack, container, position helper	95%+
`primitives`	Box, Text, Image, RepaintBoundary (pixel caching + tile-parallel scene.Scene)	94.4%
`theme/material3`	Material Design 3 — theme (HCT color science) + 21 component painters	97%+
`focus`	Keyboard focus management with Tab/Shift+Tab navigation	95.2%
`internal/focus`	Internal focus manager implementation	15.2%

Phase 3 (Complete)

Package	Description	Coverage
`animation`	Animation engine: tween, spring, M3 presets, orchestration (Stagger/Chain/Repeat/Reverse)	92.3%
`transition`	Widget enter/exit animations: Fade, Slide, Scale effects, Show/Hide wrapper	98.7%
`core/scrollview`	Scrollable container: vertical/horizontal/both, wheel+keyboard+drag, PushClip/PushTransform, signal bindings	96.5%
`core/tabview`	Tabbed navigation: lazy content switching, closeable tabs, keyboard nav, Top/Bottom position, signal bindings	92.1%
`core/listview`	Virtualized list: fixed-height items, recycling, single/multi selection, keyboard nav, M3 painter	96%+
`core/gridview`	Virtualized 2D grid: fixed cell size, auto-fit columns, cell recycling, selection, keyboard nav	92.1%
`core/linechart`	Real-time line chart: multiple series, rolling window, grid, Y-axis labels, thread-safe PushValue	98.8%
`core/progressbar`	Linear progress bar: 0-100%, rounded corners, label, signal binding, PushClipRoundRect	99.3%
`core/collapsible`	Expandable section: animated expand/collapse, keyboard focus, arrow indicator, Tween animation	98.2%
`primitives`	Box (HBox/VBox direction), Text, Image, ThemeScope, RepaintBoundary	94%+

Phase 4 (In Progress)

Package	Description	Coverage
`core/progress`	Circular progress: determinate arc + indeterminate spinner, polyline approximation	97.4%
`core/popover`	Popover (click) + Tooltip (hover): 12 placements, auto-flip, overlay integration	97.1%
`core/splitview`	Resizable split panels: draggable divider, min constraints, collapse, handle dots	96.8%
`core/treeview`	Hierarchical tree: expand/collapse, virtualized rendering, connector lines, keyboard nav	96%+
`core/datatable`	Sortable column table: fixed header, virtualized rows, zebra striping, sort indicators	96%+
`core/toolbar`	Horizontal action bar: icon buttons, separators, spacers, custom widget items	96%+
`core/menu`	MenuBar + ContextMenu: submenus, separators, disabled items, shortcut display	96%+
`core/docking`	IDE-style dockable panels: border layout, tabbed groups, Dock/Undock API	95.3%
`theme/material3`	21 component painters (all widgets covered)	97%+
`theme/devtools`	JetBrains DevTools: 22 painters, Int UI gray scale, dark/light, IDE-style	96%+
`theme/fluent`	Microsoft Fluent Design: 9 painters, accent colors, inner focus ring, light/dark	96%+
`theme/cupertino`	Apple HIG: 9 painters, iOS toggle switch, segmented control, pill buttons	96%+
`theme/font`	Font Registry: CSS weight matching (W3C spec), Weight 100-900, Style, Family/Face	97.7%
`icon`	SVG icons (JetBrains expui), vector path icons, De Casteljau bezier, gg/svg renderer	97%+
`i18n`	Internationalization: Locale, Bundle, Translator, CLDR plural rules, RTL, LocaleSignal	97.9%
`dnd`	Drag and drop: DragSource/DropTarget interfaces, Manager, 5px threshold, Escape cancel	99.3%
`uitest`	Testing utilities: MockCanvas, MockContext, event factories, widget helpers, assertions	93.1%
`internal/dirty`	Dirty region tracking: Collector, Tracker, merge algorithm, partial repaints	100%

Total: ~150,000 lines of code | 55+ packages | ~6,000 tests | ~97% average coverage

Architecture

┌─────────────────────────────────────────────────────────────┐
│                    User Application                         │
├─────────────────────────────────────────────────────────────┤
│  theme/material3/  │  theme/devtools/ │  theme/fluent/      │
│  21 Painters       │  22 Painters     │  9 Painters         │
│  theme/cupertino/  │                  │                     │
│  9 Painters        │                  │                     │
├─────────────────────────────────────────────────────────────┤
│  22 Interactive Widgets (core/)                             │
│  button, checkbox, radio, textfield, dropdown, slider,      │
│  dialog, scrollview, tabview, listview, gridview, linechart,│
│  progressbar, progress, collapsible, popover, splitview,    │
│  treeview, datatable, toolbar, menu, docking                │
├──────────────┬──────────────────────────────────────────────┤
│  cdk/        │  Content[C] polymorphic pattern              │
├──────────────┴──────────────────────────────────────────────┤
│  primitives/       │  animation/     │  transition/         │
│  Box (HBox/VBox),  │  Tween, Spring  │  Fade, Slide, Scale  │
│  Text, Image,      │  M3 Presets,    │  Enter/Exit          │
│  RepaintBoundary   │  Orchestration  │                      │
├─────────────────────────────────────────────────────────────┤
│  icon/  │  i18n/  │  dnd/   │  uitest/ │  theme/font/       │
├─────────────────────────────────────────────────────────────┤
│  app/ + FocusManager │  focus/ │  overlay/ │  render/       │
├─────────────────────────────────────────────────────────────┤
│  layout/           │  state/         │  a11y/               │
│  Flex, Stack, Grid │  Signals, Bind  │  ARIA Roles, Tree    │
├─────────────────────────────────────────────────────────────┤
│  registry/         │  plugin/        │  theme/              │
├─────────────────────────────────────────────────────────────┤
│  widget/           │  event/         │  geometry/           │
│  Widget, Context   │  Mouse, Key     │  Point, Rect         │
│  Canvas, Lifecycle │  Wheel, Focus   │  Constraints         │
├─────────────────────────────────────────────────────────────┤
│  internal/render   │  internal/layout│  internal/focus      │
│  Canvas, Scene     │  Flex, Grid     │  Manager, Ring       │
│  internal/dirty    │                 │                      │
├─────────────────────────────────────────────────────────────┤
│  gogpu/gg          │  gpucontext     │  coregx/signals      │
│  2D Graphics       │  Shared Ifaces  │  State Management    │
└─────────────────────────────────────────────────────────────┘

Dependency Principle

ui → gpucontext (interfaces)       ← dependency inversion
ui → gg (2D rendering)
ui → coregx/signals (reactive)

gogpu → gpucontext (implements)    ← concrete implementation
gg → wgpu → naga                   ← internal to gg

ui never imports gogpu, wgpu, or naga directly.

Examples

Example	Description
`examples/hello`	Widget demo: checkbox, radio, ListView (1000 items), M3 theme, event-driven GPU rendering
`examples/signals`	Reactive signals: TextSignal, ContentSignal, CheckedSignal, SelectedSignal, DisabledSignal
`examples/taskmanager`	Full task manager: charts, tables, animations, real-time data
`examples/gallery`	Widget gallery: all 22 widgets, 4 design systems (M3/DevTools/Fluent/Cupertino), theme switching
`examples/ide`	GoLand-inspired IDE layout: DevTools theme, toolbar, tree, tabs, terminal, SVG icons

Run any example:

cd examples/gallery
go run .

API Examples

Primitives

// Box — universal container
primitives.Box(children...).
    Padding(16).
    PaddingXY(24, 8).
    Background(theme.Surface).
    Rounded(8).
    BorderStyle(1, theme.Outline).
    ShadowLevel(2).
    Gap(8)

// Text — static
primitives.Text("Hello World").
    FontSize(24).
    Bold().
    Color(theme.OnSurface).
    Align(primitives.TextAlignCenter).
    MaxLines(2).
    Ellipsis()

// Text — reactive (auto-updates when signal changes)
primitives.TextFn(func() string {
    return fmt.Sprintf("Count: %d", count.Get())
}).FontSize(18)

// Text — signal binding (auto-updates when signal changes)
title := state.NewSignal("Hello World")
primitives.NewText("").ContentSignal(title).FontSize(24)

// Image
primitives.Image(mySource).
    Size(48, 48).
    Cover().
    Rounded(24).
    Alt("User avatar")

Slider

// Basic slider
s := slider.New(
    slider.Min(0),
    slider.Max(100),
    slider.Value(50),
    slider.OnChange(func(v float32) { fmt.Println("Value:", v) }),
)

// Discrete slider with step snapping and marks
s := slider.New(
    slider.Min(0), slider.Max(100), slider.Step(10),
    slider.Marks([]slider.Mark{{Value: 0}, {Value: 50}, {Value: 100}}),
    slider.PainterOpt(material3.SliderPainter{Theme: m3}),
)

// Two-way signal binding
volume := state.NewSignal[float32](75)
s := slider.New(
    slider.Min(0), slider.Max(100),
    slider.ValueSignal(volume),  // reads AND writes back on drag
)

Dialog

// Simple alert dialog
d := dialog.Alert("Error", "File not found.", func() { log.Println("dismissed") })
d.Show(ctx)

// Confirmation dialog
d := dialog.Confirm("Delete?", "This cannot be undone.",
    func() { log.Println("canceled") },
    func() { deleteItem() },
)
d.Show(ctx)

// Custom dialog with M3 painter
d := dialog.New(
    dialog.Title("Settings"),
    dialog.Content(settingsWidget),
    dialog.Actions(
        dialog.Action{Label: "Cancel", Variant: dialog.VariantTextOnly},
        dialog.Action{Label: "Save", Variant: dialog.VariantFilled, Default: true,
            OnClick: func() { saveSettings() }},
    ),
    dialog.PainterOpt(material3.DialogPainter{Theme: m3}),
)
d.Show(ctx)

Animation

// Tween animation with M3 easing
ctrl := animation.NewController()
opacity := state.NewSignal[float32](0)
animation.To(opacity, 1.0).
    Duration(animation.DurationMedium2).
    Ease(animation.M3Standard).
    Start(ctrl)

// Spring physics (critically damped)
position := state.NewSignal[float32](0)
animation.SpringTo(position, 200).
    Stiffness(animation.StiffnessMedium).
    DampingRatio(animation.DampingNoBouncy).
    Start(ctrl)

// Color tween (Flutter pattern: float32 engine + Tween[T])
progress := state.NewSignal[float32](0)
animation.To(progress, 1.0).Duration(300*time.Millisecond).Start(ctrl)
colorTween := animation.NewColorTween(startColor, endColor)
// in Draw: canvas.DrawRect(bounds, colorTween.At(progress.Get()))

// Parallel composition
animation.Parallel(
    animation.To(opacity, 1.0).Duration(200*time.Millisecond),
    animation.To(translateY, 0).Duration(300*time.Millisecond),
).Start(ctrl)

ScrollView

// Basic vertical scrollview
sv := scrollview.New(longContentWidget,
    scrollview.DirectionOpt(scrollview.Vertical),
    scrollview.ScrollbarOpt(scrollview.ScrollbarAuto),
    scrollview.OnScroll(func(x, y float32) { fmt.Printf("scroll: %.0f\n", y) }),
)

// 2D scrollview with signal binding
scrollY := state.NewSignal[float32](0)
sv := scrollview.New(largeCanvas,
    scrollview.DirectionOpt(scrollview.Both),
    scrollview.ScrollYSignal(scrollY), // two-way binding
    scrollview.PainterOpt(material3.ScrollbarPainter{Theme: m3}),
)

TabView

// Basic tab view
tv := tabview.New([]tabview.Tab{
    {Label: "Profile", Content: profileWidget},
    {Label: "Settings", Content: settingsWidget},
    {Label: "About", Content: aboutWidget},
}, tabview.OnSelect(func(idx int) { fmt.Println("Tab:", idx) }))

// Closeable tabs with M3 painter and signal binding
selected := state.NewSignal[int](0)
tv := tabview.New(tabs,
    tabview.Closeable(true),
    tabview.SelectedSignalOpt(selected),
    tabview.PainterOpt(material3.TabViewPainter{Theme: m3}),
    tabview.OnClose(func(idx int) { removeDynamicTab(idx) }),
)

Reactive State

// Create a signal
name := state.NewSignal("World")

// Computed value (auto-updates)
greeting := state.NewComputed(func() string {
    return "Hello, " + name.Get() + "!"
})

// Bind signal to widget invalidation
binding := state.Bind(name, ctx)
defer binding.Unbind()

// Batch multiple changes (single re-render)
scheduler.Batch(func() {
    firstName.Set("Alice")
    lastName.Set("Smith")
    age.Set(30)
})

Widget Signal Bindings

// Bind signals directly to widget properties
label := state.NewSignal("Submit")
disabled := state.NewSignal(false)

btn := button.New(
    button.TextSignal(label),
    button.DisabledSignal(disabled),
    button.OnClick(func() {
        label.Set("Processing...")
        disabled.Set(true)
    }),
)

// Two-way binding: checkbox state synced with signal
agreed := state.NewSignal(false)
cb := checkbox.New(
    checkbox.CheckedSignal(agreed),
    checkbox.LabelOpt("I agree to terms"),
)

Accessibility

// Every widget implements a11y.Accessible
func (b *MyButton) AccessibilityRole() a11y.Role   { return a11y.RoleButton }
func (b *MyButton) AccessibilityLabel() string      { return b.text }
func (b *MyButton) AccessibilityActions() []a11y.Action {
    return []a11y.Action{a11y.ActionClick}
}

// Accessibility tree with stable node IDs
root := a11y.NewNode(a11y.RoleWindow, "My Application")
tree := a11y.NewMemoryTree(root)
button := a11y.NewNode(a11y.RoleButton, "Save")  // stable uint64 ID
tree.Insert(root, button)

Window Integration

// ui connects to windowing via interfaces (not concrete types)
uiApp := app.New(
    app.WithWindowProvider(gogpuApp),    // gpucontext.WindowProvider
    app.WithPlatformProvider(gogpuApp),  // gpucontext.PlatformProvider
    app.WithTheme(myTheme),
)

uiApp.SetRoot(rootWidget)

// Headless mode for testing (no window needed)
testApp := app.New()  // works without any providers
testApp.SetRoot(rootWidget)
testApp.Window().Frame()  // processes layout + draw

Implementation Progress

Phase 0: Foundation ✅

Geometry types (Point, Size, Rect, Constraints, Insets)
Event system (Mouse, Keyboard, Wheel, Focus, Modifiers)
Widget interface, WidgetBase, Context, Canvas
Layout engines (Flexbox, Stack, Grid)
Canvas implementation (gogpu/gg)

Phase 1: MVP ✅

Accessibility foundation (35+ ARIA roles, Accessible interface, Tree)
Reactive signals integration (coregx/signals, Binding, Scheduler)
Basic primitives (Box, Text, Image with fluent API)
Window integration (app package via gpucontext interfaces)

Phase 1.5: Extensibility ✅

Widget Registry (third-party registration)
Public Layout API (custom algorithms)
Theme System + Extensions + Registry
Plugin System (bundling, dependency resolution)

Phase 2: Beta ✅

Phase 3: Release Candidate ✅

Phase 4: Production (v1.0) — In Progress

Requirements

Dependency	Purpose	Status
Go 1.25+	Language runtime	Required
CGO_ENABLED=0	Pure Go (no C compiler needed)	Default
gogpu/gogpu	Windowing, input, GPU surface	For examples
gogpu/gg	2D graphics rendering	Integrated
gogpu/gpucontext	Shared interfaces	Integrated
coregx/signals	Reactive state management	Integrated

Note: The entire ecosystem is pure Go. Do not set CGO_ENABLED=1 — this will cause build errors from the goffi package which requires CGO to be disabled.

Installation

# UI toolkit (library)
go get github.com/gogpu/ui@latest

# For runnable applications you also need gogpu (windowing) and gg (rendering):
go get github.com/gogpu/gogpu@latest
go get github.com/gogpu/gg@latest

Related Projects

Project	Description
gogpu/gogpu	Graphics framework — GPU abstraction, windowing, input
gogpu/gg	2D graphics — Canvas API, GPU text
gogpu/wgpu	Pure Go WebGPU — Vulkan, Metal, GLES, Software
gogpu/naga	Shader compiler — WGSL to SPIR-V, MSL, GLSL

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

Contributing

Contributions are welcome! Please read CONTRIBUTING.md for guidelines.

Ways to contribute:

Test the packages, report bugs
API feedback and suggestions
Documentation improvements
Spread the word (Reddit, Hacker News, Dev.to)
Code contributions (see open issues)

License

MIT License — see LICENSE for details.

gogpu/ui — Enterprise-grade GUI for Go
_{Part of the GoGPU ecosystem}

📚 gogpu/ui - Awesome Go Library for GUI

Detailed Description of gogpu/ui