Stop Fighting Go GUIs: Build Sleek Desktop Apps in Pure Go with Proton

The state of GUI development in Go has always been a bit complicated.

You either have to wrestle with heavy C-dependencies like GTK and Qt bindings that make cross-compiling a nightmare, or settle for web-view frameworks that turn a simple desktop utility into a 150MB RAM-hogging Electron clone.

If you love Go for its simplicity, speed, and single-binary deployment, your GUI library should look and feel the same way.

That is exactly why I built Proton.

What is Proton?

Proton is a lightweight, pure-Go GUI framework built on top of the incredibly fast Gio engine. It utilizes an immediate-mode architecture, meaning your UI renders dynamically every single frame.

The philosophy behind Proton is straightforward: Zero C-dependencies, ultra-fast performance, and a developer experience that does not make you want to pull your hair out.

Here is why it works so well:

Pure Go: No cgo required. Cross-compiling actually works out of the box.

Featherweight: Tiny binary sizes and low resource usage.

Immediate Mode: Your state lives directly in your code. No complex data-binding boilerplate.

Themeable: Comes with built-in palettes like Catppuccin, Nord, and Rose Pine.

See it in Action: The 5-Minute Setup

Here is a complete, self-contained application with an input box, a button, and basic text handling in just a few lines of code:

package main

import "github.com/CzaxStudio/proton"

type UI struct {
    name proton.Editor
    btn  proton.Clickable
}

func main() {
    u := &UI{}
    a := proton.New("My First Proton App")

    // Apply a theme instantly
    a.ApplyPalette(proton.CatppuccinPalette)

    a.Window("Hello Proton", 480, 300, func(win *proton.Win) {
        proton.H3(win, "Welcome to Go GUIs done right")
        proton.Gap(win, 12)

        // Interactive Input
        proton.Input(win, &u.name, "What is your name?")
        proton.Gap(win, 12)

        // Immediate-mode button handling
        if proton.Button(win, &u.btn, "Greet Me") {
            println("Hello, ", u.name.Text())
        }
    })

    a.Run()
}

Layouts Without the Headache

If you have ever used Gio directly, you know that managing layouts and constraints can require a lot of nesting. Proton abstracts that complexity away into intuitive layout functions:

Stacking: Arrange components cleanly using Row(win, ...) and Column(win, ...).

Flexibility: Use GrowRow alongside GrowItem and FixedItem to create responsive sidebars and expanding content panes.

Proportions: Instantly split screens using Split(win, 0.25, leftSide, rightSide) for instant dashboard layouts.

Spacing: Fine-tune visuals cleanly with Pad(), PadH(), and Gap()

// Example of a quick responsive layout split
proton.Split(win, 0.25, func(left *proton.Win) {
    proton.Label(left, "Sidebar Navigation")
}, func(right *proton.Win) {
    proton.H1(right, "Main Content Dashboard")
})

Real Features for Real Apps

Proton is not just a proof-of-concept for text and buttons. It includes the actual utilities you need to build functional software:

Virtualized Lists: List() and HList() only render what is visible on screen, letting you scroll through thousands of rows smoothly without breaking a sweat.

Keyboard Shortcuts: Global hotkeys are a first-class citizen. Fire events using proton.OnKey(win, key.ModCtrl, "S", saveFunc).

Async Notifications: Show modern, non-blocking toast notifications safely from any background goroutine using u.toast.Show("Saved!", 2 * time.Second).

Asset Embedding: Includes a simple built-in CLI tool (Proton logo path/to/img.png) that caches and bakes assets directly into your binary.

Try it out

Ready to ditch the heavy web frameworks and complex C bindings? Getting started takes seconds. Just initialize your Go module and pull the library:

mkdir myapp && cd myapp
go mod init myapp
go get github.com/CzaxStudio/proton

If you are on Linux, just grab your standard graphics drivers (libwayland-dev, libxkbcommon-dev, libvulkan-dev). Windows and macOS users need zero extra system dependencies.

The project is completely open-source and moving fast. Check out the example applications, including a fully functional Calculator and a CyberTool showcase, directly in the repository.

Take a look at the Proton GitHub Repository, try out the examples, and let me know what you think in the comments. I am curious to see what you build with it.

If you like it then please star the Repo

CzaxStudio / proton

A framework for building GUI applications in Go, Stay positive :)

Proton

A GUI library for Go. Built on Gio. No C deps, pure Go.

Example apps (made using Proton)

Note: These are very basic, you can make even better apps.

Logo

Getting started

package main
import "github.com/CzaxStudio/proton"

type UI struct {
    name proton.Editor
    btn  proton.Clickable
}

func main() {
    u := &UI{}
    a := proton.New("my app")
    a.Window("Hello", 480, 300, func(win *proton.Win) {
        proton.H3(win, "Hello from Proton!")
        proton.Gap(win, 8)
        proton.Input(win, &u.name, "Your name")
        proton.Gap(win, 8)
        if proton.Button(win, &u.btn, "Go") {
            println("Hello,", u.name.Text())

…

View on GitHub