wailsapp/wails

This is a cross-platform desktop application framework that enables developers to build native desktop and mobile applications using web technologies and Go. It provides a comprehensive runtime for window management, system integration (notifications, clipboard, menus), and inter-process communication between the Go backend and frontend. The system includes a CLI tool for project scaffolding, building, and diagnostics, alongside a rich set of APIs for handling user input, file associations, and platform-specific features like macOS window tabbing or Windows DPI scaling.

78 changes.

This period focused on the comprehensive development of the Wails v2 framework, introducing a modular internal architecture and a simplified public API. It established deep, native support for Windows, macOS, and Linux, including system diagnostics, window management, and build asset generation. The work also standardized project templates, CLI tooling, and cross-platform features like menus, notifications, and file dialogs.

100 changes.

This period focused on the development of Wails v3, introducing extensive new APIs for windowing, services, and system integration across all supported platforms. The work included building out the v3 CLI, implementing mobile support for Android and iOS, and providing comprehensive examples for new features like context menus, file associations, and system tray icons.

80 changes.

This period focused on expanding Wails v3 capabilities with comprehensive mobile support for Android and iOS, alongside new services for notifications, dock icons, and in-app updates. The release was further enriched by numerous examples demonstrating advanced features like custom protocols, WebSocket transport, and system tray integration. Additionally, internal tooling was modernized with a Go-native build runner and automated changelog generation.

A new 'dev' example has been added to the v3 examples directory, providing a template for rapid frontend development workflows. This includes a Taskfile for managing build and run tasks, a main.go demonstrating the new application API structure, and associated build configuration files (Info.plist) for macOS. The example is marked as a work in progress and is not yet ready for general use.

v3/examples/dev · high confidence

The Android build configuration and runtime components have been added, enabling Wails v3 applications to be built and run on Android. This includes the Gradle-based build system (Taskfile, Gradle wrapper), the AndroidManifest.xml, and the Java/Kotlin bridge classes (MainActivity, WailsBridge, WailsJSBridge) that connect the Go backend to the Android WebView. The entry also covers the dependency installation script and resource files required for the Android target.

_v3/examples/android/build/android, v3/internal/commands/build\assets/android · high confidence

A new Android example has been added to the Wails v3 codebase, providing a complete template for building Android applications. The addition includes the Go entry points (main.go, main\_android.go, greetservice.go) that initialize the Wails application, register the Android-specific main function, and bind a Go service. It also includes a Taskfile.yml to automate building, running, and packaging the Android app, along with a README.md and .gitignore to support the Android build workflow.

v3/examples/android, v3/examples/notifications/frontend · high confidence

The Android frontend example now includes a complete UI built with the Puppertino CSS framework, providing styled components for buttons, forms, and cards. The example integrates with the Wails v3 runtime by adding generated JavaScript bindings for Go services and event handling. The Vite configuration has been updated to resolve the local Wails runtime sources and configures the development server port via the WAILS\_VITE\_PORT environment variable.

v3/examples/android/frontend · high confidence

A new example application has been added to demonstrate the Environment API. The example displays system information such as OS name, version, and architecture by fetching data via the JavaScript runtime API and rendering it in a web view. The Go entry point configures the application with bundled assets and a translucent title bar, while the HTML/JS client-side code queries the environment details and populates an HTML table with the results.

v3/examples/environment · medium confidence

Added two new examples demonstrating how to integrate the Gin web framework with Wails. The 'gin-routing' example shows how to use Gin as the primary HTTP handler and router, including middleware and static file serving. The 'gin-service' example demonstrates how to run Gin within a Wails service, exposing a RESTful API with user management endpoints and event communication. Both examples include README documentation and frontend assets.

v3/examples/gin-service · high confidence

A new example demonstrating how to integrate the Gin web framework with Wails is added to v3/examples/gin-example. The example shows how to configure Wails to use a Gin HTTP router as the asset handler, implement a custom middleware to route requests between Wails and Gin, and communicate between the Gin-served frontend and Wails backend.

v3/examples/gin-example · high confidence

The v2/internal/github package now includes new functionality to fetch release notes from the GitHub API and retrieve sorted version tags. This introduces the ability to display formatted release notes in the terminal using the glamour library, and provides utilities to list, sort, and compare semantic versions (including pre-release and stable releases) from the Wails repository.

v2/internal/github · high confidence

The Wails v3 framework now includes generated JavaScript bindings for the Hashes, Key-Value Store, Logging, and SQLite services, enabling direct interaction with these features from the frontend. The update also provides a complete example application that demonstrates how to use these services, including a UI for generating hashes, managing key-value pairs, logging messages at various levels, and executing SQL queries.

v3/examples/services/assets · high confidence

The iOS example application now includes a complete Linux build configuration. This adds a Taskfile to manage the build process, scripts to generate AppImages and Linux packages (deb, rpm, arch), and configuration files for nfpm. The build environment is configured to depend on GTK4 and WebKitGTK 6.0, ensuring compatibility with modern Linux distributions.

v3/examples/ios/build/linux · high confidence

Introduces the complete Linux desktop frontend implementation for Wails v2, enabling the framework to run on Linux. This includes the core frontend logic (frontend.go), window management (window.go, window.c), and UI components such as menus (menu.go, gtk.go), dialogs (dialog.go), clipboard (clipboard.go), notifications (notifications.go), and single-instance handling (single\_instance.go). The implementation integrates with GTK and WebKit2GTK to provide native windowing, menu, and dialog capabilities on Linux.

v2/internal/frontend/desktop/linux · high confidence

Introduced the \libpath\ package for Linux to locate native shared libraries (\.so\ files) by searching \pkg-config\, \ldconfig\, and common filesystem paths. The implementation includes platform-specific logic for Flatpak, Snap, and Nix package managers, with a caching layer to avoid repeated filesystem and subprocess calls. Non-Linux platforms receive stub implementations that return \LibraryNotFoundError\. A public \InvalidateCache()\ function allows clearing the cache when packages are installed or removed at runtime.

v3/internal/libpath · high confidence

The \wails doctor\ command now detects and supports multiple Linux package managers, including APT, DNF, Pacman, Zypper, Emerge, Eopkg, Nixpkgs, Xbps, and Xbps. This allows the doctor command to correctly identify and report on the status of required system dependencies on various Linux distributions, ensuring accurate dependency checks and installation instructions for each package manager.

v2/internal/system/packagemanager · high confidence

A new example application in v3/examples/liquid-glass demonstrates the native Liquid Glass effect on macOS. The demo showcases various window styles (Light, Dark, Vibrant, Tinted, Sheet, HUD, and Content Background) and customization options including corner radius and tint color, providing a practical reference for implementing macOS-specific glass effects in Wails v3.

v3/examples/liquid-glass · high confidence

A new example at v3/examples/mcp demonstrates how to build a Wails application controllable by LLM agents via the Model Context Protocol. The example includes a Go main file that registers a demo service and a frontend with interactive widgets (counter, greeting input, drag-and-drop, scrolling list) that can be driven by MCP tools. The MCP server is enabled via the 'mcp' build tag, allowing clients like Claude Code to connect to the server at http://127.0.0.1:9099/mcp.

v3/examples/mcp · high confidence

Users can now configure macOS-specific window styling and behavior. This includes setting the window appearance (e.g., dark, light, vibrant, or high-contrast modes) via the new \Appearance\ option. Titlebar customization is expanded with \TitleBar\ options to hide, make transparent, or use an inset style. Additionally, users can enable a translucent window background, disable the Escape key from exiting fullscreen, and configure WebKit preferences such as tab focus, text interaction, and a custom user-agent application name.

v2/pkg/options/mac · high confidence

The v3/examples/screen directory now includes a new example application that demonstrates the Screen API. It detects all attached screens and displays their details, including bounds, work areas, and scale factors. The example registers a ScreenService that utilizes the application's ScreenManager to retrieve screen information and perform coordinate transformations between physical and device-independent pixels (DIP). This provides a reference implementation for handling multi-monitor setups and high-DPI displays.

v3/examples/screen · high confidence

The v3/examples/badge/frontend directory now contains a complete, runnable example of a Wails application built with TypeScript and Vite. This includes the HTML entry point, TypeScript source code for badge management, and a Vite configuration that allows the development server port to be controlled via the WAILS\_VITE\_PORT environment variable. The example also incorporates the Inter font and associated styling to provide a polished user interface for setting and removing application badges.

v3/examples/badge/frontend · high confidence

A new URL validation utility has been added to the frontend utilities, introducing a function that sanitizes and validates URLs before use. The implementation enforces strict security policies by blocking dangerous schemes (javascript, data, file, ftp), rejecting malformed URLs, and preventing injection attacks via control characters, shell metacharacters, and unicode anomalies. This change ensures that only safe, well-formed URLs are processed by the application.

v2/internal/frontend/utils · high confidence

A new WML (Wails Markup Language) demo example has been added to the repository, providing a reference implementation for using the experimental WML feature, which enables HTMX-style calls to the Wails JS API. The example demonstrates the new manager pattern for application setup, including event handling for button presses and hover states, and utilizes the updated asset server configuration.

v3/examples/wml · high confidence

A new WML demo application has been added to the examples directory. This includes a complete HTML/CSS/JS frontend that demonstrates Wails' capabilities, featuring a dark-themed UI with styled buttons and a logo. The demo integrates with the Wails runtime to interact with the Go backend, showcasing features like opening URLs and files, and handling dialog responses.

v3/examples/wml/assets · high confidence

A new example application demonstrating how to configure global and window-specific key bindings using the Wails v3 API. The example shows how to register keyboard shortcuts that trigger file dialogs and dev tools, illustrating the updated \application.App\ and \application.WebviewWindowOptions\ interfaces.

v3/examples/events-bug · high confidence

A new example application for Wails v3 demonstrating desktop notifications, including a Go backend that registers a notification service and a demo asset service to provide a sample image for attachments. The example includes a README with setup instructions, a Taskfile for building and running the app, and a main.go entry point that configures the Wails application with the notification service and asset handler.

v3/examples/notifications · high confidence

The Wails development environment now uses a WebSocket connection to the backend for inter-process communication (IPC) instead of the previous method. This change introduces a new runtime bridge that establishes a persistent WebSocket connection to \/wails/ipc\, handling message queuing, reconnection logic, and command dispatch (notifications, callbacks, and hot-reload triggers). A visual overlay with a loading spinner is displayed during connection attempts or when the backend disconnects, improving the user experience during development.

v2/internal/frontend/runtime/dev · high confidence

A new example application, webview-api-check, has been added to test and report which Web APIs are available in the current WebView engine. The tool runs a comprehensive suite of tests across categories such as Storage, Network, Media, Graphics, and Device APIs, then displays the results in a dark-themed UI. It supports Linux (GTK4/GTK3), Windows (WebView2), and macOS (WKWebView), allowing users to compare API availability across platforms and export JSON reports for each environment.

v3/examples/webview-api-check · high confidence

Added a new example in v3/examples/window-api that demonstrates how to use the JS Window API. The example includes a README with instructions to run the example using Go, and an HTML/JS frontend that interacts with the windowing system. This provides a concrete reference for developers looking to implement window management features in their Wails applications.

v3/examples/window-api · high confidence

The winc Windows GUI library is added to the codebase, providing a set of Windows-specific controls and windowing primitives for the desktop frontend. This includes implementations for forms, buttons, edit fields, canvas drawing, and system dialogs, enabling native Windows UI rendering.

v2/internal/frontend/desktop/windows/winc · high confidence

The v2 package now includes a new \webview2runtime\ module for Windows that handles the installation and management of the Microsoft Edge WebView2 runtime. This module provides functions to download the WebView2 bootstrapper, run the installer, and verify the installed version against requirements. It also includes utilities for displaying Windows message boxes and opening the WebView2 download page in a browser.

v2/internal/webview2runtime · high confidence

The Windows frontend now supports reading and writing text to the system clipboard, enabling copy/paste functionality for text content. Additionally, the update introduces support for Windows dark mode, allowing the application to detect and apply the system's current theme (light or dark) to the window title bar and background, as well as enabling system backdrop translucency on supported Windows versions.

v2/internal/frontend/desktop/windows/win32 · high confidence

Added a new example project at v3/examples/badge-custom that demonstrates how to use the Windows badge service to customize the application tile icon. The example shows how to configure badge options such as text color, background color, and font settings, and provides Go and JavaScript code for setting, customizing, and removing badges on the Windows taskbar.

v3/examples/badge-custom · high confidence

The webview2 module has been refactored into v3/internal/webview2, introducing a new internal/w32 package that provides low-level Windows API bindings (e.g., user32, kernel32, shlwapi) and a combridge package that enables Go objects to implement COM interfaces. This includes new types and constants for Edge WebView2 (e.g., COREWEBVIEW2\_COLOR, ICoreWebView2Controller), allowing the application to interact with the underlying Windows COM components and handle events like accelerator key presses and cursor changes.

v3/internal/webview2 · high confidence

A new asynchronous FIFO mailbox implementation has been added to the internal package, allowing concurrent senders to queue messages that are processed in the exact order they were sent. This ensures that custom event handlers receive messages sequentially without blocking the senders, with a test confirming that concurrent sends are processed in order and that no messages are lost or duplicated.

v3/internal/mailbox · high confidence

A new cleanup utility has been added to the v3/tasks/cleanup directory. This tool automatically removes test-related files and directories, including Go test binaries, package artifacts (ARCHLINUX, DEB, RPM), CLI test binaries, and template directories, while skipping the .git directory.

v3/tasks/cleanup · high confidence

A new Go example at v3/examples/autostart shows how to use the application API to manage autostart settings. The example provides menu items to enable, disable, and check the status of the autostart feature, illustrating the cross-platform autostart manager capabilities.

v3/examples/autostart · medium confidence

The bindings example now includes a Go service (GreetService) and a data struct (Person) that demonstrate how to expose Go methods and types to the frontend. The example shows binding a service with variadic parameters, complex types like time.Time, and embedding assets for the generated bindings. The main.go file registers the service and configures the application with DevTools enabled.

v3/examples/binding · high confidence

The file association example now includes a complete set of build configuration files, including \Taskfile\ definitions for Windows, macOS, and Linux, along with platform-specific metadata files like \Info.plist\ and \info.json\. This provides the necessary scaffolding to build and package the application on each supported platform.

v3/examples/file-association/build · high confidence

The badge-custom example now includes a complete build system. This adds a Taskfile to manage frontend dependencies and builds, platform-specific build tasks for macOS (Darwin), Linux (AppImage, deb, rpm, AUR), and Windows (NSIS installer), along with necessary configuration files like Info.plist, nfpm.yaml, and NSIS scripts to support building and packaging the application on each platform.

v3/examples/badge-custom/build · high confidence

The build example now includes a Taskfile.yml that defines tasks for building, packaging, and generating icons for Mac and Windows, along with supporting asset files (Info.plist, info.json, wails.exe.manifest) and a main.go demonstrating the updated Wails v3 API, such as using \application.Window\ and \SetRelativePosition\.

v3/examples/build · high confidence

The buildtags package introduces new utility functions to parse Go build tags from string inputs and convert tag slices back into comma-separated strings. The Parse function supports both comma and space delimiters, ensuring that mixed delimiters are rejected, while Stringify formats a slice of tags for use with the go build -tags flag. A corresponding test suite validates these behaviors.

v2/pkg/commands/buildtags · high confidence

New examples demonstrating how to cancel binding calls in async/await style are added to the Wails v3 examples. The \cancel-async\ example includes a README, auto-generated JavaScript bindings (\index.js\, \service.js\), and an HTML entry point (\index.html\) that showcases the cancellation functionality.

v3/examples/cancel-async, v3/examples/cancel-chaining · high confidence

The internal changelog package now provides a complete pipeline for processing changelog files. The new \Processor\ coordinates a \Parser\ and a \Validator\ to parse markdown content into structured \ChangelogEntry\ objects and verify their formatting. This includes support for standard sections (Added, Changed, Fixed, Deprecated, Removed, Security) and enforces strict formatting rules, such as requiring valid section headers and non-empty bullet points. The change also introduces comprehensive unit tests for the parser, validator, and the main processor.

v3/internal/changelog · high confidence

A new clipboard example has been added to the v3 examples directory. It demonstrates how to use the clipboard API to set, get, and clear text content via a custom application menu. The example is marked as working on Mac and Windows platforms.

v3/examples/clipboard · high confidence

A new Go program and template have been added to the \v2/pkg/menu/colours\ directory. This tool fetches color data from an external JSON source and uses a Go template to generate a \cols.go\ file containing structured color definitions (RGB, HSL, hex, and name) for the menu system.

v2/pkg/menu/colours · high confidence

The logutils package now includes new helper functions (LogGreen, LogRed, LogDarkYellow) that format log messages with ANSI color codes, enabling the CLI to display structured, color-coded output for different log levels or modules.

v2/cmd/wails/internal/logutils · high confidence

The v3/examples/contextmenus directory now includes a complete example showing how to create and register context menus. The example demonstrates registering a context menu with both the window and the application, attaching it to HTML elements using CSS custom properties (e.g., \--custom-contextmenu\), and passing data to the menu callback via \--custom-contextmenu-data\. The Go code in \main.go\ shows how to build the menu, handle clicks, and update menu items dynamically.

v3/examples/contextmenus · high confidence

Introduced a new \dock\ service in \v3/pkg/services/dock\ that provides a unified API for managing application dock icons and badges across Windows, macOS, and Linux. On Windows, the service renders custom badge icons using GDI+ and the Windows Taskbar API. On macOS, it uses native Cocoa calls to hide/show the dock icon and set badge labels. On iOS and Linux, the service provides stub implementations, as these platforms do not support these specific UI elements in the same way. The service includes a \BadgeOptions\ struct for customizing badge appearance on Windows.

v3/pkg/services/dock · high confidence

The customlayout example in the frontend now includes dedicated CSS files (app.css, style.css) and a main.js entry point that renders the UI and handles the 'Enter' key press to trigger the Greet function, providing a complete, styled example of a custom layout.

v2/examples/customlayout/myfrontend · high confidence

A new example demonstrating how to handle application launch events via custom protocols is added to the v3/examples/custom-protocol-example directory. The Go code registers a listener for the 'ApplicationLaunchedWithUrl' event, which allows the application to process URLs passed to it at launch time and emit the URL to the frontend. The example also includes a basic greeting service, a time-emitting background goroutine, and build configuration files (Taskfile.yml, .gitignore) to support the demo.

v3/examples/custom-protocol-example · high confidence

A new drag-and-drop example has been added, demonstrating how to handle files dragged from the operating system into a Wails application. The example configures the window with \EnableFileDrop: true\ and listens for the \WindowFilesDropped\ event, which provides access to dropped file paths and drop target details (element ID, CSS classes, and coordinates). It also includes an internal HTML5 drag-and-drop demo. The example is supported on Mac, Windows, and Linux.

v3/examples/drag-n-drop · medium confidence

A new HTML page has been added to the examples/events/assets directory. This page demonstrates how to receive and display events from the main program, as well as how to emit events from the browser using the wails.Events API.

v3/examples/events/assets · high confidence

Added an events example that demonstrates the new events API, including custom event handling, OS-specific application events (such as ApplicationStarted and ThemeChanged), and platform-agnostic events. The example also showcases the use of RegisterHook to capture and cancel events like WindowClosing and WindowFocus, providing a practical reference for integrating these capabilities.

v3/examples/events · high confidence

The v3/examples/file-association directory has been added, providing a complete example of how to associate a custom file type (.wails) with the application. The example includes the necessary Go code in main.go to handle the ApplicationOpenedWithFile event, a Taskfile for building and packaging across Windows, macOS, and Linux, and supporting files like .gitignore and a README. This allows users to see how to register file associations and process incoming file paths in a v3 application.

v3/examples/file-association, v3/examples/global-shortcuts · high confidence

A new example application is added at v3/examples/file-input that demonstrates file selection capabilities. It tests standard HTML file inputs (single file, multiple files, and directories) alongside the Wails Dialog API for native directory selection and filtered file selection. The example includes Go backend code using the application and dialog APIs, JavaScript bindings for the Wails runtime, and an HTML/JS frontend that showcases these interactions.

v3/examples/file-input · high confidence

A new example demonstrating frameless windows has been added to the v3 examples. It utilizes the updated App API, specifically the \application.New\ constructor and \WebviewWindowOptions\ with \Frameless: true\. The example also includes a \README.md\ file and configures asset handling using \BundledAssetFileServer\.

v3/examples/frameless · medium confidence

The v3/examples/frameless/assets/index.html file was added to demonstrate window management capabilities in a frameless window. The example includes buttons to minimize, close, and toggle the frameless state of the window, as well as draggable regions. This provides a practical reference for developers implementing custom title bars and window controls in their applications.

v3/examples/frameless/assets · high confidence

The binding example now includes auto-generated JavaScript files (index.js, greetservice.js, data/models.js) that expose the Go backend to the frontend. This enables TypeScript/JavaScript code to call backend methods like Greet and GetPerson, with proper type definitions and runtime integration for handling complex types such as Date objects.

v3/examples/binding/assets/bindings · high confidence

A new hashes service example has been added to the v3 examples, providing a Go implementation that generates MD5, SHA1, and SHA256 hashes for a given string. This introduces a new service component that users can reference for implementing similar cryptographic hashing functionality in their own applications.

v3/examples/services/hashes · high confidence

A new example application is added that demonstrates how to manage window visibility and system tray interactions. The app creates a hidden window that can be shown via a system tray click or a menu item, and handles the macOS-specific 'ApplicationShouldHandleReopen' event to show the window when the dock icon is clicked.

v3/examples/hide-window · medium confidence

Added the \v3/internal/go-common-file-dialog\ package, which provides Go bindings for the Windows Common File Dialogs. This includes support for Open, Open Multiple Files, Select Folder, and Save File dialogs, along with a utility package (\cfdutil\) for simplified usage. The implementation relies on the \go-ole\ library for COM interface interactions and includes stubs for non-Windows platforms that return an error. This change introduces the underlying mechanism for file selection on Windows.

v3/internal/go-common-file-dialog · high confidence

The repository introduces a new internal package, v2/internal/s, which provides a suite of file and directory manipulation utilities. This includes functions for renaming, deleting, and copying files and directories, as well as changing the current working directory, creating directories, and executing shell commands. The package also offers a logging mechanism that can be muted or un-muted, and exposes an output writer for controlled console output.

v2/internal/s · high confidence

A new example demonstrates how to use keybindings in your application. Run the example and press Ctrl/CMD+Shift+C to center the focused window. The example is marked as working on Mac and Windows.

v3/examples/keybindings · high confidence

A new \keys\ package has been introduced to handle keyboard shortcuts (accelerators) for menu items. It provides a \Parse\ function to convert string shortcuts (e.g., 'Ctrl+Shift+A') into structured \Accelerator\ objects, supporting modifiers like \CmdOrCtrl\, \OptionOrAlt\, \Shift\, and \Control\. The package also includes \Stringify\ to format these accelerators into platform-specific strings (e.g., 'Cmd+A' on Mac, 'Ctrl+A' on Windows/Linux) and \ToMacModifier\ to convert accelerators into macOS event modifier flags. Tests cover parsing valid and invalid shortcuts, as well as stringification across Windows, Mac, and Linux platforms.

v2/pkg/menu/keys · high confidence

Introduces the complete macOS implementation for the Wails v2 frontend, including Objective-C wrappers for window management, menus, dialogs, and notifications, along with the Go bridge layer that exposes these native capabilities to the Wails runtime.

v2/internal/frontend/desktop/darwin · high confidence

Users can now generate macOS DMG disk images directly from the tool. This new feature allows creating compressed DMG files on macOS, supporting custom background images and icon positioning for a polished distribution package.

v3/internal/commands/dmg · high confidence

A new example application, v3/examples/badge, has been added to demonstrate how to use the macOS Dock Service. This example shows how to set and remove application badges (numeric or text) on the app icon, providing a practical reference for implementing badge notifications in Wails v3 applications.

v3/examples/badge · high confidence

Introduces a new example application demonstrating the macOS dock service, including the frontend TypeScript bindings for hiding/showing the app icon and setting badges, alongside the necessary build configuration files (Taskfiles, plist configs, NSIS installer scripts, and Windows MSIX manifests) to build and package the application across all supported platforms.

v3/examples/dock · high confidence

A new example application, show-macos-toolbar, has been added to demonstrate the new \ShowToolbarWhenFullscreen\ option. This feature allows the macOS system toolbar to remain visible when a window is in fullscreen mode, providing a specific UI behavior for Mac users.

v3/examples/show-macos-toolbar · high confidence

Added new macOS-specific utility functions for Wails applications. The \mac\ package now includes \StartAtLogin\ and \StartsAtLogin\ to manage the application's presence in the system's login items, and \ShowNotification\ to trigger native desktop notifications. These features rely on \osascript\ and are available for Darwin (macOS) builds.

v2/pkg/mac · high confidence

A new Go package for macOS (darwin) is introduced, providing a Go wrapper to retrieve the application's bundle identifier via Objective-C interop.

v3/pkg/mac · high confidence

Added a new example application in v3/examples/print that demonstrates the macOS print dialog functionality. The example includes a Go backend (main.go) that registers a PrintService and handles the File \> Print menu item and Cmd+P accelerator to trigger printing. The frontend (assets/index.html) provides a UI with buttons to trigger both the Go API and the runtime Window.Print() method, allowing users to verify that the print dialog opens correctly on macOS.

v3/examples/print · medium confidence

The file explorer module now provides a new \OpenFileManager\ function that launches the native file manager on each platform. On Windows, it uses \explorer.exe\ with \/select\ for files; on macOS, it uses \open -R\; on Linux, it queries the default file manager via \xdg-mime\ and parses the associated \.desktop\ file to construct the correct command, falling back to \xdg-open\ if necessary. A lightweight \ParseDesktopFile\ parser replaces the previous \gopkg.in/ini.v1\ dependency, and comprehensive tests are added to verify cross-platform behavior.

v3/internal/fileexplorer · high confidence

The v3/internal/operatingsystem package now provides platform-specific OS information retrieval for Windows, macOS, Linux, and Android, exposing ID, name, version, and branding details. Additionally, Linux builds can detect the installed WebKitGTK version (supporting both GTK3/WebKit2GTK-4.1 and GTK4/WebKitGTK-6.0 builds) to enable version-aware logic in the application.

v3/internal/operatingsystem · high confidence

The \v2/internal/system/operatingsystem\ package is introduced to provide a unified interface for retrieving operating system details. It defines an \OS\ struct containing \ID\, \Name\, \Version\, and \Branding\ fields. Platform-specific implementations are added for each major OS: macOS (using \sysctl\ to fetch \kern.osversion\ and \kern.osproductversion\), Linux (parsing \/etc/os-release\), and Windows (reading registry keys for product name, build number, and branding). This enables the application to accurately identify and display system information across all supported platforms.

v2/internal/system/operatingsystem · high confidence

A new example in v3/examples/panic-handling shows how to register a custom PanicHandler to catch and display panics via a dialog box, with supporting HTML and Go source files.

v3/examples/panic-handling · high confidence

A new plain example has been added to the v3 examples directory, showcasing how to create a Wails application without npm by using raw HTML and CSS. The example demonstrates configuring the application with custom asset handling, creating multiple windows with inline HTML and CSS, and handling custom events via the application's event system.

v3/examples/plain · high confidence

A new example demonstrates sending raw messages from JavaScript to Go, now including origin details (origin, top origin, and main frame status) in the handler.

v3/examples/raw-message · high confidence

The screen example now includes a new set of static assets (HTML, CSS, and JavaScript) that provide an interactive demo for the Screens API. The JavaScript file \examples.js\ defines a collection of test cases and edge cases for screen layouts, which are rendered in the \index.html\ UI. This allows users to visualize and interact with different multi-monitor configurations and coordinate transformations directly in the example application.

v3/examples/screen/assets · high confidence

A new 'sed' task has been added to the v3 tasks, providing a CLI tool that recursively searches directories for files with specified extensions and replaces all occurrences of a given string with a new one. The tool supports filtering by file extension, ignoring specific filenames, and processes files in-place.

v3/tasks/sed · high confidence

Added a new example in v3/examples/server that demonstrates running a Wails application as a headless HTTP server without a native GUI. The example includes Go code (main.go) that configures the application for server mode, a frontend (index.html) for browser interaction, and supporting files (Dockerfile, Taskfile.yml, README.md) to build and run the server. This enables users to deploy Wails apps as web services, accessible via HTTP and WebSocket, with features like health checks and event broadcasting.

v3/examples/server · high confidence

A new example application has been added to demonstrate the Wails v3 services API. The example configures and registers multiple built-in services—including a hash generator, SQLite database, key-value store, logger, and file server—showing how to initialize and use these capabilities within a Wails application.

v3/examples/services · high confidence

A new example in v3/examples/single-instance shows how to ensure only one instance of the application runs at a time. The example configures a unique identifier and registers a callback to handle second-instance launches, receiving command-line arguments, working directory, and additional data from the new process. The Go code sets up the single-instance lock, while the embedded HTML/JS listens for a 'secondInstanceLaunched' event to update the UI with the second instance's information.

v3/examples/single-instance · medium confidence

A new standalone example for the v3 notifications feature has been added to the frontend distribution. The example demonstrates sending notifications with sounds, attachments, and actions, including support for threaded notifications, scheduled delays, and custom builders. The UI includes controls for authorization, quick tests (basic, complex, threaded, scheduled, update, cancel), and a custom builder form allowing users to configure title, body, subtitle, thread ID, sound, interruption level, and attachments. The frontend assets (JavaScript, HTML, CSS, and SVG) are now included in the dist folder, enabling users to preview the notifications functionality in a browser environment.

v3/examples/notifications/frontend/dist · high confidence

A new static analysis package has been introduced to parse Go source files and extract \//go:embed\ directives. The \GetEmbedDetails\ function scans the project's Go files, identifies embedded paths, and returns a structured list of \EmbedDetails\ containing the base directory, the embedded path, and whether the \all:\ prefix is used. This enables the build system to understand which directories are required for static assets.

v2/internal/staticanalysis · high confidence

The menumanager now supports application menus, context menus, and tray menus. This introduces new internal structures to process and manage these different menu types, including handling click events, radio groups, and tray-specific properties like labels, fonts, and tooltips.

v2/internal/menumanager · high confidence

The \v2/internal/system\ package now provides a unified way to scan the host machine for required and optional dependencies. On macOS, it detects Xcode command-line tools, Xcode, Node.js, npm, UPX, and NSIS. On Linux, it checks for GCC, pkg-config, Node.js, npm, Docker, UPX, NSIS, and GTK/Webkit libraries. On Windows, it verifies the presence of WebView2, Node.js, npm, UPX, and NSIS. This enables the \wails doctor\ command to provide accurate, platform-specific diagnostic information about the development environment.

v2/internal/system · high confidence

Introduces a new 'systray-basic' example that creates a simple system tray icon with an attached window. The window is hidden by default and toggled by left-clicking on the systray icon. The window will hide automatically when it loses focus. On Windows, if the icon is in the notification flyout, then the window will be shown in the bottom right corner.

v3/examples/systray-basic · high confidence

A new example named 'systray-custom' has been added to the Wails v3 examples directory. This example demonstrates how to create a system tray icon that toggles a custom window. The window is hidden by default and can be shown or hidden by clicking the system tray icon. The example includes a README file explaining the functionality and a main.go file that sets up the application, system tray, and window management.

v3/examples/systray-custom · high confidence

Added a new stress-test example for Windows systray functionality, designed to reproduce and verify fixes for handle-leak and crash issues in SystemTray.SetMenu and OpenMenu. The harness exercises various workloads (churn, show, mutate) to ensure that menu rebuilds and bitmap attachments do not leak GDI or user objects, confirming that the underlying Windows syscall fixes (such as passing HMENU to DestroyMenu) are effective.

v3/examples/systray-stress · high confidence

A new video example has been added to the v3/examples/video directory, providing a working demonstration of HTML5 video playback. The example configures a window with embedded HTML containing video sources and sets up basic application event handling for macOS.

v3/examples/video · high confidence

The v3/examples/window directory now includes a complete example demonstrating window positioning, sizing, and bounds management, alongside a new 'ignore-mouse' example that shows how to disable or enable mouse events on a window. The window example also demonstrates configuring window buttons (minimize, maximize, close) and enabling content protection.

v3/examples/window · high confidence

Introduces a new 'window-call' example that demonstrates how to identify the calling window within a service method. The example includes a Go backend (main.go) that retrieves the current window from the context using application.WindowKey, and a frontend (index.html) that invokes a service method. This serves as a concrete demonstration of the WebviewWindow API and the updated Manager API's singular naming convention.

v3/examples/window-call · high confidence

Added new test files for AppImage packaging in the v3 internal commands, including a Go main package that demonstrates the v3 application and windowing APIs (such as WebviewWindow options, menu creation, and event handling) and a corresponding .desktop entry file.

_v3/internal/commands/appimage\testfiles · high confidence

Added D-Bus interface definitions and generated Go code for the \com.canonical.dbusmenu\ and \org.kde.StatusNotifierItem\ protocols. This enables the application to communicate with the Linux system tray, allowing for proper status icon display and menu interaction on Linux desktops.

v3/internal/dbus · high confidence

A new FNV hash utility function has been added to the internal hash package, providing a convenient way to generate 32-bit hashes for string inputs using the FNV-a algorithm.

v3/internal/hash · high confidence

The v2/internal/gomod package introduces new functions to inspect, validate, and update the go.mod file for Wails projects. Users will benefit from automated checks that detect when the Wails version in their project's go.mod is out of sync with the CLI, and tools to automatically update the Wails dependency and Go version requirements to match the current development environment.

v2/internal/gomod · high confidence

The file association example now includes a complete JavaScript frontend implementation. This adds the necessary HTML structure, CSS styling (including support for light and dark modes), and JavaScript logic to handle user interactions and communicate with the backend. The build configuration has also been updated to allow the Vite development server port to be configured via the WAILS\_VITE\_PORT environment variable, ensuring compatibility with package managers like pnpm.

v3/examples/file-association/frontend · high confidence

Users can now build Windows applications as MSIX packages. This adds two new template files (app\_manifest.xml.tmpl and template.xml.tmpl) that define the structure for MSIX packaging, including identity, dependencies, file associations, and protocol handlers.

_v3/internal/commands/build\assets/windows/msix · high confidence

The Preact frontend template now includes the core application components and styling. The \app.jsx\ file provides the main \App\ component that renders a greeting interface, utilizing the \Greet\ function from the Go backend. The \app.css\ file defines styles for the layout, logo, and input fields, while \style.css\ sets the global background and font families. Additionally, the template now includes the Preact logo asset and the Nunito font files with their licensing information.

v2/pkg/templates/templates/preact/frontend · high confidence

New TypeScript bindings have been added to the frontend for the notifications service, exposing methods such as SendNotification, CheckNotificationAuthorization, and UpdateNotification. The update also introduces TypeScript models for notification options, including support for sounds, attachments, categories, and scheduling, enabling frontend applications to interact with the native notification system.

v3/examples/notifications/frontend/bindings · high confidence

Added the v2/internal/typescriptify package, a Go library for generating TypeScript type definitions and conversion utilities from Go structs. The package includes a license file (Apache 2.0), a README, a list of JavaScript reserved keywords, and the core generator logic.

v2/internal/typescriptify · high confidence

A new development example for the v3 branch has been added, providing a ready-to-run Svelte application integrated with Wails. The example includes the necessary source files (App.svelte, Counter component, styles, and entry points) and a Vite configuration that allows the development server port to be customized via the WAILS\_VITE\_PORT environment variable, ensuring compatibility with package managers like pnpm.

v3/examples/dev/frontend · high confidence

The v3/examples/websocket-transport directory now contains a complete example demonstrating how to replace the default HTTP-based IPC with a custom WebSocket transport. This includes a Go backend (GreetService, main.go, transport\_websocket.go) that configures a WebSocket server on port 9099, alongside frontend JavaScript (websocket-transport.js) and generated bindings (greetservice.js, index.js) that utilize the new transport. The example also provides an HTML/CSS frontend (index.html) and a README explaining the architecture, showing that all Wails bindings and events work identically over the custom transport.

v3/examples/websocket-transport · high confidence

The \w32\ package now includes comprehensive bindings for core Windows libraries, enabling direct interaction with the operating system's UI and system services. This adds support for Common Controls (\comctl32\), Common Dialogs (\comdlg32\), Desktop Window Manager (\dwmapi\), Graphics Device Interface (\gdi32\, \gdiplus\), OLE/COM (\ole32\, \oleaut32\), Shell (\shell32\, \shcore\, \shlwapi\), User32 (window management, messages, and input), and Kernel32 (memory, resources, and process management). These additions provide the foundational layer for rendering, window creation, and system integration on Windows.

v2/internal/frontend/desktop/windows/winc/w32 · high confidence

The \v2/internal/go-common-file-dialog\ package has been added, providing Go bindings for the Windows Common File Dialogs. This includes support for Open, Open Multiple Files, Select Folder, and Save File dialogs, along with configuration options for titles, roles, folders, and file filters. The implementation uses COM interfaces and the \go-ole\ library for Windows, while providing stubs for non-Windows platforms. This adds a new internal capability for file selection on Windows.

v2/internal/go-common-file-dialog · high confidence

The badge example now includes a complete set of build configuration files to support building and packaging the application across all three major platforms. For macOS, the build process is configured to target a minimum deployment of macOS 12.0, and the build tasks handle creating the \.app\ bundle. For Linux, the build system is updated to use GTK4 and WebKitGTK 6.0, with support for generating AppImages, DEB, RPM, and AUR packages. For Windows, the build process generates the necessary \.syso\ and \.manifest\ files, and the NSIS installer template now supports a user-scoped installation option, allowing the installer to run without requiring administrator privileges. These changes provide a standardized, cross-platform build workflow for the example project.

v3/examples/badge/build · high confidence

A new \colour\ package has been introduced to manage terminal text styling. It provides helper functions to wrap text in ANSI color codes for various colors (e.g., \Yellow\, \Red\, \Blue\, \Green\, \Cyan\, \Magenta\, \White\, \Black\, and their dark variants) as well as a \Rainbow\ function that applies a cycling set of colors to each character. All styling functions respect a global \ColourEnabled\ flag, which can be set to \false\ to disable colored output entirely.

v2/internal/colour · high confidence

The badge-custom example now supports setting a custom badge on the application icon with specific styling options, including text color, background color, and font settings. This is enabled by new TypeScript bindings for the Dock service (including \SetCustomBadge\ and \BadgeOptions\ models) and updated frontend code that allows users to apply these customizations via the UI. Additionally, the Vite build configuration has been updated to allow the development server port to be controlled via the \WAILS\_VITE\_PORT\ environment variable, improving compatibility with package managers like pnpm.

v3/examples/badge-custom/frontend · high confidence

The custom protocol example now includes a complete frontend implementation. This adds a build output directory containing the compiled JavaScript and CSS assets, alongside the source files (HTML, CSS, JS) that render a page demonstrating how to handle custom URL schemes (deep links) and display received URL data in the UI.

v3/examples/custom-protocol-example/frontend · high confidence

Added two new example projects to the v2/examples directory: a 'customlayout' example demonstrating how to use a custom layout, and a 'dragdrop-test' example for drag and drop functionality. Each example includes the necessary Go source files, frontend assets, build configuration templates for macOS and Windows (including NSIS installer scripts and Windows manifests), and supporting documentation files.

v2/examples · high confidence

A new debug package has been introduced in the v3 internal directory. This addition provides a mechanism to detect the local module path by checking for a .git directory relative to the source file, which is useful for identifying local builds during development.

v3/internal/debug · high confidence

A new Info.plist template has been added to the build system for macOS applications. This template provides default metadata such as the application name, bundle identifier, versioning, and system requirements, ensuring that generated macOS apps have the necessary configuration for proper identification and execution on Apple platforms.

v2/pkg/commands/build/internal · high confidence

A new drag-and-drop example is provided in the v3 examples, demonstrating both external file drops and internal element dragging between zones. The HTML template includes styling for drop zones, drag-over states, and bucket lists to showcase the runtime's drag-and-drop capabilities.

v3/examples/drag-n-drop/assets · high confidence

The drag-and-drop example frontend now includes the necessary CSS styles, font licensing, and JavaScript to render the UI and handle interactions. Crucially, global event listeners are registered in main.js to prevent the browser from opening new windows when files are dropped in the window, ensuring a smoother user experience.

v2/examples/dragdrop-test/frontend · medium confidence

The CLI now includes a new internal package (v2/cmd/wails/internal/gomod) that provides a SyncGoMod function. This function locates the project's go.mod file, ensures the Go version matches the minimum requirement, and optionally updates the Wails dependency version to match the CLI's internal version. If the Wails version in go.mod is out of sync, the CLI will either update it automatically or print a warning suggesting the user update their project's go.mod file.

v2/cmd/wails/internal/gomod · high confidence

Added new files in the iOS build assets directory to support building and packaging iOS applications. This includes a Taskfile.yml defining tasks for building, packaging (including .ipa generation), and deploying to simulators and physical devices, along with Go source files (main.m, main\_ios.go, app\options\\*.go) that handle the iOS-specific application lifecycle, signal handling, and dependency checking scripts.

_v3/internal/commands/build\assets/ios · high confidence

New PowerShell and Bash scripts have been added to the scripts directory to streamline the management of GitHub issues and pull requests. The \issue-triage\ scripts (\.ps1\ and \.sh\) provide an interactive menu to quickly triage unassigned issues, allowing users to add labels (such as v2-only, v3-alpha, bug, or documentation), request more information, or close issues. Similarly, the \pr-review-helper\ PowerShell script offers an interactive workflow for reviewing pull requests, enabling users to view diffs, generate review checklists, approve or request changes, and add labels. These tools are designed to reduce manual effort in community management.

scripts · high confidence

The frontend now includes a new main entry point that wires up two buttons to the Wails DockService, allowing users to show or hide the application's icon in the macOS dock. This adds the ability to toggle the dock icon visibility directly from the UI.

v3/examples/dock/frontend · high confidence

New TypeScript bindings have been added for the macOS Dock service, enabling frontend applications to control the application icon in the dock or taskbar. The \dockservice.ts\ file exposes methods to hide or show the app icon (\HideAppIcon\, \ShowAppIcon\) and manage badge labels (\SetBadge\, \SetCustomBadge\, \RemoveBadge\). The \SetCustomBadge\ method accepts a \BadgeOptions\ model, which allows customization of the badge's text color, background color, and font properties. Supporting models for \RGBA\ color representation are also included to facilitate these customizations.

v3/examples/badge/frontend/bindings · high confidence

The Android example now includes macOS build support. New files (Info.plist, Info.dev.plist, and Taskfile.yml) configure the macOS build process, including setting the minimum macOS deployment target to 12.0 and defining tasks for building, packaging, and running the application on macOS.

v3/examples/android/build/darwin, v3/examples/ios/build/darwin · high confidence

A new example application has been added at v3/examples/dialogs-basic that demonstrates the v3 Dialog API. The app provides a suite of 10 tests covering file and directory selection, extension filtering, multi-selection, hidden file visibility, and save dialogs, allowing users to verify dialog behavior across different configurations.

v3/examples/dialogs-basic · high confidence

New platform-specific files (desktop\_darwin.go, desktop\_linux.go, desktop\_windows.go) have been added to the desktop frontend package. Each file uses build tags to conditionally compile a \NewFrontend\ function that delegates to the corresponding platform implementation (darwin, linux, or windows). This change provides the necessary entry points for the Wails framework to initialize the correct desktop frontend based on the operating system.

v2/internal/frontend/desktop · high confidence

A new service template has been added to the Wails v3 framework, providing a structured starting point for creating backend services. The template includes a Go module file, a service implementation with lifecycle hooks (Startup/Shutdown), HTTP handling, and a YAML configuration file. This allows developers to quickly generate and integrate custom services into their Wails applications.

v3/internal/service · high confidence

A new example application demonstrating system tray (systray) integration is now available. The app displays a live clock in the system tray tooltip, updating every second. On macOS, it uses a template icon to respect light/dark mode, and the application remains active in the background without closing when the main window is closed.

v3/examples/systray-clock · high confidence

The Android build configuration now includes the full set of native Android files required to run a Wails v3 application on mobile devices. This includes the AndroidManifest.xml with permissions for internet, vibration, biometric authentication, notifications, geolocation, camera, and foreground services, as well as the main activity, bridge classes (WailsBridge, WailsJSBridge), and a foreground service to keep the app alive in the background. The layout, themes, and resource files are also added to support the mobile environment.

v3/examples/mobile/build/android · high confidence

The v3 changelog workflow now uses two new Go scripts: auto-changelog.go generates changelog entries by fetching PR details and a CodeRabbit summary, then uses an LLM to produce a concise entry for the Unreleased section, while validate-changelog.go checks that entries are placed in the correct section and automatically fixes misplaced lines. This replaces the previous bash-based pipeline and ensures internal-only commits (ci, chore, build, test, style) are excluded from user-facing release notes.

v3/scripts · high confidence

A new Go utility has been added to the v3/tasks/contribs directory. This tool automatically detects missing contributors by running the all-contributors-cli check command, parses the output to identify those who need to be added, and then executes the add command for each valid contributor (excluding bots like dependabot). This streamlines the process of keeping the project's contributor list up to date.

v3/tasks/contribs · high confidence

The codebase now includes an automated code generator (generate.go) that produces strongly-typed event definitions for Go, C headers, and TypeScript across all supported platforms (Windows, Mac, Linux, iOS, and Android). This ensures that event types and their corresponding JavaScript/TypeScript mappings are consistently generated, reducing manual maintenance and improving type safety for cross-platform event handling.

v3/tasks/events · high confidence

A new Go-based release tool has been added to the v2/tools directory. This script automates the release process by automatically incrementing the minor version number (resetting the patch to zero) when no explicit version is provided, updating the changelog with the current date, and optionally regenerating and cleaning up Docusaurus documentation versions.

v2/tools · high confidence

Icon assets for macOS, Windows, and systray (light/dark modes) are now embedded directly in the v3/pkg/icons package. This change consolidates default icons such as the macOS template icon, Windows default icon, and various Wails logos into a single location, ensuring consistent access to these visual resources across the application.

v3/pkg/icons · medium confidence

The v3/internal/version package now manages the application's version string. It embeds the version from a version.txt file, which currently contains v3.0.0-beta.4. The String() function returns the embedded version for production builds and a hardcoded dev string for development builds, with tests ensuring whitespace is trimmed correctly.

v3/internal/version · high confidence

The asset server now supports a configurable HTTP middleware chain, allowing users to intercept or modify requests before they reach the default handler. Additionally, users can specify a fallback HTTP handler to serve requests that are not found in the static assets, with validation ensuring that at least one of Assets, Handler, or Middleware is provided.

v2/pkg/options/assetserver · medium confidence

The custom-protocol-example now includes a complete build system for macOS, Linux, and Windows. macOS builds enforce a minimum deployment target of 12.0 and use Taskfile tasks for building, packaging, and signing. Linux builds are configured to use GTK4 and WebKitGTK 6.0, with support for generating AppImage, .deb, .rpm, and AUR packages. Windows builds generate NSIS installers that support both machine-wide and user-scoped installations, including a new option for user-level installs without UAC prompts.

v3/examples/custom-protocol-example/build · high confidence

Wails v3 introduces an experimental, opt-in Go-native build runner called Wake, activated by setting the \WAILS\_USE\_WAKE=true\ environment variable. This new executor reads \Taskfile.yml\ files directly in Go, providing faster incremental builds through a native Go auto-cache for \go build\ and \go mod tidy\ tasks, and supports parallel dependency execution. It also introduces layered local overrides (e.g., \Taskfile.local.yml\) and structured build reporting via the \internal/report\ interface. When a feature is unsupported by Wake, it automatically falls back to the embedded Task runtime.

v3/internal/wake · high confidence

The \v3/pkg/w32\ package is now public, making it available for external use. This change adds new Go wrappers for Windows system libraries, including clipboard management (read/write text), image handling (converting PNG/ICO files to HICON), and drag-and-drop target implementation. These additions provide the underlying mechanisms for features like custom hit-test logic, systray support, and file drop zones on Windows.

v3/pkg/w32 · high confidence

The git package now includes functions to retrieve the configured git user name and email, with the name retrieval properly escaping special characters (such as backslashes and apostrophes) to ensure valid JSON output. Additionally, the package now supports initializing a new git repository in a specified directory.

v2/pkg/git · high confidence

Added Android-specific implementation files to the application package, including \application\_android.go\ which provides a JNI bridge to the Android runtime, and \application\_android\_nocgo.go\ which provides stubs for non-CGO builds. These changes enable the Wails v3 application lifecycle to run on Android devices, allowing Go code to interact with the Android OS and Java/Kotlin layers via the \android\ build tag.

v3/pkg/application · high confidence

A new CLI logger implementation has been added to the codebase, providing structured logging for the command-line interface. The logger supports muting output and formats fatal errors in red using the internal color utility.

v2/pkg/clilogger · high confidence

Added a new SQLite service implementation in v3/pkg/services/sqlite, providing Go backend logic and corresponding JavaScript/TypeScript bindings (stmt.js) for database operations. The service exposes methods for opening, closing, and managing SQLite connections, along with prepared statement handling via the Stmt class, enabling database interactions from the frontend.

v3/pkg/services/sqlite · high confidence

The repository now includes the formal process for proposing and implementing enhancements to Wails. This includes a new \v3/wep/README.md\ file that outlines the WEP workflow, a \WEP\_TEMPLATE.md\ for structuring proposals, and an initial example proposal (WEP 0001) for customizing window controls. This provides a structured way for the community to suggest and discuss significant changes to public APIs and behavior.

v3/wep · high confidence

The \wails doctor\ command has been added to provide a comprehensive diagnostic report of the development environment. It automatically detects system information (OS, CPU, GPU, memory), checks for required and optional dependencies (npm, Docker, Android toolchain, Xcode, Windows SDK), and verifies signing configurations across macOS, Linux, and Windows. The tool also runs platform-specific checks, such as verifying the presence of \.syso\ files on macOS or the Windows SDK on Windows, and reports any issues that may prevent successful builds.

v3/internal/doctor · high confidence

The \v2/pkg/menu\ package now provides a full-featured menu system inspired by Electron, allowing developers to create and manage application menus. This includes support for various item types such as Text, Checkbox, Radio, Submenu, and Separator. The package also introduces a \StyledText\ type for rich text labels with color and style formatting, and provides helper functions to create default menus for macOS and Windows. Additionally, the \TrayMenu\ struct has been updated to support opening and closing events, and the \MenuItem\ struct now includes properties for disabled, hidden, and checked states, as well as methods for dynamic menu manipulation like \InsertBefore\, \InsertAfter\, and \Remove\.

v2/pkg/menu · high confidence

The notifications service now provides a unified API for sending notifications on macOS, Windows, and Linux, with a stub for iOS. This update adds support for interactive notifications with actions and reply fields, notification categories, custom sounds, media attachments, thread grouping, interruption levels, and scheduled delivery. Platform-specific implementations handle the underlying systems: macOS uses the UserNotifications framework, Windows uses the wintoast library for toast notifications, and Linux uses D-Bus for the freedesktop notifications spec. The service also includes validation for notification options and handles platform-specific constraints, such as macOS requiring a valid bundle identifier and critical interruption levels needing entitlements.

v3/pkg/services/notifications · high confidence

A new fileserver service has been added to the v3 package, providing a configurable HTTP handler for serving static files from a specified root path. Users can now initialize and configure this service to serve content from a given directory, with unconfigured requests receiving a 503 Service Unavailable response.

v3/pkg/services/fileserver · high confidence

The v2 internal frontend package now exposes a comprehensive set of methods for window management (show, hide, maximize, minimize, fullscreen, theme switching), screen dimensions, system notifications, clipboard access, and browser URL opening. This establishes the frontend contract for these features.

v2/internal/frontend · high confidence

The \v3/pkg/updater\ package is added, providing a complete in-app self-update mechanism for Wails v3 applications. This includes a pluggable \Provider\ interface for fetching release information from sources like GitHub, AppCast, or keygen.sh, along with a default HTML/CSS update window template that supports both light and dark modes. The update flow handles downloading artifacts, verifying release signatures and digests, and performing a safe binary swap via a helper process that manages cross-platform file locking and executable bit preservation. The package also exposes lifecycle events (e.g., \EventDownloadProgress\, \EventUpdateAvailable\) for both Go and JavaScript subscribers to track and react to update states.

v3/pkg/updater · high confidence

A new key-value store service is introduced, providing an in-memory data store that can optionally persist to disk. The service supports configuration for a file path and an auto-save mode, with explicit methods to load and save state. It implements the standard service lifecycle hooks (Startup/Shutdown) to manage persistence automatically, and offers Get, Set, and Delete operations for key-value manipulation.

v3/pkg/services/kvstore · high confidence

The v2/pkg/application package now provides a new Application struct that manages the Wails app lifecycle. It adds event hooks for startup, shutdown, and DOM ready states, allowing users to register callbacks for these phases. Additionally, the Quit method is now nil-safe, preventing panics if called before the application has fully initialized or after an early shutdown.

v2/pkg/application · high confidence

A new capabilities module has been added to detect and expose platform-specific feature support. On Linux, the system now reports whether native drag-and-drop is supported along with the specific GTK (3 or 4) and WebKitGTK (4.1 or 6.0) versions in use. On Windows, the module detects whether the installed WebView2 version is at least 113.0.0.0 to enable native drag support. macOS is included but currently reports that native drag is not supported. This structured capability data is serialized to JSON for use by the rest of the application.

v3/internal/capabilities · high confidence

A new logging service is added to the v3 package, providing structured logging with support for context propagation (e.g., window state). The service exposes methods for Debug, Info, Warning, and Error levels, along with a configurable log level and custom logger injection. This enables developers to integrate Wails' logging into their applications with full context awareness.

v3/pkg/services/log · high confidence

Added new files in v3/internal/term to provide consistent terminal output formatting. styles.go defines color palettes and styles using the lipgloss library, including styles for headers, sections, status icons, and tables. term.go introduces helper functions for printing headers, managing spinners, and outputting information, warnings, errors, and success messages with appropriate styling. The implementation also includes utilities for detecting terminal environments, enabling/disabling color output, and generating hyperlinks in the terminal.

v3/internal/term · medium confidence

The v3 CLI is now available as the \wails3\ command, providing a comprehensive set of subcommands for project initialization, building, and packaging. This update adds new generation tools for build assets, icons, and runtime files, alongside a \tool\ namespace for system diagnostics, port checking, and file operations. It also introduces mobile support for iOS and Android, including overlay generation and Xcode project creation, as well as an \updater\ command for managing update manifests and signing keys.

v3/cmd/wails3 · high confidence

The \v3/pkg/events\ package now provides a typed, cross-platform event system that maps platform-specific window and application events to a common set of types. This includes support for window focus, resize, move, fullscreen, and close states, as well as application lifecycle and system events like sleep/wake and theme changes. The system generates C headers and Go constants for each platform (macOS, Windows, Linux, iOS) to ensure consistent event handling across the Wails v3 runtime.

v3/pkg/events · high confidence

A new internal signal package provides a centralized way to handle OS signals (SIGINT, SIGTERM, interrupt) and execute registered shutdown callbacks, enabling graceful application shutdown when Ctrl+C is pressed.

v2/internal/signal · high confidence

The v2/pkg/options package now provides a centralized \App\ struct that defines the configuration for creating a Wails application. This includes window properties (title, size, frameless, fullscreen), background color, asset server configuration, menu, logger, and platform-specific options for Windows, Mac, and Linux. It also introduces debug options for opening the inspector on startup, a single instance lock mechanism, and drag-and-drop settings. The \MergeDefaults\ function ensures sensible defaults are applied for window dimensions, logging, and drag-and-drop behavior.

v2/pkg/options · high confidence

The Linux doctor command now detects and supports a wider range of package managers, including APT, DNF, Pacman, Emerge, Zypper, Nixpkgs, Eopkg, and Xbps. This enables the doctor to provide accurate dependency checks and installation commands for various Linux distributions. The doctor also now detects the newer GTK4 and WebKitGTK 6.0 libraries, which are the default for Wails v3, while still supporting the legacy GTK3/WebKitGTK 4.1 for compatibility.

v3/internal/doctor/packagemanager · high confidence

A new \linux\ package is introduced, defining an \Options\ struct that allows users to configure Linux-specific behaviors. This includes setting a window icon, enabling window transparency, specifying a minimum required version of WebKit2GTK, and controlling the webview's hardware acceleration policy (OnDemand, Always, or Never). The default message for missing WebKit2GTK is also provided.

v2/pkg/options/linux · high confidence

The @wailsio/runtime module has been added to the Wails v3 codebase, providing a comprehensive JavaScript/TypeScript API for interacting with the Wails runtime. This includes namespaces for Android, Application, Browser, Clipboard, ContextMenu, Dialogs, Drag-and-drop, and more, enabling frontend applications to access native platform features such as system dialogs, clipboard access, and window management.

v3/internal/runtime/desktop/@wailsio/runtime · high confidence

Two new Dockerfiles are introduced in the build assets: a cross-compilation image (Dockerfile.cross) that supports building for Darwin, Linux, and Windows on amd64 and arm64 architectures using Zig and GCC, and a server-mode image (Dockerfile.server) that produces a minimal, static Go binary for headless HTTP deployment. Users can now compile their Wails v3 apps for multiple platforms from a single Docker environment and deploy a production-ready server image with optional CGO support.

_v3/internal/commands/build\assets/docker · high confidence

A new dependency-free Go tool, \tools/sponsorkit\, replaces the previous Node-based implementation for generating the project's \sponsors.svg\ and \contributors.svg\ images. The tool fetches live data from the GitHub API to render two self-contained SVGs: one for active sponsors (with tiered styling and hover effects) and one for repository contributors (using a superellipse mosaic layout). It supports both commit and pull-request-based ranking for contributors, and includes a CI workflow to regenerate the images daily.

tools · high confidence

The code generator now produces JavaScript and TypeScript files for models, services, and events using new templates (models.js.tmpl, models.ts.tmpl, service.js.tmpl, service.ts.tmpl, eventcreate.js.tmpl, eventdata.d.ts.tmpl, and index.tmpl). These templates generate typed, auto-generated code that includes JSDoc comments, proper type definitions, and creation functions for classes, enums, and interfaces, ensuring that the generated bindings are fully typed and support modern JavaScript/TypeScript features.

v3/internal/generator/render/templates · high confidence

Added interactive demo applications for several Web APIs, including Beacon, Blob, Broadcast Channel, Cache, Canvas 2D, Clipboard, and Device Orientation. Each demo provides a self-contained Go application that serves a frontend interface to explore the respective API's capabilities, such as sending beacons, managing browser caches, drawing on canvas, or accessing device orientation data.

v3/examples/web-apis, v3/pkg/doctor-ng/tui · high confidence

The binding generator now uses a new \collect\ package to gather information about services, models, and events from the Go source code. This refactors how the generator identifies and processes types, introducing dedicated structs for constants, fields, methods, and models, along with a caching mechanism to avoid redundant analysis. This change improves the reliability and performance of the code generation process.

v3/internal/generator/collect · high confidence

The v3 binding generator has been replaced with a new implementation located in the \internal/generator/render\ package. This update introduces a new code generation pipeline that produces JavaScript and TypeScript output, including support for generating creation functions, default values, and type mappings. The new generator handles various Go types, including standard library types like \time.Time\ (mapped to JS \Date\ objects), maps, slices, and structs, while also managing template functions and identifier escaping for JavaScript/TypeScript reserved words.

v3/internal/generator/render · high confidence

The internal/generator package has been replaced with a new implementation that supports obfuscated binding IDs, allowing for stable identifiers when using tools like Garble. The generator now produces a metadata file (wails\_obfuscated.gen.go) that registers binding IDs for all services and methods, ensuring consistency during obfuscation. Additionally, the generator now includes a dedicated error reporting system (ErrorReport) that deduplicates and tracks warnings and errors, improving the feedback loop for developers. The new generator also supports generating constants for JavaScript/TypeScript, handles event data and creation code generation, and includes comprehensive test coverage for all new components.

v3/internal/generator · high confidence

A new \bindings\ command and its underlying implementation have been added to the Wails CLI, enabling users to generate TypeScript and JavaScript bindings for their Go backend. The implementation includes support for custom TypeScript prefixes and suffixes, configurable output types, and conditional stripping of debug information on Windows to avoid linker issues. Additionally, the generated binaries on macOS are automatically stripped of their quarantine attributes, and the command supports cross-compilation by correctly passing platform and architecture environment variables.

v2/pkg/commands/bindings · high confidence

The v3/examples/dialogs directory now contains a comprehensive example demonstrating the new dialog API, including info, question, warning, and error dialogs, as well as file and directory selection dialogs. The example showcases cross-platform functionality for macOS and Windows, with Linux support noted as incomplete. It also includes build configuration files (Taskfile.yml, Info.plist, info.json, wails.exe.manifest) and a README, providing a complete template for integrating dialogs into a Wails application.

v3/examples/dialogs · medium confidence

The v3/internal/flags package now defines the command-line flag structures for the Wails v3 tooling. This includes options for the \init\ command (including a new \-ui\ flag to launch an interactive browser-based setup wizard), the \build\ command (supporting \-tags\ and Garble obfuscation), the \package\ command (supporting DMG, MSIX, and Linux formats), and the \sign\ command (supporting Windows, macOS, and Linux signing). Additionally, a new \GenerateBindingsOptions\ struct and its associated parsing logic for build flags have been introduced.

v3/internal/flags · medium confidence

The Wails v3 tooling now includes a new interactive setup wizard that guides users through project initialization and environment checks. For project creation, the wizard presents a list of templates and collects user preferences (project name, identifier, template selection) via a frontend interface. For environment setup, the wizard detects and reports the status of required dependencies (Go, npm, Xcode, Docker, etc.) across Windows, macOS, and Linux, providing specific install commands and help links. The implementation includes a new \defaults\ package for configuration management, a \pullParser\ to track Docker image download progress, and platform-specific dependency checks (e.g., Xcode on macOS, WebView2 on Windows). Tests cover the parser logic and static asset serving.

v3/internal/setupwizard · high confidence

The v2/internal/fs package introduces a suite of file-system helper functions, including RelativeToCwd, Mkdir, MkDirs, MoveFile, DeleteFile, CopyFile, DirExists, FileExists, RelativePath, MustLoadString, MD5File, MustMD5File, MustWriteString, and GetSubdirectories. These utilities provide standardized, safe operations for path resolution, directory and file management, and content hashing. Corresponding unit tests have been added to verify path resolution and file-finding logic.

v2/internal/fs · high confidence

The macOS build process has been restructured to support cross-compilation via Docker, universal binary creation, and DMG packaging. Users can now build for macOS on non-macOS hosts using the wails-cross Docker image, generate universal binaries for both Apple Silicon and Intel, and create styled .dmg installers with custom backgrounds and icons. The minimum macOS deployment target has been updated to 12.0.

_v3/internal/commands/build\assets/darwin · high confidence

Added a new example demonstrating macOS window tabbing, showcasing the \MacWindowTabbingMode\ API. The example includes a \README\ explaining the feature, a \Taskfile\ to manage the build and dev workflows, and all necessary build configuration files (including \Info.plist\ for macOS, \config.yml\, and icon assets). The example is configured to use a local Wails module via a \replace\ directive in \go.mod\, as the feature is not yet in a published release.

v3/examples/mac-window-tabs · high confidence

A new menu example has been added to the v3 examples, showcasing the application menu system. The example demonstrates creating and customizing menus with roles, submenus, checkboxes, radio groups, and accelerators. It specifically highlights cross-platform support by conditionally adding the application menu on macOS and using the \UseApplicationMenu\ option for Windows/Linux, while also showing how to toggle menu item visibility and enabled states.

v3/examples/menu · high confidence

A new mobile example application has been added to the v3/examples/mobile directory, providing a cross-platform 'Kitchen Sink' demo that runs on iOS, Android, and desktop from a single codebase. The example includes build configurations, Gradle scripts, and task files for building and packaging Android (APK/AAB) and iOS (Xcode project) artifacts, along with a README detailing the supported features such as system events, native dialogs, and hardware sensors.

v3/examples/mobile · high confidence

A new \process\ package has been introduced in \v2/internal/process\ to provide a structured way to manage external processes. This utility allows applications to start, monitor, and terminate background commands, exposing methods to retrieve the process ID and handle exit conditions. This change supports improved process lifecycle management within the application.

v2/internal/process · high confidence

The v2 runtime package now exposes a comprehensive set of new functions for application control and user interaction. Users can now open URLs in the system browser, read and write to the system clipboard, and trigger file/directory/save dialogs. The update adds event management (registering, removing, and emitting events), structured logging with format support, and menu management. It also introduces a full notifications API (including categories, actions, and responses), and extensive window controls including resizing, positioning, theming, fullscreen, and JavaScript execution. Additionally, Linux-specific signal handler resets are provided to improve panic recovery.

v2/pkg/runtime · high confidence

Added new functions to the shell package for executing external commands. The \env.go\ file introduces helpers (\UpsertEnv\, \RemoveEnv\, \SetEnv\) to manage environment variable slices, while \shell.go\ provides a \Command\ struct and standalone functions (\RunCommand\, \RunCommandWithEnv\, \RunCommandVerbose\) to run shell commands with specified directories and environment variables, capturing stdout and stderr.

v2/internal/shell · high confidence

The \v2/pkg/logger\ package now provides a structured logging interface (\Logger\) supporting multiple log levels (TRACE, DEBUG, INFO, WARNING, ERROR, FATAL) and runtime level configuration. A new \FileLogger\ implementation allows users to direct log output to a specified file, while the existing \DefaultLogger\ continues to output to standard output. This change introduces a more flexible and configurable logging system for Wails applications.

v2/pkg/logger · high confidence

A new example application has been added at v3/examples/systray-menu that demonstrates how to create a system tray icon with an attached window and menu. The example shows how to toggle window visibility via the system tray, handle menu interactions (including submenus, checkboxes, radio groups, and disabled states), and manage window lifecycle events like closing. It also includes platform-specific configurations for macOS activation policy and Windows taskbar hiding.

v3/examples/systray-menu · high confidence

A new example application has been added at v3/examples/window-menu that demonstrates how to create a window with a default menu bar (File, Edit, Help) and toggle its visibility using the new Window interface methods (ToggleMenuBar, ShowMenuBar, HideMenuBar) bound to F1, F2, and F3 keys respectively. The example includes the necessary HTML and CSS assets to render the demo interface.

v3/examples/window-menu · high confidence

The repository now includes several new configuration files that define project standards and workflows. A contributor list file (.all-contributorsrc) is introduced to track and display community contributions. Development tooling is standardized with a Prettier configuration (.prettierrc.yml) and ignore rules (.prettierignore). The project also adopts a new AI agent instruction guide (AGENTS.md) to standardize AI-assisted development workflows. Additionally, a Coderabbit configuration (.coderabbit.yaml) is added to automate code review processes, and a FOSSA license scanning configuration (.fossa.yml) is introduced to manage license compliance for the documentation site and examples.

(repo-wide) · high confidence

A new HTML audit document, history/beta-readiness-audit.html, was added to the repository. This page details the current state of the Wails v3 Beta release, including a 'No-go today' verdict, a breakdown of open issues and PRs, and a checklist of 38 release gates that must be closed before tagging Beta 1.

history · high confidence

The default project templates have been redesigned to include a new, modern UI for the starter application, with distinct templates for iOS and Android platforms. The base template now includes a \README.md\ file to guide new users, a \Taskfile\ that dispatches build and run tasks to platform-specific sub-tasks for Windows, macOS, Linux, iOS, and Android, and a \gitignore\ that excludes mobile build artifacts. The Go backend template (\main.go.tmpl\) has been updated to use the new \application\ package API, registering services and events via the new manager pattern. Additionally, the iOS template includes a \puppertino\ CSS framework for mobile styling, while the base template uses a more robust frontend structure with a \main.js\ that handles events and service calls. These changes provide a more consistent and feature-rich starting point for new Wails projects, particularly with first-class support for mobile platforms.

v3/internal/templates · high confidence

The release script now supports a --create-release-notes flag that extracts content from UNRELEASED\_CHANGELOG.md and generates a clean release\_notes.md file suitable for GitHub releases. The extraction process filters out HTML comments, empty sections, and example entries, preserving only actual changelog content with proper section headers. The implementation includes comprehensive tests for various edge cases including empty changelogs, mixed bullet styles, and custom output paths. Documentation for the new feature has been added to RELEASE\_NOTES\_CREATION.md.

v3/tasks/release · high confidence

The v3 runtime package now explicitly initializes the global \window.wails\ object and injects platform-specific invocation bridges. On macOS, it uses \webkit.messageHandlers\ for message passing, while on Windows it utilizes \chrome.webview.postMessage\. Linux and Android also receive specific handling for the invoke bridge, and the environment object (OS, Arch, Debug status) is injected into the browser context. This ensures the JavaScript runtime is correctly wired to the host application across all supported platforms.

v3/internal/runtime · high confidence

The JavaScript and TypeScript runtime wrappers have been updated to expose a broader set of window and environment APIs to the frontend. This includes new functions for managing window state (minimise, maximise, fullscreen, and theme switching), controlling window size and position, and accessing environment information. The TypeScript definitions (runtime.d.ts) and JavaScript implementation (runtime.js) now include methods such as WindowMinimise, WindowMaximise, WindowFullscreen, WindowSetLightTheme, WindowSetDarkTheme, and Environment, ensuring the frontend has the necessary type definitions and runtime calls to interact with these features.

v2/internal/frontend/runtime/wrapper · high confidence

All frontend templates (React, Vue, Svelte, Preact, Lit, and Vanilla) now include the Nunito font, with corresponding CSS styles and license files added to each template's assets. The styling for the main application container, logo, input fields, and buttons has been standardized across all frameworks to ensure a consistent look and feel.

(repo-wide) · high confidence

The website directory is initialized with essential configuration files to support the Docusaurus-based documentation site. This includes a .gitattributes file to exclude the site from GitHub language statistics, a .gitignore file to manage build artifacts and dependencies, and an .nvmrc file to pin the Node.js version to 18.14.0. Additionally, a Taskfile.yml is added to standardize common development tasks such as installing dependencies, starting the local server, building the site, and managing translations via Crowdin. Prettier is also configured to enforce consistent code formatting across the project.

website · high confidence

The Windows WebView2 installer has been refactored to support a configurable browser path via the new \WebviewBrowserPath\ option, allowing users to specify a custom WebView2 runtime location. Additionally, the installer now implements distinct installation strategies—using the system bootstrapper, an embedded bootstrapper, or a browser-based download—controlled by build tags, providing more flexible and robust runtime installation and update handling for end users.

v2/internal/wv2installer · high confidence

Added the complete set of build and packaging configuration files for Windows in the v3 Android example. This includes a Taskfile to automate building the Windows executable, generating syso resources, and creating installers. Specifically, it introduces NSIS-based installer support with a configurable install scope (user vs. machine) and MSIX packaging support, along with the necessary manifest files (info.json, app\_manifest.xml, template.xml, wails.exe.manifest) to configure application metadata, DPI awareness, and security privileges for Windows deployment.

v3/examples/android/build/linux, v3/examples/android/build/windows · high confidence

The Windows build process now generates three new template files to configure Windows-specific application properties. An executable manifest (wails.exe.manifest.tmpl) is added to enable per-monitor DPI awareness and set the default execution level to 'asInvoker'. Additionally, an NSIS script (wails\_tools.nsh.tmpl) is introduced to handle the installation logic, including support for user-level vs. machine-level installation scopes and automatic WebView2 runtime detection. A resource info template (info.json.tmpl) is also added to embed product metadata such as version, company name, and copyright into the build artifacts.

_v3/internal/commands/updatable\_build\assets/windows · high confidence

The Windows frontend implementation for Wails v2 is introduced, providing the core windowing, browser, and system integration for the platform. This includes the main \Frontend\ struct and \Window\ handling, along with specific implementations for clipboard, file and message dialogs, keyboard accelerators, application menus, screen enumeration, single-instance locking, and toast notifications. The code also adds support for window theming (dark/light/system), background color, and content protection.

v2/internal/frontend/desktop/windows · high confidence

Added Windows build configuration files for iOS applications, including a Taskfile to manage build and packaging tasks, an NSIS installer script with support for user-level installation scope, and MSIX packaging templates. These changes enable building, installing, and packaging iOS apps on Windows, providing both NSIS and MSIX distribution options.

v3/examples/ios/build/windows · high confidence

The NSIS build templates for the file association example now allow installing the application to the user's local app data directory ($LOCALAPPDATA) without requiring administrator privileges. This is controlled by the WAILS\_INSTALL\_SCOPE variable, which defaults to 'machine' (system-wide) but can be set to 'user' to enable a per-user install that avoids UAC prompts.

v3/examples/file-association/build/nsis · high confidence

The Windows NSIS installer template has been updated to allow installing applications to the user's local app data directory (via the new WAILS\_INSTALL\_SCOPE=user option) in addition to the default Program Files location. The installer now also creates desktop and start-menu shortcuts, registers file associations, and supports custom protocol associations, enabling deeper integration with the Windows shell.

v2/pkg/buildassets/build/windows/installer · high confidence

On Windows, the application now supports interactive menu items in the system tray and application menus. The new \menu\ package provides a \Manager\ that tracks the state of checkboxes and radio groups across multiple menus, ensuring that clicking a checkbox toggles its state and clicking a radio item updates the group. This enables users to interact with menu items that persist their checked/radio state across the UI.

v2/internal/platform · high confidence

The Windows package now exposes a comprehensive set of options for customizing the application window and WebView2 runtime. Users can configure window themes (System, Dark, Light) and custom title bar/border colors, select backdrop types (Mica, Acrylic, etc.), and control window decorations. WebView2 behavior is also configurable, including user data paths, browser paths, GPU acceleration, and disabling renderer code integrity. Additional options include enabling/disabling swipe gestures, pinch zoom, and window class names, as well as handling DLL search paths for security.

v2/pkg/options/windows · high confidence

Added the complete set of iOS build artifacts for Wails v3, including Xcode project files (\project.pbxproj\), asset catalogs (\Assets.xcassets\), and property list files (\Info.plist\, \LaunchScreen.storyboard\). The change also introduces Go source files (\main.m\, \main\_ios.go\, \app\_options\_ios.go\) that handle the iOS application lifecycle, linking the Go runtime with the UIKit entry point, and configuring native iOS app options such as disabling default signal handlers and enabling native tabs.

_v3/examples/ios/build/ios, v3/internal/commands/updatable\_build\assets/ios · high confidence

A new iOS example project has been added to the v3 examples directory, providing a proof-of-concept for running Wails v3 on iOS devices and simulators. The example includes a Go entry point (main.go) that configures the application with iOS-specific options such as native UITabBar tabs and custom user-agent support. It also features an HTML/CSS frontend demonstrating WebView rendering, asset server functionality, JavaScript bridge calls, and Go-to-JS event communication. Platform-specific Go files handle iOS runtime events (like scroll and bounce settings) while providing stubs for non-iOS platforms. The example is accompanied by a README with build and run instructions, a Taskfile for development tasks, and a .gitignore file.

v3/examples/ios · high confidence

The iOS frontend example now includes a complete JavaScript frontend with bindings to the Wails runtime, enabling native iOS features such as haptic feedback, device information retrieval, and scroll/navigation control. The example features a tabbed UI for Bindings, Go Runtime, and JS Runtime interactions, along with CSS styling and font licenses for the iOS build.

v3/examples/ios/frontend · high confidence

A new example in v3/examples/spotlight demonstrates how to create a launcher-style window on macOS that appears on all virtual desktops (Spaces) and can overlay fullscreen applications. The example configures MacWindowCollectionBehaviorCanJoinAllSpaces and MacWindowCollectionBehaviorFullScreenAuxiliary to achieve this behavior, along with a floating window level and translucent backdrop.

v3/examples/spotlight · medium confidence

The generated Info.plist and Info.dev.plist templates for macOS builds now include CFBundleDocumentTypes and CFBundleURLTypes entries. This enables the built application to handle specific file extensions and custom URL schemes, allowing users to open files from Finder or launch the app via custom protocols.

v2/pkg/buildassets/build/darwin · high confidence

The origin validator now strictly enforces that wildcard patterns must span complete origin components (e.g., subdomains or ports) and cannot cross boundaries such as host, port, or path separators. This prevents suffix-matching bypasses where a pattern like 'myapp.com\*' could previously match 'myapp.community' or 'myapp.com.attacker.com'. The implementation uses anchored regular expressions with strict component boundaries to ensure that partial-label wildcards fail closed rather than expanding unexpectedly.

v2/internal/frontend/originvalidator · high confidence

A new README.md has been added to the v3/examples directory, providing instructions for running and compiling the Go-based examples. Additionally, a new file, linux\_status.org, has been introduced to track the operational status of each example on Linux, indicating which features work, are partial, or are broken.

v3/examples · medium confidence

The updater now supports pluggable update providers (e.g., GitHub, keygen.sh, AppCast) and allows developers to supply a custom HTML template for the update window. This example demonstrates configuring the updater with a GitHub release, wiring a menu item to trigger the update flow, and subscribing to updater events. The 'Bring Your Own UI' (BYO) variant shows how to create a fully custom update window with a custom HTML template, while the main example uses the framework's default window with release notes, progress bar, and standard buttons.

v3/cmd/updater-ui-driver-byo, v3/examples/updater · medium confidence

The default 404 error page is now localized, with new HTML templates for English (index.en.html) and Chinese (index.zh.html) providing tailored user-facing error messages and styling for each language.

v3/internal/assetserver/defaults · high confidence

The internal asset server has been completely rewritten to improve reliability and performance. The new implementation adds retry logic with a 50-retry limit for the Vite development server proxy to handle transient connection failures. It introduces a content-type sniffer that detects MIME types from the first 512 bytes of the response, ensuring correct headers are set. The server now supports multi-language default index pages and serves assets asynchronously on Windows. Additionally, the server implements the http.CloseNotifier and http.Flusher interfaces for better compatibility with frameworks like Gin, and includes a fallback mechanism to serve a default index.html when a 404 is returned by the main handler.

v3/internal/assetserver · high confidence

The tool now requires Go 1.20 or newer to compile. If the installed Go version is older than 1.20, compilation will fail with a clear error message indicating the minimum version requirement.

v2/internal/goversion · high confidence

The doctor command now supports a broader range of Linux package managers, including Xbps (Void Linux), Emerge (Gentoo), Eopkg (Solus), and Nixpkgs (Nix/NixOS), alongside existing support for APT, DNF, Pacman, and Zypper. This allows the doctor command to correctly identify and report on the required build dependencies for these distributions.

v3/pkg/doctor-ng/packagemanager · high confidence

The Linux asset server now safely handles request lifecycle and main-thread dispatch during application shutdown, preventing deadlocks and crashes. A new \mainthread\_linux.go\ implementation ensures that WebKit2GTK requests are confined to the GTK main thread and that callbacks are executed inline if the main loop has already stopped, avoiding infinite waits. Additionally, the codebase introduces platform-specific request and response writer implementations for Linux (GTK3/GTK4), macOS, iOS, Android, and Windows, each adhering to a unified \Request\ and \ResponseWriter\ interface to standardize how the asset server interacts with the underlying webview engine.

v3/internal/assetserver/webview · high confidence

The 'Development' field in build info now correctly reflects whether the Wails source tree is resolvable at runtime, rather than relying on Go's 'vcs=git' build setting. This prevents release artifacts built in CI from incorrectly triggering development-mode behavior, which previously caused malformed 'replace' directives in scaffolded projects.

v3/internal/buildinfo · high confidence

The bindings generation command now uses an atomic directory sync to prevent file-watcher loops and Windows access-denied errors when the Vite dev server holds open handles. Build assets are generated into a temporary directory first and then synced, ensuring that the output directory is never deleted or renamed while in use. Additionally, build warnings are now collected via an environment variable and flushed at the end of the build, providing clearer feedback on deprecated or missing configurations.

v3/internal/commands · high confidence

Added new internal files to the generator's config package: file.go defines a FileCreator interface and implementations (DirCreator, NullCreator) for managing file output; log.go introduces a Logger interface with a Pterm-based implementation that prefixes warnings with '\[warn\]' to prevent GitHub Actions from treating them as errors; paths.go defines constants for Wails v3 package paths and a SystemPaths struct for resolved system package locations.

v3/internal/generator/config · high confidence

The Wails v2 library now provides a simplified \Run()\ function in the main \wails\ package, which accepts an \\*options.App\ configuration and executes the application. This replaces the previous \CreateApp\ pattern, offering a more direct way to start a Wails application.

v2 · high confidence

The project configuration is now managed through a dedicated \Project\ struct in \v2/internal/project\, which maps JSON fields like \frontend:dir\, \build:dir\, \frontend:dev\, and \frontend:dev:build\ to Go fields. This change adds support for configuring the frontend directory, build directory, dev server settings, and build commands, with default values and path resolution logic implemented in the new \project.go\ file. Tests in \project\_test.go\ verify the correct resolution of relative and absolute paths for frontend and build directories.

v2/internal/project · medium confidence

The build process for Linux AppImages now includes a dedicated shell script that constructs the AppDir structure and invokes linuxdeploy to generate the final AppImage. The script supports both x86\_64 and aarch64 architectures, downloading the appropriate linuxdeploy binary for each platform to ensure correct bundling.

_v3/internal/commands/build\assets/linux/appimage · medium confidence

The Linux build configuration has been updated to target GTK4 and WebKitGTK 6.0, which are the default libraries for modern Linux distributions such as Ubuntu 24.04+ and Debian 13+. This change ensures that packaged applications (AppImage, deb, rpm, and Arch packages) correctly depend on and utilize these newer library versions, aligning the build process with current Linux ecosystem standards.

v3/examples/notifications/build/linux · high confidence

The Linux package generation now includes postinstall and preremove scripts that update the desktop database and MIME database. This ensures that application menu entries and custom URL scheme handlers are correctly registered and cleaned up during package installation and removal.

_v3/internal/commands/build\assets/linux/nfpm · high confidence

The frontend dispatcher has been refactored into a new modular structure, replacing the previous monolithic implementation. This change introduces separate handlers for browser messages, system calls (including window management, clipboard, and notifications), secure calls, and event processing. The dispatcher now supports a broader range of runtime interactions, such as opening URLs, managing window states (minimize, maximize, fullscreen), and handling drag-and-drop events, all routed through a centralized message processing pipeline.

v2/internal/frontend/dispatcher · high confidence

The internal/frontend/devserver package has been replaced with a new DevWebServer implementation. This change introduces a dedicated HTTP server (using the Echo framework) that manages WebSocket connections for hot-reloading and IPC, and proxies requests to either the embedded asset server or an external frontend development server (e.g., Vite). This enables a more robust development experience with automatic reloads and better separation of concerns during the development phase.

v2/internal/frontend/devserver · high confidence

The Svelte frontend template has been completely redesigned to use Svelte 5, featuring a new header with brand logos, a greeting input with animated title swapping, a toast notification system, and a responsive footer. The update also adds ARIA labels to interactive elements for better accessibility.

v3/internal/templates/svelte/frontend · high confidence

The Vue frontend template has been completely redesigned to use TypeScript by default and support Vite 5. The new template includes a restructured component hierarchy (App.vue, HelloWorld.vue) and a main entry point (main.ts) that mounts the Vue application. The template also adds accessibility improvements, such as aria-labels on interactive elements, and integrates with the Wails runtime for cross-process communication and URL handling.

v3/internal/templates/vue/frontend · medium confidence

The desktop frontend runtime has been refactored into separate, modular JavaScript files (e.g., \calls.js\, \events.js\, \window.js\) to improve maintainability and testability. This change introduces a new \ObfuscatedCall\ mechanism for backend communication, ensures that all binding errors are rejected as \Error\ objects rather than plain strings, and adds support for multiple event listener deregistration via \EventsOff\. Additionally, the event dispatching logic has been fixed to correctly handle listener removal and addition during event notification, preventing listener resurrection or dropping issues.

v2/internal/frontend/runtime/desktop · high confidence

The setup wizard has been redesigned with a modern, glassmorphic UI theme that includes support for both light and dark modes. The visual overhaul introduces new styling for components such as settings rows, buttons, and cards, along with updated color palettes and typography, providing a more polished and consistent user experience during project initialization.

v3/internal/setupwizard/frontend · medium confidence

The default project templates for React, Svelte, Vanilla JS, and Vue have been redesigned. Each template now features a unified UI with a header displaying the Wails and framework logos, a greeting input with a 'Greet' button, and a footer showing the Wails version and a live clock. The templates implement a crossfade animation for the title, a toast notification for backend messages, and responsive handling for the time display on narrow screens. The Vue template was restructured to use a separate HelloWorld component, while the others use a single App component.

(repo-wide) · high confidence

The asset server logic has been refactored into the \v2/pkg/assetserver\ package, separating the core file serving (\assethandler.go\) from platform-specific request handling (\assetserver\_webview.go\) and development mode logic (\assetserver\_dev.go\). This change introduces a new \NewExternalAssetsHandler\ that allows the asset server to proxy requests to an external server, falling back to local assets if the proxy returns a 404 or 500 error. The \AssetServer\ now injects runtime and IPC scripts into HTML responses, and the default \index.html\ is embedded and served when no assets are found.

v2/pkg/assetserver · high confidence

The CLI flag definitions for the Wails command-line interface have been refactored into specific structs for each command (e.g., Build, Dev, Init, Generate). This change introduces new command-line flags such as \-devtools\ for production builds, \-nopackage\ (renamed from \-noPackage\), and \-m\ to skip mod tidy, while also adding configuration options for Vite server timeouts and NSIS install scopes. These changes allow users to customize build modes, control frontend rebuilding, and specify platform targets more granularly.

v2/cmd/wails/flags · high confidence

The build command implementation has been refactored into a modular structure with a shared base builder and platform-specific implementations. This change introduces a \BaseBuilder\ struct in \base.go\ that handles common build logic, such as running \go mod tidy\, generating runtime wrappers, and managing file cleanup. Platform-specific builders, like \DesktopBuilder\ for macOS and Windows, now embed this base, allowing for cleaner separation of concerns. The \build.go\ file now orchestrates the build process by selecting the appropriate builder based on the output type (e.g., 'desktop') and executing the build steps. This structure supports future expansion to other platforms or build types while maintaining a consistent interface for build operations.

v2/pkg/commands/build · high confidence

The \wails dev\ command has been refactored to improve reliability during development. The file watcher now correctly filters out base directories from the \.gitignore\ file, ensuring that only relevant project files trigger rebuilds. Additionally, the development server now properly manages the lifecycle of child processes (such as Vite or other frontend watchers) by killing them cleanly on exit, preventing orphaned processes and ensuring a clean state when the dev server is stopped.

v2/cmd/wails/internal/dev · high confidence

The internal logging system has been refactored to support named, custom logger instances via the new \CustomLogger\ interface, which prefixes all messages with a specified name. The main \Logger\ type now exposes methods to create these custom loggers and allows runtime configuration of the minimum log level via \SetLogLevel\. Additionally, the \Print\ method has been added to the main logger for direct, unformatted output.

v2/internal/logger · medium confidence

The runtime's event system was refactored to use a dedicated \Events\ struct with a \notifyLock\ mutex to prevent race conditions during event dispatch and listener deregistration. Additionally, the internal \assets.go\ and \assets\_dev.go\ files were introduced to bundle and expose the \DesktopIPC\ and \WebsocketIPC\ JavaScript modules, separating production and development builds via Go build tags.

v2/internal/frontend/runtime · high confidence

The project has replaced several external third-party dependencies with internal, standard-library-based implementations. This includes a new \browser\ package for opening URLs and files using OS-native commands (\open\, \xdg-open\, \rundll32\), a \gosod\ package for extracting and templating file systems, a \lo\ package providing generic utility functions (e.g., \Associate\, \Contains\, \Find\), an \optional\ package for tracking set/unset states, a \semver\ package for semantic version parsing and comparison, a \tint\ package for colored logging, and a \uuid\ package for generating and formatting UUIDs. Each of these internal packages includes comprehensive unit tests to verify their behavior.

(repo-wide) · high confidence

The internal app initialization logic has been refactored into separate build-tag-specific files (e.g., app\_dev.go, app\_production.go, app\_bindings.go), each handling a specific build mode. This change introduces a new \app\ package in \v2/internal/app\ that centralizes the creation and configuration of the \App\ struct, while delegating mode-specific behavior (such as dev server setup, production logging, and binding generation) to distinct files. Users will see a more modular internal structure that separates concerns by build tags, potentially affecting how custom build tags or environment variables (like \tsprefix\, \tsuffix\, \tsoutputtype\) are processed during the build process.

v2/internal · high confidence

The internal binding package was refactored into distinct files (binding, boundMethod, db, generate, reflect) to improve maintainability and support new features like obfuscation and improved TypeScript type generation. The \Bindings\ struct now explicitly manages TypeScript generation state (prefix, suffix, interface mode) and handles enum and struct collection for TS models. The \BoundMethod\ and \DB\ structures were updated to support obfuscated method calls and more robust method storage. Additionally, the TypeScript generation logic in \generate.go\ was enhanced to better handle return types, including \Promise\<void\>\ for methods with no returns or only error returns, and improved type mapping for Go types to TypeScript types.

v2/internal/binding · medium confidence

The asset server's webview implementation has been refactored to use a unified \Request\ and \ResponseWriter\ interface across all platforms. This change introduces platform-specific implementations for macOS (using WKWebView), Windows (using WebView2), and Linux (using WebKit2GTK), ensuring consistent request processing and response handling. On Linux, this includes support for WebKit2GTK versions 36, 40, and 41, with specific handling for each version's API. The \Request\ interface abstracts away platform-specific details, allowing the asset server to handle HTTP-like requests from the webview in a standardized way.

v2/pkg/assetserver/webview · high confidence

The Linux build assets now target GTK4 and WebKitGTK 6.0 as the default runtime dependencies for Linux packages. The nfpm configuration has been updated to include these new dependencies, with specific overrides for RPM (Fedora/RHEL) and Arch Linux distributions. Additionally, a new desktop template is generated that includes support for custom URL protocols, allowing the application to handle specific URL schemes.

_v3/internal/commands/updatable\_build\assets/linux · high confidence

The binding example in v3/examples/binding/assets has been updated to a new HTML structure with embedded CSS for styling. The file index.html was added/modified to include a complete HTML5 document with head and body sections, defining styles for the page background, typography, and button components. This reflects the implementation of the basic binding example, aligning the frontend assets with the updated binding generator and runtime API changes.

v3/examples/binding/assets · medium confidence

The bundled JavaScript runtime has been updated to version 3.0.0-alpha.92, introducing support for native macOS titlebar double-click, Android platform support, and chunked IPC payloads to bypass WebView2's 2 MB body limit. The update also includes fixes for Linux resize and scrollbar detection, Windows custom hit-test logic, and error handling improvements where errors are now returned as dedicated Error objects instead of stringified JSON.

v3/internal/assetserver/bundledassets · high confidence

The context menu example has been updated to demonstrate the new default context menu behavior, which is now enabled for certain elements by default. The example showcases how to use the \--default-contextmenu\ CSS property to show, hide, or enable smart (auto) context menus. It also includes a copy-to-clipboard feature and demonstrates context menu behavior on disabled and read-only inputs.

v3/examples/contextmenus/assets · medium confidence

The default Wails project template has been updated with a new set of base files, including a Go application structure, frontend assets, and platform-specific build scripts. Users generating a new project will now receive a more complete starting point, including scripts for building on macOS (ARM, Intel, and Universal), Windows, and a generic build script, as well as updated Go and frontend configurations.

v2/cmd/wails/internal/template · high confidence

The default project templates have been updated to use Go 1.23.0 and include improved Go and TypeScript type definitions for the runtime, such as \WindowSetAlwaysOnTop\ and \EventsOffAll\. Additionally, new IDE configuration templates for GoLand and VS Code have been added to streamline the development experience.

v2/pkg/templates · high confidence

The frontend build artifacts for the badge example have been updated. The main JavaScript bundle (index-CtfGGYXM.js) now includes a module preload polyfill, a runtime caller for Wails IPC, and handlers for context menus and window dragging. The HTML entry point and CSS styles have been refreshed to support the new UI, and the TypeScript logo asset has been added to the distribution.

v3/examples/badge/frontend/dist · high confidence

The macOS build configuration now requires macOS 12.0 or later. This change is reflected in the Info.plist and Info.dev.plist files, which set the minimum system version to 12.0.0, and in the Taskfile.yml, which sets the deployment target via environment variables and compiler flags.

v3/examples/notifications/build/darwin · high confidence

The v2 templates for Lit (TypeScript and JS), Vue (JS and TS), and plain HTML/JS now include explicit style imports and updated font licensing. Specifically, each template's main component or entry point now imports its corresponding \style.css\ file (e.g., \import './style.css'\ in Lit and Vue templates, or \\<link\>\ in plain HTML) to ensure consistent styling. Additionally, an \OFL.txt\ file containing the SIL Open Font License for the Nunito font has been added to the assets of every template, ensuring proper attribution and licensing for the included font files.

(repo-wide) · high confidence

The Wails CLI now reads its version string from an embedded text file (version.txt) rather than a hardcoded string. This change allows the version to be updated simply by modifying the text file, which is useful for automated release processes and ensures the CLI reports the correct version without requiring code changes for each release.

v2/cmd/wails/internal · high confidence

The Wails CLI has been restructured into distinct command files (build, dev, doctor, generate, init, show, update) with improved output handling. The \wails doctor\ command now provides deeper system diagnostics, including CPU, GPU, and memory details, with a fix for a nil pointer error when GPU device info is missing. The \wails update\ command has been ported to support automatic version updates and pre-release checks. The \wails generate\ command now supports generating modules and templates, while \wails init\ has been updated to change the default module name to the project name. Additionally, the CLI now supports build tags, obfuscation settings, and various UI improvements like spinner usage and ANSI color support.

v2/cmd/wails · medium confidence

The Windows NSIS installer template has been updated to allow users to choose a per-user installation scope. This change enables the installer to place application files in the user's local AppData directory instead of the global Program Files directory, which allows installation without requiring administrator privileges or triggering a UAC prompt.

_v3/internal/commands/build\assets/windows/nsis · medium confidence

The Windows build configuration for the notifications example has been updated to allow installing the application in the user's local AppData folder rather than the global Program Files directory. This change, implemented via the new \wails\_tools.nsh\ and \project.nsi\ files, enables a per-user install scope which avoids requiring administrator privileges and eliminates the UAC prompt during installation.

v3/examples/notifications/build/windows · medium confidence

The Windows build process now includes an info.json template and a wails.exe.manifest file. The manifest configures the application to use Windows Common Controls v6 and sets DPI awareness to 'permonitorv2' (with fallbacks), which resolves a DPI scaling bug on Windows. This ensures proper high-DPI rendering and modern UI control behavior for Windows executables.

v2/pkg/buildassets/build/windows · medium confidence

The macOS application bundle templates (Info.plist and Info.dev.plist) have been updated to set the minimum supported macOS version to 12.0. Additionally, the generated app bundles now include configuration for file associations (CFBundleDocumentTypes) and custom URL schemes (CFBundleURLTypes), enabling the application to handle specific file types and register for custom protocol handlers.

_v3/internal/commands/updatable\_build\assets/darwin · high confidence

The build assets are now managed through a centralized Go package that embeds default project assets and handles file resolution. This introduces a new \safeBundleID\ function that sanitizes bundle identifiers by converting them to lowercase, replacing non-alphanumeric characters with hyphens, and trimming the result, ensuring compliance with platform requirements (such as Apple's). The \ReadFile\ and \ReadFileWithProjectData\ functions now support fallback to embedded assets when local build files are missing, and the \safeBundleID\ logic is covered by new unit tests.

v2/pkg/buildassets · medium confidence

The JavaScript binding generator has been updated to correctly handle complex type scenarios that previously caused errors or incorrect output. Specifically, the generator now properly processes type aliases (including generic and sub-package aliases), complex JSON structures with nested and shadowed fields, and cyclic type references. This ensures that generated JavaScript code for services and models accurately reflects the Go types, including correct handling of nullable types, maps, arrays, and recursive structures.

v3/internal/generator/testdata/output · high confidence

On macOS, launching an app via a custom URL scheme previously failed to pass the URL to the first instance when a second instance was spawned. This was because the URL is delivered via an Apple Event rather than command-line arguments, and the event handler was not installed before the second instance exited. The fix adds a helper to capture the URL from the Apple Event and appends it to the data relayed to the first instance, ensuring the URL is correctly received in the \OnSecondInstanceLaunch\ callback.

v3/examples/single-instance-url-scheme · high confidence

The binding generator now correctly handles a wider variety of Go types in the generated TypeScript models. This includes proper support for nested anonymous structs, deep element nesting (arrays, maps, and structs), and Go generics. Additionally, enum ordering is now deterministic (alphabetical), and edge cases like empty structs, unexported fields, and conflicting package names are handled without errors.

_v2/internal/binding/binding\test · high confidence

Added benchmark and visibility test suites for Linux and Windows; Added manual test harnesses for event blocking, menu crashes, and file drop fixes; Added regression tests for macOS fullscreen, Windows focus-steal, and frontend directory sync; Expanded test coverage for the v3 binding generator.

The documentation site (docs) has been upgraded to Astro 6 and Starlight 0.38.4, along with associated tooling like @astrojs/check and React 19. Additionally, the Go dependencies for the customlayout and dragdrop-test examples have been updated to use Wails v2.10.1, with corresponding updates to go.mod and go.sum files to reflect the new version and indirect dependencies.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• First survey — no prior run to compare against. CAI 55.

• Code Health 74
• Architecture 100
• Maturity 69
• Readiness 58
• Security 65
• Accessibility 44

• 300 commits — 188 feature/other, 112 fixes

• v3/UNRELEASED_CHANGELOG.md — 79 commits
• docs/src — 44 commits
• (repo) — 38 commits
• v3/pkg — 38 commits
• v3/internal — 25 commits
• website/static — 21 commits
• .github/workflows — 18 commits
• v3/examples — 8 commits
• (root) — 6 commits
• docs/public — 3 commits
• website/i18n — 3 commits
• .release/v3.0.0-beta.0 — 2 commits
• docs/astro.config.mjs — 2 commits
• website/docs — 2 commits
• website/docusaurus.config.js — 2 commits
• .github/ISSUE_TEMPLATE — 1 commit
• docs/.node-version — 1 commit
• tools/sponsorkit — 1 commit
• v2/examples — 1 commit
• v2/internal — 1 commit

• fix: Fix/linux dark mode flash (#5899)
• fix: Fix/linux isvisible before widget (#5898)
• fix: Fix/mac background app focus steal (#5897)
• fix: Merge branch 'master' into fix-no-hover-events-when-enableFileDrop
• fix: Merge branch 'master' into fix/custom-event-order
• fix: Merge branch 'master' into fix/sytemtray-panic
• fix: Merge branch 'master' into fix/sytemtray-panic
• fix: Merge branch 'master' into fix/sytemtray-panic
• fix: Merge branch 'master' into fix/sytemtray-panic
• fix: Merge branch 'master' into fix/sytemtray-panic
• fix: Merge branch 'master' into fix/sytemtray-panic
• fix: Merge pull request #5703 from wayneforrest/fix/sytemtray-panic
• fix: Merge pull request #5772 from Etesam913/fix-no-hover-events-when-enableFileDrop
• fix: Merge pull request #5851 from savely-krasovsky/fix/custom-event-order
• fix: Merge pull request #5865 from wailsapp/fix/linux-blob-fetch-headers
• fix: Revert "i18n(de): add German translations 2026-05-11 (#5396)" (#5702)
• fix: [v3] fix: (Windows OS) DnD dropzone detection failing at non-100% display scaling (#4632)
• fix: [v3][windows] Re-enable WebView2 monitor-scale detection to fix mixed-DPI GPU-process crash (#5732) (#5734)
• fix: chore(.github): accept v3 bug reports, add triage dropdowns, wire up auto-labelers (#5754)
• fix: chore(changelog): auto-add entry for PR #4435 — fix: prevent crash when closing window with pending async calls
• …and 280 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

wailsapp/wails was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.