Wails v3 Beta: a new foundation for Go desktop applications<br>Skip to content

Wails v3 Beta: a new foundation for Go desktop applications

Today we are releasing Wails v3 Beta.

Wails lets Go developers build desktop applications with the web frontend tools<br>they already know, using the native WebView on each platform rather than an<br>embedded browser. v3 is a substantial step forward: it gives applications a<br>more direct API, a clearer build model, and a better foundation for the desktop<br>applications people have been asking Wails to support.

This is a beta release, not the final 3.0 release. The desktop API is stable<br>and teams are already using v3 in production, but you should test thoroughly<br>before deploying. We are using the beta period to catch the final compatibility<br>and workflow issues with the community. Wails v2 remains the current stable<br>release and will continue to receive fixes.

Documentation during beta<br>Section titled “Documentation during beta”

During beta, we are maintaining the English documentation as the source of<br>truth while the API and workflows receive their final validation. We are not<br>accepting translation PRs at this stage. Translation work will resume before<br>general availability, once the documentation is stable enough for translators<br>to work without repeated churn.

What is in v3<br>Section titled “What is in v3”

An explicit application and window API, including first-class multi-window support

Go services with static source analysis that generates richer TypeScript bindings, preserving comments and meaningful parameter names

Services that can bundle frontend assets and scripts with their backend API - the foundation for installable, richer plugins

A visible, Taskfile-based build system you can inspect, extend, and debug

Server builds for running the same application and services without a native desktop window

Modern desktop support for macOS, Windows, and Linux on Intel, Apple Silicon, amd64, and arm64 where supported

Experimental mobile support for iOS and Android, available for exploration but outside the desktop beta compatibility promise

Why v3<br>Section titled “Why v3”

Wails v2 made it straightforward to build a Go application with a modern web<br>frontend. It has served the project - and a great many applications - well. But its<br>single-window, context-driven runtime and tightly managed build process made<br>some common desktop work harder than it should have been.

v3 starts from a different model. Applications, windows, services, events, and<br>platform capabilities are explicit objects. That makes the framework easier to<br>reason about as an application grows, and makes features such as multiple<br>windows a normal part of the application model rather than a workaround.

What is new<br>Section titled “What is new”

An application API built for real desktop software<br>Section titled “An application API built for real desktop software”

v3 replaces the v2 wails.Run(...) configuration style with an explicit<br>application lifecycle. You create an application, register services, create<br>windows, and interact with the objects that own the behaviour you need.

That removes a great deal of implicit context passing. Window operations belong<br>to windows; application-wide operations belong to the application. It is a more<br>natural model for multi-window applications and a better fit for testing and<br>maintaining larger codebases.

The feedback from people who used v3 during alpha has been overwhelmingly<br>positive. In particular, developers have responded well to the explicit model:<br>it makes the code easier to follow, makes ownership clearer, and gives complex<br>desktop applications room to grow without fighting the framework.

First-class multiple windows<br>Section titled “First-class multiple windows”

Multiple windows are a core v3 capability. Windows have their own lifecycle and<br>can be created, managed, and closed at runtime. The result is a clearer route<br>to the kind of desktop software that needs editors, inspectors, preferences,<br>tool windows, or several independent pieces of UI.

Services and generated bindings<br>Section titled “Services and generated bindings”

Go services replace the older binding model. They keep application logic as<br>ordinary Go code and make the boundary to the frontend explicit. Bindings are<br>generated into a structure that reflects the application and its services,<br>making it easier to find and use the API exposed to the frontend.

v3 generates those bindings with static source analysis. That means the<br>generator can retain the information developers put into their code - including<br>comments and meaningful parameter names - rather than discovering an already<br>built program through reflection. The result is a richer, more useful frontend<br>API and a generation process that is easier to understand and maintain.

Services can also mount frontend assets and scripts alongside their Go code.<br>That gives a capability one coherent home: its backend API, the JavaScript or<br>UI it needs, and the...