Four Ways to Build Desktop Apps: Electron, Tauri, Wails, and MyGo

In 2026 there are four mainstream routes to “build a desktop app”: Electron, Tauri, Wails, and MyGo. Everyone has heard the names, but few can say precisely where they differ — after all, all of them turn code into a .app/.exe, and syntax differences are a table lookup away.

This article skips syntax. The real dividing line is one question: where does your UI run, and who draws it? The answer decides bundle size, memory footprint, required team skills, and which pitfalls you will hit. Every version number and figure below was verified against official release pages on 2026-11-08 — none of it is from memory.

One table, four frameworks

	Electron	Tauri	Wails	MyGo
Project started	2013	2019	2018	2026-09
GitHub Stars	123.8k	112.6k	37k	5.3k
Current version	v45.2.3	v2.12.5 stable (v3 in alpha)	v3.0.0 (stable since 2026-10-26)	v0.8.3
Backend language	JavaScript / TypeScript	Rust	Go	Go
Where the UI runs	Bundled Chromium	System WebView	System WebView	System WebView or GPU-drawn
Packaging	Ships a full browser	No bundled browser	No bundled browser	No bundled browser
Maturity	13 years, thickest ecosystem	Mature ecosystem	8 years, v3 rewrite just landed	6 weeks, API not frozen

The eye-catching column is MyGo — a six-week-old project sitting in the same table as three projects with eight years or more behind them. Read on.

The main line: where the UI runs, who draws it

The four frameworks sit on one spectrum, from “heaviest browser” to “lightest self-drawn”; the further right, the less it depends on what the OS already has:

The three Web-camp frameworks (Electron, Tauri, Wails — plus MyGo’s web mode) share one idea: reuse the Web skills you already have by putting your existing front-end code inside a desktop window. Between them the differences are engineering details, not paradigm shifts.

MyGo’s native UI mode is a different road: you write the UI in Go and a GPU draws it — every pixel painted by your own program, with neither a browser nor an instantiated system WebView. (I ran it; measurements below.)

So “which framework is fastest to develop” is a trick question. The Web camp is fast because you already know HTML/CSS/JS; the Go camp is fast because you already know Go and have Go code. Speed is relative to you, never absolute.

Framework by framework

Electron: heaviest, and the most worry-free

Electron’s logic has not changed in thirteen years: trade a full Chromium for “every user sees exactly the same thing”. Windows users run the same browser engine you do on your Mac; Safari quirks and per-distro WebView differences are not your problem. VS Code, Slack, and Discord all run on it.

• Pick it when: your team is front-end; the UI is complex or leans on the Web ecosystem (Monaco editor, WebGL, mature component libraries); bundle size and RAM are acceptable; you want the most mature auto-update, crash reporting, and packaging pipeline — its ecosystem is the thickest of the four.
• Skip it when: 80–100 MB installers and hundreds of MB of idle RAM are the norm. If all you want is “a local tool with a window”, shipping a whole browser is enormous waste. The current stable v45.2.x embeds Chromium 156 and Node 24.22 and tracks security patches promptly — but “ship a browser” remains the founding decision.

Tauri: the bundle-size and memory compromise

Tauri’s core move: do not ship a browser; borrow the one already on the user’s system (WKWebView on macOS, WebView2 on Windows, WebKitGTK on Linux). The cost: the rendering layer is not identical across platforms — the same CSS can render subtly differently in WKWebView versus WebView2, and the version spread of WebKitGTK across Linux distros is the community’s loudest complaint.

• Pick it when: front-end is your home turf but Electron’s bundle size is not; you need mobile — Tauri 2 ships stable iOS / Android support (Wails v3’s is still alpha), a unique advantage over Wails; Rust’s performance and safety guarantees help.
• Skip it when: the team has zero Rust experience and the tool is small; or you need pixel-identical rendering everywhere.
• One trend to watch: Tauri v3’s alpha introduced an official CEF runtime (tauri-runtime-cef, optionally bundling Chromium). If it lands, Tauri patches its own “rendering consistency” weakness and starts covering Electron’s turf too.

Wails: the Web shell for Go developers

Wails borrows the system WebView just like Tauri; the difference is the backend language: Wails uses Go, Tauri uses Rust. It plugs Go’s HTTP, database, and file-processing ecosystem straight into the desktop shell, with type-safe bindings generated between front end and back end.

Two weeks ago (2026-10-26), Wails v3.0.0 went stable — a full rewrite: a new services mechanism (Go structs generate TypeScript bindings automatically), Windows MSIX installers, macOS DMG plus App Store distribution, the full Linux set (AppImage / deb / rpm / Arch), and a pluggable in-app updater (GitHub Releases and other providers, cryptographic verification, atomic swap with rollback). v3.1.0 followed on 11-01.

• Pick it when: your backend is already Go — or you want it to be — and you still want a Web-technology UI. Eight years old, stable community, and you can expect stability from a stable-tagged release.
• Skip it when: your backend is not Go and will not become Go (choose Tauri); or you deeply depend on v2 plugins — v3 is a rewrite and the plugin ecosystem needs time to migrate.

MyGo: the only one that draws its own UI

MyGo is a new framework open-sourced by indie developer egoist on 2026-09-26 — 5.3k stars in six weeks, currently v0.8.3. It has two modes, and the second one is unique among the four:

• Web mode: same logic as the other three — front end in the system WebView, Go backend receiving calls through a generated TypeScript client.
• Native UI mode: write the UI in Go, drawn by the GPU — no HTML, no JS, and no WebView instance. Text rendering is handled by go-text/typesetting; the docs list theming, dark mode, localization, and accessibility support.

I ran it (macOS / arm64, measured)

None of the above is transcribed from docs — I compiled and ran both modes on macOS 26.5.2 / Apple Silicon (Go 1.27.3, MyGo v0.8.3):

Measured	Result
Does it depend on Wails?	No. Grepping “wails” across all 1,777 .go files in the module: zero hits; go list -m all closure has no wails — the independent-implementation claim holds
Does it really build without cgo?	Yes. CGO_ENABLED=0 go build succeeds, producing a 14 MB binary; the module has zero import "C"
Artifact size	native-app.app and web-app.app are 9.5 MB each (signed, arm64)
Any browser inside?	No. otool -L lists only libSystem / libresolv / CoreFoundation / Security; no Frameworks/ directory, no Chromium Helper
Does native mode really draw itself?	Yes. Metal rendering (CAMetalLayer plus its own shader.metal). Controlled experiment: running the native app spawns zero WebKit subprocesses, while the web app adds three (WebContent / GPU / Networking) — native mode genuinely never instantiates a WKWebView
The TS binding the front end receives	mygo generate emits a plain src/mygo.ts (types live in the mygo-runtime package’s dist/*.d.ts); the window’s darwin/arm64 · go1.27.3 comes from the Go side, and the clock is pushed from a Go event every second

Three details that must be stated or the claim misleads:

1. “No HTML/JS/WebView” holds only for native UI mode — web mode is a standard WKWebView with HTML/JS.
2. The accurate wording is “no WebView instance”, not “never touches WebKit”: the native process still dlopen-maps WebKit.framework (loaded unconditionally), it simply creates no WKWebView. Anyone reading vmmap output will see that line.
3. Go 1.27.3+ is required: on this machine’s 1.27.2 the CLI fails outright, so GOTOOLCHAIN=auto has to switch versions.
4. Do not infer a memory advantage from this test: RSS was about 94 MB native versus 98 MB web, and both sample app bundles were 9.5 MB. One sample cannot predict every application’s footprint.

What I could not cover, stated plainly: DMG packaging failed on my machine with hdiutil detach exit 16 (an environment problem — --skip-dmg produced the .app), and Linux and Windows are untested, so treat the cross-platform numbers as coming from the official CI.

Pick it when: you write Go and want a pure-Go app where “the UI is Go too”; the UI is simple while the logic is heavy (settings panels, monitoring widgets, internal tools); or you care about pure-Go cross-compilation. Skip it when: it is six weeks old at v0.8.x and the docs plainly say the API will still change; the ecosystem starts from zero — no component marketplace, no ready-made complex tables or editor components; the web mode’s supporting pieces (updater, distribution pipeline) are still on the way.

The concrete call: MyGo or Wails?

This is the pair Go developers hesitate over — both have Go backends, both can pair with a Web front end, both ship without a browser. The dividing line is clear:

Question	“Yes” →	“No” →
Must the UI reuse the Web ecosystem (component / chart / editor libraries)?	Wails	next row
Can you accept a six-week-old project with a freezing API?	MyGo (or its web mode)	Wails
Do you need batteries-included auto-update / signed distribution?	Wails	MyGo is worth a try
Do you want a pure-Go app with zero HTML/JS?	MyGo native mode	Wails

One honest warning: if your UI needs the front-end ecosystem, do not force it through MyGo’s native mode — you save one WebView and pay with the entire Web ecosystem. Native mode fits “simple UI, heavy Go logic, no browser” and is the wrong tool for complex Web-grade interfaces.

The full decision tree

Cost of getting started

• Electron: official npm create templates; near-zero learning cost for front-end teams.
• Tauri: front-end skills plus Rust basics — most people trip on the Rust toolchain, not the language; documentation widely considered the best of the four.
• Wails: knowing Go is enough to start with wails3 init; the docs cover multi-window, menus, trays, the updater, and per-platform distribution.
• MyGo: web mode starts with bunx mygo-cli init my-app; native mode with go run github.com/egoist/mygo/cmd/mygo@latest init -template native my-app, then go tool mygo dev for live reload, and mygo doctor to check the environment. The docs are surprisingly complete, down to automated testing and E2E. But remember: complete docs ≠ mature project — on a six-week-old codebase, your pitfalls have no prior answers to lean on.

Closing thoughts

No framework wins outright; they occupy four positions on one line — where the UI runs: Electron ships a browser, Tauri and Wails borrow the system WebView, and MyGo’s native mode draws everything itself.

MyGo’s arrival reads as a signal: the WebView dependency is becoming optional. Half a year ago, “desktop app = WebView + a backend language” was the industry default; now a six-week-old project has proven pure-Go UI rendering works. Meanwhile the official CEF runtime in Tauri v3’s alpha shows the borrow-the-system-WebView road is also being re-examined — some would rather bundle a browser for rendering consistency. Both directions are worth watching.

When choosing, answer two questions first: ① should the UI reuse Web skills and components? ② can you accept an unfrozen new project? The two answers place each framework in its quadrant; everything else — bundle size, memory, ecosystem depth — is downstream of them.

References

All versions and figures verified on 2026-11-08:

• Electron v45.0.0 Release Notes (Chromium 156 / Node 24.22)
• Tauri v2.12.5 · tauri-runtime-cef v3.0.0-alpha.7 · Tauri 2.0 Stable Release
• Wails v3.0.0 Released (2026-10-26) · Wails v3.1.0
• MyGo on GitHub · MyGo documentation