The GUI Framework
Go Deserves
Hybrid immediate-mode. GPU-accelerated. Cross-platform. No virtual DOM, no JavaScript — just fast, composable Go.
🍎 macOS🪟 Windows🐧 Linux
📱 iOS🤖 Android🌐 Web / WASM
Hybrid immediate-mode. GPU-accelerated. Cross-platform. No virtual DOM, no JavaScript — just fast, composable Go.
A framework that refuses to compromise
No virtual DOM. No diffing. Layout, sizing, and rendering happen in a single pass each frame. GPU-accelerated via Metal, OpenGL, or WebGL — zero-alloc draw paths keep frames smooth at any scale.
Build UI with plain Go functions. State lives in a single typed slot per window — no closures, no globals, no framework magic. Views are pure functions; testing is trivial.
Built-in accessibility tree, IME support, OS-level spell check, native dialogs, and system tray. 50+ widgets, time-travel debugging, and headless test backend — tools you need to ship real apps.
Six libraries, one coherent toolkit — each laser-focused, all designed to compose
Core framework — widgets, constraint layout, event system, GPU-accelerated retained-mode scene graph.
Browser-quality text rendering — BiDi, multi-grapheme clusters, complex scripts — plus vector icons and glyph rasterization.
Declarative charting — line, bar, area, pie, scatter, candlestick — incremental updates for real-time dashboards.
Text editing — single-line to multi-cursor code editor, piece-table undo, syntax highlighting, completion hooks.
Tiled raster/vector map widget with projection handling, markers, and geospatial overlays.
Embeddable terminal emulator — PTY, ANSI/VT parser, render surface as a go-gui widget.
Deep capabilities across rendering, widgets, text, and developer tooling
Metal on macOS. OpenGL on Linux and Windows. WebGL in the browser. Every frame, a single pass sizes, positions, and renders the entire widget tree — no virtual DOM, no diffing overhead, no hidden layout passes.
Custom GPU shaders are a first-class feature. Rounded-rect clip masking, box shadows, blur effects, and color-filter post-processing ship out of the box.
Hundreds of simultaneous animations, each updating independently — and the frame graph barely moves. go-gui's single-pass pipeline and zero-alloc draw path mean you can throw real workloads at it without worrying about jank.
Every spinner in this demo is a fully composited widget with its own animation state. No pre-rendered sprites, no tricks — just the framework doing what it was designed to do.
Buttons, inputs, sliders, tables, trees, tabs, menus, dialogs, toasts, breadcrumbs — every widget follows the same config-struct pattern. DataGrid with built-in virtualization, sorting, grouping, inline editing, and CSV/TSV/XLSX/PDF export.
IDE-style DockLayout with drag-and-drop panel rearrangement. Canvas and DrawCanvas for custom rendering. Sidebar, CommandPalette, Form with validation — the widget set covers real application needs.
Full Unicode support with bidirectional text, complex script shaping, and multi-grapheme clusters. Rich text with mixed fonts, sizes, colors, and inline styling. Gradient text, stroke outlines, affine transforms, and glyph placement on paths.
Zero-alloc draw path. Multi-page glyph atlas with automatic shelf packing and time-based eviction. IME composition with clause underlines and cursor feedback.
Line, bar, area, scatter, bubble, pie, donut, gauge, candlestick, histogram, box plot, waterfall, radar, heatmap, treemap, funnel, sankey, sparkline. Interactive zoom, pan, and brush select. Real-time dashboards with incremental updates.
Render to PNG or SVG with no window — 16x MSAA, export from CI, servers, or headless environments. Built-in data transforms: moving averages, regression, Bollinger bands, LTTB downsampling.
Time-travel debugging — scrub back through app state frame-by-frame with a built-in debugger window. Headless testing — runs all layout and widget logic without a display server. Theme system — dark, light, custom themes with a live theme picker widget.
Command registry with global hotkeys and a fuzzy-search command palette. 35 example applications ship with the framework. CI runs on every commit.
Single-line input to full multi-cursor code editor — go-edit covers the full spectrum. Piece-table undo with infinite history. Syntax highlighting with pluggable grammars. Completion hooks for LSP integration.
Search and replace with regex. Code folding. Diagnostics API for inline error markers. Built as an extension substrate — embed it, theme it, wire it into your toolchain.
Tiled raster and vector maps with projection handling — OSM, WMS, and custom tile sources. Kinetic pan and zoom. Markers, polylines, polygons, and circles as first-class overlay primitives.
Legend, gallery, and overview companion widgets. Geospatial overlays with coordinate transforms. Every map is a standard go-gui widget — compose it with charts, tables, or forms in the same window.
Real screenshots from the framework and its companion libraries
Install dependencies, write a view, run — that's it
go get github.com/go-gui-org/go-gui
package main
import (
"fmt"
"github.com/go-gui-org/go-gui/gui"
"github.com/go-gui-org/go-gui/gui/backend"
)
type App struct{ Clicks int }
func main() {
gui.SetTheme(gui.ThemeDarkBordered)
w := gui.NewWindow(gui.WindowCfg{
State: &App{},
Title: "Hello GUI",
Width: 300,
Height: 300,
OnInit: func(w *gui.Window) { w.UpdateView(mainView) },
})
backend.Run(w)
}
func mainView(w *gui.Window) gui.View {
app := gui.State[App](w)
return gui.Column(gui.ContainerCfg{
HAlign: gui.HAlignCenter,
VAlign: gui.VAlignMiddle,
Content: []gui.View{
gui.Text(gui.TextCfg{Text: "Hello GUI!"}),
gui.Button(gui.ButtonCfg{
IDFocus: 1,
Content: []gui.View{
gui.Text(gui.TextCfg{
Text: fmt.Sprintf("%d Clicks", app.Clicks),
}),
},
OnClick: func(l *gui.Layout, e *gui.Event, w *gui.Window) {
gui.State[App](w).Clicks++
e.IsHandled = true
},
}),
},
})
}15 lines of Go → native app on every platform. No runtime, no VM, no JavaScript.