Wails
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 #7 The Note Editor for Real — Markdown Preview and List UX
The first post of Part 2. We actually build the front half of the notes app, backend-heavy so far. Covers a preview that renders markdown safely, debounced autosave that fires when typing stops, keeping edits from shuffling the list order, and a list UX you can move through with the keyboard.
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 #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.