#Go
50 posts
Wails in Practice #10 Finishing Touches — Settings, Dark Mode, Data Backup
The final post of the series. Features are all there, but we fill in the touches that make the app worth reopening. Covers a structure for saving and loading settings, dark mode that follows the system, remembering window state, backup/export/import that keeps user data safe, and a recap of the principles running through all ten posts.
Wails in Practice #9 Implementing Auto-Update — Delivering a New Version Safely
Actually implement the auto-update that #6 only discussed as strategy. Covers stamping a version into the app and querying the latest from GitHub Releases, a safe notify-style implementation, why fully automatic replacement is risky and what it must uphold, and a version flow that does not clash with signing and CI.
Wails in Practice #8 A Testing Strategy — Verifying the Service and Repository
Actually write the tests promised back in #1 when we split the layers. Covers unit tests that verify service logic in pure Go without Wails, integration tests that verify the repository with a temporary SQLite, sweeping edge cases with table-driven tests, and wiring these into #6's CI so they run automatically before a release.
Wails in Practice #6 CI/CD Automated Releases — Three-Platform Delivery with GitHub Actions
Close the series by making a single tag generate a three-platform release automatically. Covers why macOS cannot be cross-compiled and forces a matrix build, a GitHub Actions workflow that builds and signs on per-platform runners, where pure-Go SQLite keeps CI simple, an auto-update strategy, and a full recap of the six posts.
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.
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.