Wails: Desktop Apps with Go and Web Technologies

What Wails is

Wails is an MIT-licensed framework for building desktop applications with Go and web technologies. Application logic is written in Go, the interface is built with HTML, CSS and JavaScript or any frontend framework, and Wails renders it in the operating system's native webview. The README contrasts this with the traditional way of giving a Go program a web interface, a built-in web server: Wails instead wraps the Go code and the web frontend into a single binary, with tooling for project creation, compilation and bundling.

The README's FAQ says it is aimed at Go programmers who want to bundle an HTML/JS/CSS frontend with their applications without creating a server and opening a browser to view it. The name started as a play on "Webview on Rails" and happens to be a homophone of Wales, the author's home country.

Wails has two active major versions. Wails v3.0.0, a rewrite of the application API, was released as stable on October 26, 2026 after a long beta series, and is the version new projects should use. Wails v2 remains stable and, according to the FAQ, continues to receive critical updates.

How it works

A Wails application has two parts. The Go backend handles business logic and system operations and compiles to a native binary. The frontend is a normal web project rendered by the OS-provided WebView: WebView2 on Windows, WebKit on macOS and WebKitGTK on Linux. No browser engine or Node.js runtime is bundled into the app, which is where the project's small-binary and low-memory claims come from.

The two sides talk through a bindings layer. You register Go services with the application; when you run wails3 dev or wails3 build, Wails analyses those services and generates a type-safe TypeScript or JavaScript SDK in frontend/bindings/, so frontend code calls Go methods like ordinary async functions. Go can also send events and data back to the frontend through a unified eventing system. The docs describe the bridge as in-memory with sub-millisecond overhead.

Version 3 replaces v2's single-window, declarative API with a procedural one. An app is created with application.New, and windows, menus and tray icons are created and managed from code through objects such as app.Window, app.Menu and app.SystemTray. The project says this makes complex multi-window applications easier to read and write.

Key features

• Any frontend stack: templates for React, Vue and Svelte (TypeScript by default) plus vanilla JavaScript, with the option to bring your own framework.
• Generated TypeScript definitions: bindings for Go structs and methods are regenerated on every dev or production build.
• Multiple windows: each window has its own size, position, content and lifecycle, and can load embedded assets or an external URL.
• System tray: tray menus, light and dark icons, macOS template icons, and a window that can be attached to the tray icon.
• Native UI: native dialogs and menus, dark and light mode support, and translucency or "frosted window" effects.
• Built-in updater: app.Updater with providers for GitHub Releases, keygen.sh and Sparkle AppCast, cryptographic signature verification and a replaceable default UI.
• Packaging and signing: wails3 package produces platform-native formats (NSIS on Windows, .app bundles and DMGs on macOS, Linux packages), with guides for code signing and macOS notarization.
• Hot reload: wails3 dev rebuilds Go code and restarts the app on save.
• Server build: the same application can be served as a regular web app.

Getting started

Wails v3 needs Go 1.26 or later, Node.js and npm for the frontend build, and a platform toolchain. Install the CLI:

go install github.com/wailsapp/wails/v3/cmd/[email protected]

Then check the environment; wails3 doctor reports exactly which dependencies are missing:

wails3 doctor

On macOS the platform requirement is the Xcode Command Line Tools:

xcode-select --install

On Ubuntu 24.04+ or Debian 13+ the docs list:

sudo apt install build-essential pkg-config libgtk-4-dev libwebkitgtk-6.0-dev

Create and run a project, then build a production binary (it lands in bin/) and package it:

wails3 init -n myapp -t vanilla-js
wails3 dev
wails3 build
wails3 package

Projects that need v2 install a separate CLI named wails:

go install github.com/wailsapp/wails/v2/cmd/wails@latest

Use cases

• Developer tools: the docs list database clients, API testers and deployment tools as typical Wails apps.
• Internal and business apps: dashboards, admin tools and inventory or CRM front ends that need to ship as a desktop binary.
• A GUI for an existing Go program: keep the Go core and add a web UI without running a local HTTP server.
• Tray utilities: background apps with a tray icon and a pop-up window, using the v3 tray and window-attachment APIs.
• Productivity apps: note-taking tools, task managers and time trackers that benefit from small downloads and low memory use.

How it compares

The obvious comparison is Electron, and the README answers it directly: whether Wails is an alternative "depends on your requirements". It offers native menus and dialogs, so it can be considered a lightweight Electron alternative, but it is designed first for Go programmers. The "Why Wails" page claims roughly 15MB binaries versus Electron's 150MB, about 10MB baseline memory versus 100MB+, and startup under half a second versus two to three seconds; the FAQ puts a typical binary at around 10MB. Treat these as the project's own figures. The trade-off of using the system WebView is that the rendering engine differs per operating system, so the UI needs testing on each target. Other frameworks, such as Tauri, use a similar system-WebView approach with a different backend language; Wails is the natural pick when the backend is already Go.

Things to know before adopting

• Toolchain floor: v3 requires a Go 1.26 or later toolchain; a starter project's own go.mod does not lower that requirement.
• Linux support: the default stack is GTK4 with WebKitGTK 6.0 (Ubuntu 24.04+, Debian 13+, Fedora 40+). Ubuntu 22.04, Debian 12 and RHEL 9 need the legacy -tags gtk3 build, which the docs say will be removed in v3.1. Distributions that only ship WebKit2GTK 4.0 are not supported.
• Platform matrix: Windows on AMD64 and ARM64 via WebView2; macOS 10.15+ on Intel and 11.0+ on Apple Silicon, with universal binaries. iOS and Android are experimental and outside the stable desktop compatibility contract.
• Cross-compilation is limited: native webview libraries rule out plain Go cross-compilation; building Linux targets from another OS uses a Docker-based toolchain.
• Migration: v2 to v3 is an API change with a dedicated migration guide. The wails and wails3 CLIs and their module paths coexist on one machine.
• Experimental setup wizard: wails3 setup is new and mainly tested on Linux; the docs suggest wails3 doctor if it misbehaves.
• Licence: MIT, with no copyleft obligations for applications built with it.

Project activity

As of October 2026 the repository has about 36,800 stars and 1,910 forks. It was created in December 2018, is written in Go and is MIT-licensed. v3.0.0 was tagged on October 26, 2026, following v3.0.0-beta.34 on October 20, and v3.1 nightlies have already started. New functionality and public behaviour changes go through Wails Enhancement Proposals submitted as draft pull requests. Source is at github.com/wailsapp/wails, v3 documentation at wails.io and v2 documentation at v2.wails.io.