Framework
Wails in Practice #5 Signing and Notarization — How a Shipped App Earns Trust
Make the finished notes app run without warnings on other people's machines. Covers why an unsigned app is blocked by macOS Gatekeeper and Windows SmartScreen, the macOS code-signing and notarization (notarytool) procedure, the types and cost of Windows code-signing certificates, and what to know before handing this process to CI.
Wails in Practice #4 Tray Residence and a Global Shortcut — Capture Fast from the Background
Turn the notes app into a background app that stays alive after the window closes. Covers the fact that Wails v2 has no built-in tray and how to work around it, changing window close from quit to hide, implementing a global shortcut to capture a new note from anywhere, and how v3's built-in tray changes this.
Wails in Practice #3 Full-Text Search and Data Flow — FTS5 and Event-Driven Updates
Add fast full-text search to the notes app and settle the data flow. Covers SQLite FTS5 virtual tables and triggers that keep the search index in sync automatically, exposing search as a service in Go, and a design that keeps the truth in one place by refreshing the frontend with Wails events when data changes.
Building Desktop Apps with Wails #8 Debugging — Dev Tools, Logs, Common Errors
Gathers the spots beginners get stuck on most. Covers opening the WebView dev tools during development, reading logs on both the frontend and Go sides, diagnosing a built app with -debug, and the causes and fixes for common errors like a blank screen, binding not found, and a nil context.
Wails in Practice #2 SQLite Local Database — Pure Go, No CGO
Add persistence to the notes app. Covers the CGO trap that blocks cross-compilation when using SQLite in a Wails app and how the pure-Go driver modernc.org/sqlite sidesteps it, the repository layer implementation, schema and migrations, and CRUD with validation applied in the service layer.
Building Desktop Apps with Wails #7 Adding a Frontend Framework — Svelte, Vue, React
Swap the vanilla front half from the main series for a framework, for a real app whose state grows. Covers what it means that Wails is frontend-agnostic, starting Svelte/Vue/React with wails init templates, that the generated bindings are the same regardless of framework, and connecting binding results to framework state.
Wails in Practice #1 Designing a Real Project — What to Build and How to Split It
The first post of the Wails practice series. Going beyond the in-memory to-do app of the intro, we design a local notes app worth shipping: deciding what to build, drawing the boundary that splits the Go backend into a service layer, choosing a frontend state approach, and mapping the final form we complete across six posts.
Build a Desktop App with Wails #6: Build and Distribution — Packaging per Platform
Build a single binary with wails build and package it as a Windows installer, a macOS app bundle, and a Linux binary. The final part of the series, covering the cross-compilation constraint, GitHub Actions matrix builds, and the outlook for v3.
Build a Desktop App with Wails #5: Real-World Features — Persisting Settings and Error Handling
Persist the todo data as JSON under os.UserConfigDir and wire it into the startup and shutdown hooks. We also cover the flow where a Go error becomes a frontend notification, file logging, and why external API calls belong on the Go side.
Build a Desktop App with Wails #4: System Integration — Dialogs, Menus, and Window Control
Native file dialogs, application menus with shortcuts, window control, and the clipboard — integrating with the OS through the Wails runtime API. This is where a web frontend starts to feel like a desktop app.
Build a Desktop App with Wails #3: Connecting Go and the Frontend — Method Bindings and Events
Pinning down the binding rules in a table, building a todo-list backend in Go, and wiring it to a React frontend. Covers auto-generated TypeScript models for structs and the event system that pushes data from Go to the UI.
Build a Desktop App with Wails #2: Project Structure and the Dev Loop — wails dev and Bindings
Walking through what each of main.go, app.go, frontend, and wails.json does in a project created by wails init. Covers the hot-reload dev loop and how the auto-generated binding code flows.