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

Screenshot

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)

MVP (Phase 1)

Extensibility (Phase 1.5)

Interactive Widgets (Phase 2 — Complete)

Phase 3 (Complete)

Phase 4 (In Progress)

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

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 ✅

• Button widget (4 variants, 3 sizes, keyboard activation)
• Checkbox widget (checked/unchecked/indeterminate, pluggable Painter)
• Radio group widget (vertical/horizontal, arrow key navigation)
• TextField widget (cursor, selection, clipboard, validation)
• Dropdown/Select widget (overlay menu, keyboard nav, scroll)
• Overlay infrastructure (stack, container, position)
• Material Design 3 theme (HCT color science, 21 painters)
• Keyboard navigation (focus management, Tab/Shift+Tab, shortcuts)
• ThemeScope (theme override for widget subtrees)
• Event-driven rendering (0% CPU when idle)
• Reactive signal bindings for all widgets (TextSignal, CheckedSignal, SelectedSignal, DisabledSignal, ContentSignal)

Phase 3: Release Candidate ✅

• Retained-mode rendering: dirty tracking, DrawTree, DrawStats (SP1)
• RepaintBoundary: per-widget pixel caching (SP2)
• scene.Scene integration: tile-parallel rendering via SceneCanvas (SP3)
• Slider widget (continuous/discrete, horizontal/vertical, M3 painter)
• Dialog/Modal widget (backdrop, actions, focus trapping, M3 painter)
• Animation engine (Tween, Spring, CubicBezier, M3 motion tokens)
• Animation presets (M3 motion tokens) + orchestration (Stagger, Chain, Repeat)
• Transitions: enter/exit animations (Fade, Slide, Scale)
• ScrollView widget (vertical/horizontal/both, wheel+keyboard+drag)
• TabView widget (lazy content, closeable tabs, keyboard nav)
• ListView widget (virtualized list, recycling, single/multi selection, M3 painter)
• GridView widget (virtualized 2D grid, auto-fit columns, cell recycling)
• LineChart widget (real-time, multiple series, rolling window)
• ProgressBar widget (linear, rounded corners, signal binding)
• Collapsible section widget (animated expand/collapse)
• Box HBox/VBox direction support
• Dirty region tracking (internal/dirty)
• Performance benchmarks (36 across 5 packages)

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

• Circular progress indicator (determinate arc + indeterminate spinner)
• SplitView (resizable split panels, draggable divider)
• Popover/Tooltip (12 placements, auto-flip, overlay)
• TreeView (hierarchical, expand/collapse, virtualized)
• DataTable (sortable columns, fixed header, virtualized rows)
• Toolbar (icon buttons, separators, spacers)
• Menu system (MenuBar + ContextMenu, submenus, shortcuts)
• IDE-style docking system (border layout, tabbed groups)
• Drag & drop foundation (DragSource, DropTarget, Manager)
• Fluent Design theme (9 painters, accent colors)
• Cupertino theme (9 painters, iOS-style)
• i18n (CLDR plural rules, RTL detection, LocaleSignal)
• Icon system (vector paths, 10 Material icons, De Casteljau)
• Font registry (CSS weight matching, W3C spec)
• Testing utilities (MockCanvas, MockContext, assertions)
• Dirty region tracking (merge algorithm, partial repaints)
• Performance benchmarks (36 across 5 packages)
• Hover tracking (W3C PointerEventSource, HoverTracker, cursor management)
• ScreenBounds coordinate system (overlay positioning, hit-testing)
• Event coordinate transforms (ScrollView content-space dispatch)
• Inter font full Unicode (Cyrillic, Greek, Vietnamese)
• MeasureText on Canvas (layout calculations without drawing)
• FocusManager integration in Window (Tab/Shift+Tab navigation)
• OnTextInput handler (platform character input API)
• Task Manager example (charts, tables, animations)
• Widget Gallery example (all widgets, 4 design systems, theme switching)
• Platform accessibility adapters (UIA, AT-SPI2, NSAccessibility)
• Performance optimization pass

Requirements

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

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}