# Gova

Gova is a declarative GUI framework for Go. You write desktop apps as plain Go and compile a single static binary for macOS, Windows, and Linux — no Chromium, no JavaScript runtime, no bundled assets. The pitch against Fyne is the reactivity model; the pitch against Wails/Tauri is the absence of an embedded browser.

It's listed on [[toolbox/watchlist]] — repo was created 2026-04-22, two days before this entry went in. Single author, no tagged releases, pre-1.0. The concept is interesting enough to track, but nothing here is production-shaped yet.

## The distinguishing feature: explicit reactive scope

State, signals, and effects live on a `Scope` value that you can see and pass around. There's no hidden scheduler, no hook-order rules, no re-render-surprise class of bug. A counter component:

```go
package main

import . "github.com/nv404/gova"

var Counter = Define(func(s *Scope) View {
  count := State(s, 0)

  return VStack(
    Text(count.Format("Count: %d")).Font(Title),
    Button("+", func() { count.Update(func(n int) int { return n + 1 }) }),
    Button("-", func() { count.Update(func(n int) int { return n - 1 }) }),
  )
})

func main() { Run("Counter", Counter) }
```

Views are plain Go structs. Props are struct fields. Defaults are zero values. Composition is function calls. The compiler checks your UI the same way it checks any other Go code. This is closer to SwiftUI's shape than to React's — you don't declare "hooks" that implicitly mount to a global stack, you just take a `*Scope` argument and it's obvious what depends on what.

Whether this ergonomic bet pays off depends on how non-trivial layouts look. The counter is small enough that any framework looks clean.

## The portability caveat

Platform support is not symmetric:

| Feature | macOS | Windows | Linux |
|---|---|---|---|
| Hot reload via `gova dev` | yes | yes | yes |
| App icon at runtime | yes | yes | yes |
| Native dialogs | NSAlert / NSOpenPanel | Fyne fallback | Fyne fallback |
| Dock integration | NSDockTile | planned | planned |

So "native dialogs everywhere" means "NSAlert on macOS, otherwise Fyne draws a window that looks like Fyne." That's honest, but it does mean the framework's portability story rests on Fyne on two of the three platforms. If Fyne's look-and-feel is a dealbreaker on Linux, Gova doesn't solve that problem for you.

cgo is required on all platforms (Xcode CLT on macOS, build-essential + libgl1-mesa-dev on Linux, mingw-w64 on Windows). Cross-compilation therefore carries the normal cgo pain.

## CLI

Three commands, install with `go install github.com/nv404/gova/cmd/gova@latest`:

- `gova dev` — watch `.go` files, rebuild on save, relaunch the window. Ignores `.git`, `node_modules`, `vendor`, `_test.go` by default.
- `gova build` — static binary for the current platform. Pair with `-ldflags "-s -w"` for a smaller artifact.
- `gova run` — build and launch once, no file watching. Useful in CI for smoke tests.

## Footprint

Measured on macOS arm64 with Go 1.26.2, counter example:

- Default binary: 32 MB
- Stripped (`-ldflags "-s -w"`): 23 MB
- Memory idle: ~80 MB RSS

For comparison, a Wails app is usually 10–20 MB but carries the OS webview (so the user pays elsewhere); an Electron app is 150+ MB. Gova sits in the same "bundle your own runtime" class as Fyne, which is expected — under the hood it leans on Fyne for the non-macOS path.

## Status

- Created: 2026-04-22
- Stars: 78 (at time of ingest, 2026-04-24)
- Releases: none tagged yet
- Open issues: 0
- Single author (`nv404`), one community PR merged
- README says "pre-1.0 and the API is still moving"

Re-check signals at 2026-07-24: is the Windows/Linux story still Fyne-fallback? Has the API stabilized? Any v0.x tags? Did the star trajectory continue or flat-line at the launch peak?

**Repo:** https://github.com/nv404/gova — 78 stars, MIT.