Version: 0.1.23 (Custom Font Pipeline + Mac Retina Fix + CJK) Updated: May 2026 Go Version: 1.25+

gogpu/ui is a reference implementation of an enterprise-grade GUI library for Go.

Target applications:

• IDEs (GoLand-class)
• Design tools (Photoshop, Illustrator)
• CAD applications
• Chrome/Electron-class applications
• Professional dashboards

Key differentiators:

• Pure Go (zero CGO)
• WebGPU-first rendering via gogpu/wgpu
• Signals-based state management (coregx/signals)
• Enterprise features: docking, virtualization, accessibility
• Four design systems: Material 3, DevTools (JetBrains), Fluent, Cupertino

v0.x.x  → Active development (current)
v1.0.0  → ONLY when API stable for 1+ year
v2.0.0  → AVOID (requires /v2 import path)

v0.0.x  → Phase 0 Foundation ✅ COMPLETE
v0.1.0  → Phase 1 MVP ✅ COMPLETE
v0.1.x  → Phase 1.5 Extensibility ✅ COMPLETE
v0.2.0  → Phase 2 Beta ✅ COMPLETE
v0.2.x  → Phase 2.5 Signals Integration ✅ COMPLETE
v0.3.0  → Phase 3 RC ✅ COMPLETE
v0.4.0  → Phase 4 v1.0 features (in progress)
v0.9.0  → Pre-1.0 API freeze
v0.10+  → Stabilization
v1.0.0  → Production (when ready)

Full policy: docs/VERSIONING.md

┌─────────────────────────────────────────────────────────────┐
│                    User Application                         │
├─────────────────────────────────────────────────────────────┤
│  theme/material3  │ theme/devtools │ theme/fluent │ theme/cupertino │
│  (Complete)       │ (Complete)     │ (Complete)   │ (Complete)      │
├─────────────────────────────────────────────────────────────┤
│  core/button/      │  animation/ ✅    │  core/docking/ ✅  │
│  core/checkbox/    │  Tween, Spring    │  DockingHost       │
│  core/radio/       │  M3 motion        │  Zone, Panel       │
│  core/textfield/   │                   │                    │
│  core/dropdown/    │  transition/ ✅   │  dnd/ ✅           │
│  core/slider/ ✅   │  Enter/exit       │  Drag & Drop       │
│  core/dialog/ ✅   │  effects          │                    │
│  core/scrollview/✅│                   │  uitest/ ✅        │
│  core/tabview/ ✅  │  internal/        │  Test utilities    │
│  core/listview/ ✅ │  render/          │                    │
│  core/gridview/ ✅ │  Canvas +         │  i18n/ ✅          │
│  core/linechart/ ✅│  SceneCanvas ✅   │  Internationalize  │
│  core/progressbar/✅│  (tile-parallel  │                    │
│  core/progress/ ✅ │   scene.Scene)    │  icon/ ✅          │
│  core/collapsible/✅│                  │  Icon system       │
│  core/splitview/ ✅│                   │                    │
│  core/popover/ ✅  │                   │  theme/font/ ✅    │
│  core/treeview/ ✅ │                   │  Typography        │
│  core/datatable/ ✅│                   │                    │
│  core/toolbar/ ✅  │                   │                    │
│  core/menu/ ✅     │                   │                    │
│  focus/ overlay/ ✅│                   │                    │
├─────────────────────────────────────────────────────────────┤
│  layout/                            │  state/               │
│  VStack, HStack, Grid, Flexbox      │  coregx/signals       │
│  (Complete ✅)                      │  (Complete ✅)       │
├─────────────────────────────────────────────────────────────┤
│  widget/                            │  event/               │
│  Widget, WidgetBase, Context        │  Mouse, Keyboard      │
│  (Complete ✅)                      │  (Complete ✅)       │
├─────────────────────────────────────────────────────────────┤
│  geometry/        │  internal/render │  internal/layout     │
│  Point, Rect      │  Canvas impl     │  Flex, Stack, Grid   │
│  (Complete ✅)    │  (Complete ✅)   │  (Complete ✅)      │
├─────────────────────────────────────────────────────────────┤
│  gogpu/gg          │  gogpu/gogpu    │  coregx/signals      │
│  2D Graphics ✅    │  Windowing      │  State Management    │
└─────────────────────────────────────────────────────────────┘

Goal: Core packages for building widgets

Completed:

• geometry — Point, Size, Rect, Constraints, Insets
• event — MouseEvent, KeyEvent, WheelEvent, FocusEvent, Modifiers
• widget — Widget interface, WidgetBase, Context, Canvas, Color
• internal/render — Canvas implementation using gogpu/gg
• internal/layout — Engine, FlexContainer, VStack, HStack, ZStack, Grid

Goal: Working foundation with basic widgets

Delivered:

• Signals integration (coregx/signals)
• Basic primitives (Box, Text, Image)
• Public layout API
• Theme system foundation
• Window integration (app package via gpucontext interfaces)

Goal: Enable community to create custom widgets, themes, and layouts

Implemented Packages:

• registry/ — Widget factory registration (100% coverage)
• layout/ — Public layout API with custom algorithms (89.5% coverage)
• theme/ — Theme System + Extensions + Registry (100% coverage)
• plugin/ — Plugin bundling with dependency resolution (99.4% coverage)

Goal: Interactive widget library with Material Design 3

Implemented Packages:

• core/button/ — Interactive button, 4 variants, 3 sizes, pluggable Painter
• core/checkbox/ — Toggleable checkbox, 3 states
• core/radio/ — Radio group, vertical/horizontal, arrow key navigation
• core/textfield/ — Text input, cursor, selection, clipboard, validation
• core/dropdown/ — Dropdown/select, overlay menu, keyboard nav, scroll
• overlay/ — Overlay stack, container, position helper
• focus/ — Keyboard focus management with Tab/Shift+Tab
• theme/material3/ — M3 theme (HCT color science) + widget painters
• cdk/ — Component Development Kit, Content[C] pattern
• primitives/themescope.go — Theme override for widget subtrees

Goal: Push-based reactive state for all widgets

Key decisions:

• PropertySignal naming convention: TextSignal(), CheckedSignal(), etc.
• Priority: ReadonlySignal > Signal > Fn > Static
• Two-way binding for stateful widgets (checkbox, radio, textfield, dropdown)
• One-way for display widgets (button text, labels, primitives)

Goal: Enterprise features, rendering optimizations, containers

Completed:

Goal: Production-ready enterprise library

Completed:

Remaining:

Architecture: Hybrid CPU+GPU — industry standard (Chrome/Skia, Flutter, GTK4, Qt). CPU text atlas + GPU shapes + GPU compositor. Validated by source-level analysis of 8 engines.

Single-pass compositor (Flutter OffsetLayer / Chrome cc pattern):

• FlushPixmap: CPU pixmap upload without GPU readback
• DrawGPUTextureBase: pixmap as base layer (drawn first)
• FlushGPUWithView: GPU shapes overlay (same render pass)

• Scene composition: full DrawTree every frame via render.Canvas (gg.Context GPU pipeline). RepaintBoundary cache hit = replay cached scene.Scene; miss = re-record. Single FlushGPUWithView render pass per frame. No retained CPU pixmap.
• Granular widget invalidation (INVAL-001): 11 interactive widgets migrated from ctx.Invalidate() to SetNeedsRedraw + InvalidateRect. ~50 regression tests.
• GPU SDF shapes natively: no RasterizerAnalytic hack, shadows and rounded corners rendered via GPU accelerator.
• Upward dirty propagation: O(depth) to nearest RepaintBoundary, O(1) guard.

• Per-boundary GPU textures: each RepaintBoundary → own offscreen MSAA texture
• DrawChild skip: child boundaries SKIPPED during parent BoundaryRecording (Flutter paintChild)
• Compositor scissor clipping: items clipped by parent viewport (ScrollView)
• Frame skip: early return in desktop.draw when nothing dirty → 0% GPU idle
• Offscreen boundary culling: isBoundaryVisible checks CompositorClip intersection
• Pumper isolation: ScheduleAnimationFrame only pumper trigger, data tickers don't restart 30fps
• 34 integration tests: multi-frame lifecycle, visibility matrix, damage rects, recording order

• Layer Tree compositor in production — compositor/ drives render loop (OffsetLayer, PictureLayer, ClipRectLayer, OpacityLayer)
• Persistent Layer Tree — UpdateLayerTree() reuses layers (97.9% fewer allocs, 613→13)
• O(1) frame skip — flat dirty boundary set replaces O(n) tree walk (45× faster)
• Multi-rect damage — per-draw dynamic scissor, ring buffer, 16-rect merge threshold
• LoadOpLoad — preserve previous framebuffer, blit only damage rects
• Partial present — PresentWithDamage sends dirty rects through full stack
• Overlay boundary pipeline — dropdown/dialog content via same Layer Tree
• Remaining: scheduler.SetOnDirty lifecycle → spinner GPU 10% → <3%

Full Vello 9-stage compute pipeline for GPU-accelerated path rendering:

• internal/gpu/tilecompute/ already exists (CPU reference)
• GPU dispatch via wgpu compute shaders

Indirect: go-text/typesetting v0.3.4, gogpu/gputypes v0.5.0, gogpu/wgpu v0.28.1, gogpu/naga v0.17.14, goffi v0.5.1, golang.org/x/text v0.37.0

• 60fps with 10,000 widgets
• <100ms startup time
• <1KB memory per widget
• 0% GPU on static UI ✅

• 80%+ test coverage (current: 97%+)
• WCAG 2.1 AA compliance
• Zero known critical bugs

• 20+ example applications
• Complete API documentation
• Migration guides from Fyne/Gio

This roadmap is updated as the project evolves.