Repository files navigation
Enterprise-Grade GUI Toolkit for Go
Join the Discussion: Help shape the future of Go GUI! Share your ideas, report issues, and discuss features at our GitHub Discussions .
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
Feature
gogpu/ui
Fyne
Gio
CGO-free Yes
No
Yes
WebGPU rendering Yes (Vulkan/DX12/Metal/GLES/Software)
OpenGL
Direct GPU
Reactive state Signals (push-pull, zero glitch)
Binding
Events
Gesture recognition Arena-based (Flutter pattern)
No
No
Layout engine Flexbox + Grid + per-widget cache
Custom
Flex
Accessibility Day 1 (35+ ARIA roles)
Limited
Limited
Design systems 4 (M3, DevTools, Fluent, Cupertino)
1
1
Widgets 27 interactive + primitives
~20
~15
Plugin system Yes (deps, assets, fonts)
No
No
Android In review (wgpu#268 )
Yes
Yes
examples/hello — Checkboxes, Radio Buttons, ListView (1000 items), Material Design 3
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 using desktop.Run (recommended):
package main
import (
"log"
_ "github.com/gogpu/gg/gpu"
"github.com/gogpu/gogpu"
"github.com/gogpu/ui/app"
"github.com/gogpu/ui/desktop"
"github.com/gogpu/ui/primitives"
"github.com/gogpu/ui/widget"
)
func main () {
gogpuApp := gogpu .NewApp (gogpu .DefaultConfig ().
WithTitle ("My App" ).
WithSize (800 , 600 ))
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 )),
)
if err := desktop .Run (gogpuApp , uiApp ); err != nil {
log .Fatal (err )
}
}
Package
Description
Coverage
geometryPoint, Size, Rect, Constraints, Insets
98.8%
eventMouseEvent, KeyEvent, WheelEvent, FocusEvent, Modifiers
100%
widgetWidget, WidgetBase, Context, Canvas, Lifecycle (mount/unmount), SchedulerRef
100%
internal/renderCanvas, SceneCanvas, IconCache (2-level LRU), DPI-aware SVG
96.5%
internal/layoutFlex, Stack, Grid layout engines
89.9%
Package
Description
Coverage
a11yAccessibility: 35+ ARIA roles, Accessible interface, Tree, Announcer
99.1%
stateReactive signals, Binding, Scheduler with push-based invalidation
100%
primitivesBox, Text, Image widgets with fluent builder API
94.4%
appWindow integration via gpucontext interfaces (dependency inversion)
98.6%
Extensibility (Phase 1.5)
Package
Description
Coverage
layoutPublic layout API with custom algorithms
89.5%
registryWidget factory registration for third-party widgets
100%
themeTheme system with Extensions and Registry
100%
pluginPlugin bundling with dependency resolution
99.4%
Interactive Widgets (Phase 2 — Complete)
Package
Description
Coverage
cdkComponent Development Kit — Content[C] polymorphic pattern
100%
core/buttonGeneric button with pluggable Painter, 4 variants, 3 sizes, signal bindings
96%+
core/checkboxToggleable checkbox with checked/unchecked/indeterminate states, signal bindings
96%+
core/radioMutually exclusive radio group with vertical/horizontal layout, signal bindings
96%+
core/textfieldText input with cursor, selection, clipboard, validation, signal bindings
96%+
core/sliderSlider: continuous/discrete, horizontal/vertical, drag+keyboard, signal bindings
94.6%
core/dialogModal dialog: backdrop overlay, action buttons, focus trapping, Alert/Confirm
96.9%
core/dropdownDropdown/select with overlay menu, keyboard navigation, signal bindings
96%+
overlayOverlay/popup stack, container, position helper
95%+
primitivesBox, Text, Image, RepaintBoundary (GPU texture caching via Layer Tree compositor)
94.4%
theme/material3Material Design 3 — theme (HCT color science) + 24 component painters
97%+
focusKeyboard focus management with Tab/Shift+Tab navigation
95.2%
internal/focusInternal focus manager implementation
15.2%
Package
Description
Coverage
animationAnimation engine: tween, spring, M3 presets, orchestration (Stagger/Chain/Repeat/Reverse)
92.3%
transitionWidget enter/exit animations: Fade, Slide, Scale effects, Show/Hide wrapper
98.7%
core/scrollviewScrollable container: vertical/horizontal/both, wheel+keyboard+drag, PushClip/PushTransform, signal bindings
96.5%
core/tabviewTabbed navigation: lazy content switching, closeable tabs, keyboard nav, Top/Bottom position, signal bindings
92.1%
core/listviewVirtualized list: fixed-height items, recycling, single/multi selection, keyboard nav, M3 painter
96%+
core/gridviewVirtualized 2D grid: fixed cell size, auto-fit columns, cell recycling, selection, keyboard nav
92.1%
core/linechartReal-time line chart: multiple series, rolling window, grid, Y-axis labels, thread-safe PushValue
98.8%
core/progressbarLinear progress bar: 0-100%, rounded corners, label, signal binding, PushClipRoundRect
99.3%
core/collapsibleExpandable section: animated expand/collapse, keyboard focus, arrow indicator, Tween animation
98.2%
primitivesBox (HBox/VBox direction), Text, Image, ThemeScope, RepaintBoundary
94%+
Package
Description
Coverage
core/progressCircular progress: determinate arc + indeterminate spinner, polyline approximation
97.4%
core/popoverPopover (click) + Tooltip (hover): 12 placements, auto-flip, overlay integration
97.1%
core/splitviewResizable split panels: draggable divider, min constraints, collapse, handle dots
96.8%
core/treeviewHierarchical tree: expand/collapse, virtualized rendering, connector lines, keyboard nav
96%+
core/datatableSortable column table: fixed header, virtualized rows, zebra striping, sort indicators
96%+
core/toolbarHorizontal action bar: icon buttons, separators, spacers, custom widget items
96%+
core/menuMenuBar + ContextMenu: submenus, separators, disabled items, shortcut display
96%+
core/dockingIDE-style dockable panels: border layout, tabbed groups, Dock/Undock API
95.3%
core/badgeNotification badge: count mode (pill, "99+" overflow), dot mode, signal bindings with dedup
99.3%
core/chipAction/filter chip (M3 spec): toggleable selection, two-way signal write-back, state layers
99.0%
theme/material324 component painters (all widgets covered)
97%+
theme/devtoolsJetBrains DevTools : 24 painters, Int UI gray scale, dark/light, IDE-style96%+
theme/fluentMicrosoft Fluent Design: 11 painters, accent colors, inner focus ring, light/dark
96%+
theme/cupertinoApple HIG: 11 painters, iOS toggle switch, segmented control, pill buttons
96%+
theme/fontFont Registry: CSS weight matching (W3C spec), Weight 100-900, Style, Family/Face
97.7%
iconSVG icons (JetBrains expui), 2-level cache, DPI-aware rasterization, gg/svg renderer
97%+
i18nInternationalization: Locale, Bundle, Translator, CLDR plural rules, RTL, LocaleSignal
97.9%
dndDrag and drop: DragSource/DropTarget interfaces, Manager, 5px threshold, Escape cancel
99.3%
offscreenHeadless widget rendering: CPU-only *image.RGBA output, no GPU/window/app required
100%
uitestTesting utilities: MockCanvas, MockContext, event factories, widget helpers, assertions
93.1%
internal/dirtyDirty region tracking: Collector, Tracker, merge algorithm, partial repaints
100%
core/stripeVertical sidebar strip: tool window buttons, top/bottom items, icon buttons
96%+
core/titlebarWindow title bar: CSD, drag, minimize/maximize/close, WindowChrome interface
96%+
gestureGesture recognition: Arena, ClickRecognizer, DragRecognizer, LongPressRecognizer, TapAndDragRecognizer, VelocityTracker, Team
96.0%
compositorLayer Tree compositor: OffsetLayer, PictureLayer, ClipRectLayer, OpacityLayer — production render pipeline
95%+
desktopProduction render loop: Layer Tree → GPU textures → damage-aware blit
—
Total: ~220,000+ lines of code | 70 packages | ~7,800+ tests | 97%+ average coverage
gogpu/ui renders through any GPU backend via the gogpu ecosystem — no code changes needed:
GOGPU_GRAPHICS_API=vulkan go run ./examples/hello/ # Vulkan (default on Linux)# DirectX 12 (Windows)# Metal (macOS)# OpenGL ES# CPU software renderer The software backend runs on any machine without GPU drivers. It uses the same unified render pipeline (Layer Tree compositor, offscreen boundary textures, damage-aware blit) as GPU backends. Performance is significantly slower than GPU — optimization via naga Go+SIMD backend (NAGA-FEAT-004 ) is planned.
Android support is in review (wgpu#268 ) — Vulkan on arm64, contributed by @besmpl for Hearth game engine.
┌─────────────────────────────────────────────────────────────┐
│ User Application │
├─────────────────────────────────────────────────────────────┤
│ theme/material3/ │ theme/devtools/ │ theme/fluent/ │
│ 24 Painters │ 24 Painters │ 11 Painters │
│ theme/cupertino/ │ │ │
│ 11 Painters │ 70 painters total across 4 systems │
├─────────────────────────────────────────────────────────────┤
│ 27 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, badge, chip, │
│ stripe, titlebar, gpuview │
├──────────────┬──────────────────────────────────────────────┤
│ 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/ │
├─────────────────────────────────────────────────────────────┤
│ gesture/ (Arena, Click, Drag, LongPress, Team) │
├─────────────────────────────────────────────────────────────┤
│ app/ + FocusManager │ focus/ │ overlay/ │ render/ │
├─────────────────────────────────────────────────────────────┤
│ desktop/ (Layer Tree Compositor + Damage-Aware Blit) │
│ compositor/ (Production: OffsetLayer, PictureLayer, Opacity)│
│ offscreen/ (headless widget → *image.RGBA) │
├─────────────────────────────────────────────────────────────┤
│ 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 │
│ IconCache (LRU) │ internal/dirty │ Tracker, Collector │
├─────────────────────────────────────────────────────────────┤
│ gogpu/gg │ gpucontext │ coregx/signals │
│ 2D Graphics │ Shared Ifaces │ State Management │
└─────────────────────────────────────────────────────────────┘
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.
Enterprise-grade retained-mode rendering (ADR-007) with unified draw queue (ADR-051/052):
O(1) frame skip — flat dirty boundary set, no tree walks when idle (0% GPU)Layer Tree composition — OffsetLayer, PictureLayer, OpacityLayer, ClipRectLayerPer-boundary GPU textures — dirty boundaries re-render to MSAA offscreen texture, clean reuse cachedDamage-aware blit — LoadOpLoad + multi-rect scissor, only dirty pixels touch the GPUPersistent tree — layer objects reused across frames (97.9% fewer allocations)Unified draw queue — backend-agnostic command dispatch (shapes, text, GPU textures through single pipeline). GPU backends batch into render passes; software dispatches through CPU rasterizer.
Validated by enterprise research: Flutter, Chrome, Qt6, Android, Skia patterns.
Works on all backends: Vulkan, DX12, Metal, GLES, Software, Browser (WASM).
Example
Description
examples/helloWidget demo: checkbox, radio, ListView (1000 items), M3 theme, event-driven GPU rendering
examples/signalsReactive signals: TextSignal, ContentSignal, CheckedSignal, SelectedSignal, DisabledSignal
examples/taskmanagerFull task manager: charts, tables, animations, real-time data
examples/galleryWidget gallery: all 26 widgets, 4 design systems (M3/DevTools/Fluent/Cupertino), theme switching
examples/ideGoLand-inspired IDE layout: DevTools theme, toolbar, tree, tabs, terminal, SVG icons
examples/filedropOS file drag-and-drop: drop files from file manager, reactive path display
examples/gpuviewGPU view widget: offscreen texture compositing (Flutter Texture pattern)
examples/modular-compositorMulti-module offscreen rendering: clock + notification compositor (#75 )
Run any example:
cd examples/gallery
go run . // 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" )// 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
)// 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 )// 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 )// 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 }),
)// 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 ) }),
)// 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 )
})// 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" ),
)// 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 )// Render widgets to image without GPU, window, or app
r := offscreen .NewRenderer (400 , 120 )
r .Render (primitives .Text ("Hello, World!" ).FontSize (24 ))
img := r .Image () // *image.RGBA — ready for png.Encode, testing, compositing
// HiDPI with dark theme and white background
dark := material3 .NewDark (widget .Hex (0x00BFA5 ))
r := offscreen .NewRenderer (800 , 240 ,
offscreen .WithTheme (dark ),
offscreen .WithScale (2.0 ),
offscreen .WithBackground (widget .ColorWhite ),
)
r .Render (myWidgetTree )// 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
Phase 1.5: Extensibility ✅
Phase 3: Release Candidate ✅
Phase 4: Production (v1.0) — In Progress
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.
go get github.com/gogpu/ui@latest
go mod tidy A runnable application also imports gogpu (windowing) and gg (rendering), as in the Quick Start above. go mod tidy adds them at the versions this ui release was built with. Upgrade them together with ui, not ahead of it: a newer gogpu or gg may not build with the other versions this ui release uses.
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, DX12, GLES, Software, Browser
gogpu/naga Shader compiler — WGSL to SPIR-V, MSL, GLSL, HLSL, DXIL
gogpu/g3d Pure Go 3D rendering — scene graph, PBR, forward renderer
gogpu/compose Multi-process composition — Unix socket, LZ4, hot-plug
gogpu/audio Pure Go audio engine — WASAPI, WAV decoder, Mixer
Total ecosystem: 1.14M+ lines of Pure Go — zero CGO, Rust optional via -tags rust (ADR-038). Android/arm64 in review.
Contributions are welcome! Please read CONTRIBUTING.md for guidelines.
Ways to contribute:
Test the packages, report bugs
API feedback and suggestions
Documentation improvements
Software backend profiling and optimization
Spread the word (Hacker News, Dev.to, GitHub Discussions)
Code contributions (see open issues)
MIT License — see LICENSE for details.
gogpu/ui — Enterprise-grade GUI for GoPart of the GoGPU ecosystem
