mygo: an AI-built Go framework for desktop apps, with native UI or a web frontend

mygo (the project writes it MyGo) is a Go framework for desktop apps. Each window shows either a web page in the operating system’s own webview or a native UI that mygo draws itself, written in Go alone. The repository is five weeks old and already at v0.7.4. Its git history shows Claude did much of the writing: 778 of its 944 commits carry a Co-authored-by: Claude trailer. The project makes two main claims, pure Go with no cgo and cross-compiling from any machine, and both held up when we built its native-UI example on Linux. We did not test performance, the web mode, or the apps on macOS and Windows.

The author is EGOIST (GitHub egoist), who posts on X as @localhost_5173 in English and @localhost_4173 in Chinese. In this article, project claims means what the README, docs and author say. Our measurements means what we ran on November 1, 2026.

What mygo is

According to the README, an app or a single window can mix two kinds of UI:

• Web pages run in the system webview: WKWebView on macOS, WebKitGTK on Linux and WebView2 on Windows. The architecture doc says “no browser engine is bundled”. The frontend calls Go through a generated TypeScript client.
• Native UI is written in Go with package ui, with “no HTML, no JavaScript and no webview”. mygo draws it “with Metal, Direct3D 11 or OpenGL, or on the CPU”. The same UI can compile to WebAssembly and run in a browser on WebGL 2.

Other parts listed in the README:

• Typed IPC with mygo.Bind and mygo.NewEvent[T].
• A widget toolkit with flexbox and grid layout, IME input, virtualized lists, SVG, animation, screen reader support, and views you can test without a window.
• Desktop APIs for tray, menus, dialogs, notifications, global shortcuts, deep links, file associations and media keys.
• Packaging for macOS app bundles and dmg files, Windows installers, Debian packages, Arch PKGBUILDs and a Linux install script, plus code signing, notarization and signed delta auto-updates with an update window like Sparkle’s.
• Plugins for SQLite, a terminal built on libghostty-vt, Liquid Glass effects on every platform, an updater, WebSocket, file watching, and an automation plugin that lets test runners “and agents” drive a running app.

The architecture doc sets the rules. Everything builds with CGO_ENABLED=0. Native APIs are called at run time through purego on macOS and Linux and through syscall on Windows. The design goal is “Great DX over API parity. The API has the feel of Electron”. Bun is used only for dev tooling and the web template, and native-UI projects don’t need it. 32-bit Windows and Linux are not supported. The license is MIT.

How AI built it

We counted the repository’s git history at commit c971c903 (2026-11-01 19:01 UTC+8):

Most trailers name “Claude Opus 5.5”, some “Claude Opus 5.5 (1M context)”. Codex, Amp and Cursor Agent show up a handful of times each. Several commit messages link Claude sessions. A trailer shows that an agent took part in a commit. It does not show how much of the code the agent wrote, so read these counts as a lower bound on AI involvement, not a share of the code.

The author is open about it on X:

• On September 27 he wrote: “I’m done using Rust for new desktop apps. My SSD is only 1TB (yes poor people exist), and while AI makes me code 10x faster, Rust slows down my iteration speed by 10x” (post).
• On October 27: “I created MyGo just three weeks ago, and it’s already the best desktop GUI framework for Go, unbelievable things are happening thanks to Opus 5.5” (post). The first commit is from September 26, about four and a half weeks earlier.
• In Chinese, he describes his agent setup as main, QA and review agents, all “claude opus 5.5” (post), and says he uses the Claude app to run an hourly scan for bug fixes on Kero and MyGo (post).
• On November 1: “MyGo skips the Rust tax. It’s young on paper, but it’s years of me building desktop apps plus AI-agent shipping speed. To me, it might as well be years old.” (post).

On cost, he wrote on October 14 that a $200 Claude Max plan’s weekly quota was “刚好够我用” (just enough for him), almost all on Opus 5.5 high, without scheduled tasks (post). On October 27 he wrote that he no longer used up a week’s Opus 5.5 high quota (post). These are personal reports. We have not checked them and they are not our price data.

The project also builds for agents. The native template we generated includes .agents/skills/mygo-maintenance/SKILL.md, a set of rules for coding agents that maintain a mygo app.

Quickstart

The README asks for Go 1.27.3 or later. The web template also needs Bun.

Web frontend:

bunx mygo-cli init my-app   # or: npx mygo-cli init my-app
cd my-app
bun run dev

Native UI only:

go run github.com/egoist/mygo/cmd/mygo@latest init -template native my-app
cd my-app
go tool mygo dev

The README’s native counter example:

type counter struct{ n int }

func (s *counter) view(c *ui.Context) {
	ui.Column(c).Fill().Center().Gap(12).Children(func() {
		ui.Text(c, fmt.Sprint(s.n)).FontSize(40).Bold()
		if ui.PrimaryButton(c, "Increment").Clicked() {
			s.n++
		}
	})
}

func main() {
	s := &counter{}
	mygo.App.WhenReady(func() {
		mygo.NewWindow(mygo.WindowOptions{Title: "Counter", Content: ui.View(s.view)})
	})
	if err := mygo.App.Run(); err != nil {
		log.Fatal(err)
	}
}

In web mode you bind a Go struct and call it from TypeScript. The README’s example binds Greeter{} with mygo.Bind, and the frontend runs await Greeter.greet("Ada") from a generated ./mygo module.

What we built on Linux

We used a Debian 13 box with 8 vCPUs, go1.27.3 and an X11 desktop without a GPU. Some of the Go module cache was already filled when the second test ran.

Test 1: cross-compiling the repo’s counter-native example at commit c971c903. We used CGO_ENABLED=0 go build -trimpath -tags mygo_noinspector -ldflags "-s -w -X github.com/egoist/mygo.production=1", with no C toolchain or SDK for the other systems.

We ran only the Linux binary. A “Counter” window opened. mygo logged “native UI draws without the GPU: there is none” and fell back to CPU drawing, and it also printed a GTK accessibility-bus warning because the box has no AT-SPI bus. Two clicks on “+” and three presses of the Up arrow took the counter from 0 to 5. One ps reading after that showed 45,820 KB resident memory. That is a single sample with CPU rendering and is not a benchmark.

Test 2: the README quickstart (native template, published v0.7.4). init took 13.7 s and created main.go, a main_test.go that tests the view without a window, mygo.json and the agent skill mentioned above. go test passed. go tool mygo build reported “Built my-app 0.1.0 in 5.2s” and produced a 9.6 MB binary, a 4.3 MB .deb, a tarball, a PKGBUILD, an install script and a .desktop file. go tool mygo build -platform windows/amd64,darwin/arm64 finished in 6.5 s with a 9.9 MB .exe and a 9.7 MB .app. It skipped the Windows installer because NSIS was missing and skipped the dmg because “it needs macOS”. We did not launch the template app.

Project claims we did not reproduce. The project’s own CI publishes release sizes for each push on its benchmarks page. At c971c903, counter-native was 9,615,040 bytes on Linux, 9,906,688 on Windows and 9,390,450 on macOS. The architecture doc says the counter example uses 65 to 67 MB on Linux in a specific 4K setup without Mesa loaded, and says native windows that have finished drawing go idle. The author posted that a fresh build plus a Windows installer took 21 seconds (post) and that a layout benchmark beat Taffy and Yoga (post). We did not test either.

Apps built with mygo

The author builds his own products on mygo, and the showcase page lists them. Descriptions below come from the showcase and the author’s posts. We did not install any of them.

He has also shown an Obsidian-style notes app that “Opus 5.5 one shotted… in an hour with MyGo” (post). It is a demo, not a released product.

Other developers have started using it too. The showcase lists MixMusic (YouTube Music and Spotify player), four apps by echoVic, mostly for macOS, built in web mode (留白 Liubai, Clipnest, Cleanzo, 小海底 Little Reef), the Git client MyTwig, the AI email client Godwit, Video-Downloader, Lumilo and Tomoru. On GitHub we also found meiro, a YouTube Music client on mygo v0.7.2 that is not in the showcase.

mygo vs Wails, Tauri, Electron and Fyne

This table uses each project’s own docs, checked on November 1, 2026. It compares design and requirements, not speed.

Sources: mygo architecture, Wails README and install guide, Tauri start and webview versions, Electron docs, Fyne quick start.

mygo’s position comes from two things. It offers both a webview and a native toolkit in one Go framework, and it avoids cgo, so one machine can cross-compile for all three desktops. Wails is closest in language and webview approach and is far more established, with v2.17.1 and v3.1.0 both released on November 1. Fyne is the established Go option for UI it draws itself, but it needs a C compiler. When the author introduced mygo in Chinese he called it “我的 Tauri/Wails 竞品” (my Tauri/Wails competitor) and listed its advantages over Tauri: builds in seconds, cross-compiling, less disk use, built-in delta updates and type-safe IPC (post). Those are his claims. Apart from cross-compiling and build time on our one machine, we have not tested them against Tauri.

Limits and risks

• It is very new. The first commit is from September 26, 2026, and the latest release is v0.7.4. Releases arrive every few days, and the bundled agent skill tells agents to read a migration guide on every 0.x minor bump. There were 82 open issues on November 1.
• Most of the code was written with an AI agent. That is how the project moves this fast. It also means the toolkit’s years of experience come from the author, not from long production use of this code.
• The webview is uneven across systems. Web mode depends on WebKitGTK on Linux and WebView2 on Windows, so rendering and web features differ by system. Linux uses GTK 3, and the architecture doc explains why it doesn’t use GTK 4.
• We tested one thing on one system. We have no GPU-rendering, macOS, Windows, web-mode, signing or auto-update results. The memory, size and benchmark claims above belong to the project.
• No mobile. If you need iOS or Android from the same code, Tauri 2 and Fyne state support for them, and mygo does not.

What this says about AI-built tools

mygo shows how much one experienced developer can ship with an AI agent in five weeks, and it keeps a clear record: the git trailers, the per-push size benchmarks and the agent skill shipped in every new project. The no-cgo claim and the cross-compile claim are easy to check, and both held up in our build.

Our take: mygo is worth trying for a small Go desktop tool, especially native-UI utilities like the author’s own. Treat it as v0.x software that changes weekly, check its webview behavior on each target system, and wait for more outside use before betting a large product on it.

Primary sources

• mygo repository and README
• mygo website, showcase, benchmarks
• Architecture doc
• Releases
• Launch post on X (2026-10-03)
• First introduction in Chinese (2026-10-01)
• Advantages over Tauri, author’s list
• “Thanks to Opus 5.5” post (2026-10-27)
• “Desktop apps are a solved problem” post (2026-11-01)
• Wails, Tauri, Electron, Fyne