The application API assists in creating an application using the Wails +framework.
+API: New(appOptions Options) *App
New(appOptions Options) creates a new application using the given application
+options . It applies default values for unspecified options, merges them with
+the provided ones, initializes and returns an instance of the application.
In case of an error during initialization, the application is stopped with the +error message provided.
+It should be noted that if a global application instance already exists, that +instance will be returned instead of creating a new one.
+package main
+
+import "github.com/wailsapp/wails/v3/pkg/application"
+
+func main() {
+ app := application.New(application.Options{
+ Name: "WebviewWindow Demo",
+ // Other options
+ })
+
+ // Rest of application
+}
+Get() returns the global application instance. It's useful when you need to
+access the application from different parts of your code.
API: Capabilities() capabilities.Capabilities
Capabilities() retrieves a map of capabilities that the application currently
+has. Capabilities can be about different features the operating system provides,
+like webview features.
// Get the application capabilities
+ capabilities := app.Capabilities()
+ if capabilities.HasNativeDrag {
+ // Do something
+ }
+API: GetPID() int
GetPID() returns the Process ID of the application.
API: Run() error
Run() starts the execution of the application and its components.
app := application.New(application.Options{
+ //options
+ })
+ // Run the application
+ err := application.Run()
+ if err != nil {
+ // Handle error
+ }
+API: Quit()
Quit() quits the application by destroying windows and potentially other
+components.
API: IsDarkMode() bool
IsDarkMode() checks if the application is running in dark mode. It returns a
+boolean indicating whether dark mode is enabled.
API: Hide()
Hide() hides the application window.
API: Show()
Show() shows the application window.
API: NewWebviewWindow() *WebviewWindow
NewWebviewWindow() creates a new Webview window with default options, and
+returns it.
API:
+NewWebviewWindowWithOptions(windowOptions WebviewWindowOptions) *WebviewWindow
NewWebviewWindowWithOptions() creates a new webview window with custom
+options. The newly created window is added to a map of windows managed by the
+application.
// Create a new webview window with custom options
+ window := app.NewWebviewWindowWithOptions(WebviewWindowOptions{
+ Name: "Main",
+ Title: "My Window",
+ Width: 800,
+ Height: 600,
+ })
+API: OnWindowCreation(callback func(window *WebviewWindow))
OnWindowCreation() registers a callback function to be called when a window is
+created.
// Register a callback to be called when a window is created
+ app.OnWindowCreation(func(window *WebviewWindow) {
+ // Do something
+ })
+API: GetWindowByName(name string) *WebviewWindow
GetWindowByName() fetches and returns a window with a specific name.
API: CurrentWindow() *WebviewWindow
CurrentWindow() fetches and returns a pointer to the currently active window
+in the application. If there is no window, it returns nil.
API: RegisterContextMenu(name string, menu *Menu)
RegisterContextMenu() registers a context menu with a given name. This menu
+can be used later in the application.
// Create a new menu
+ ctxmenu := app.NewMenu()
+
+ // Register the menu as a context menu
+ app.RegisterContextMenu("MyContextMenu", ctxmenu)
+API: SetMenu(menu *Menu)
SetMenu() sets the menu for the application. On Mac, this will be the global
+menu. For Windows and Linux, this will be the default menu for any new window
+created.
// Create a new menu
+ menu := app.NewMenu()
+
+ // Set the menu for the application
+ app.SetMenu(menu)
+API: ShowAboutDialog()
ShowAboutDialog() shows an "About" dialog box. It can show the application's
+name, description and icon.
API: InfoDialog()
InfoDialog() creates and returns a new instance of MessageDialog with an
+InfoDialogType. This dialog is typically used to display informational
+messages to the user.
API: QuestionDialog()
QuestionDialog() creates and returns a new instance of MessageDialog with a
+QuestionDialogType. This dialog is often used to ask a question to the user
+and expect a response.
API: WarningDialog()
WarningDialog() creates and returns a new instance of MessageDialog with a
+WarningDialogType. As the name suggests, this dialog is primarily used to
+display warning messages to the user.
API: ErrorDialog()
ErrorDialog() creates and returns a new instance of MessageDialog with an
+ErrorDialogType. This dialog is designed to be used when you need to display
+an error message to the user.
API: OpenFileDialog()
OpenFileDialog() creates and returns a new OpenFileDialogStruct. This dialog
+prompts the user to select one or more files from their file system.
API: SaveFileDialog()
SaveFileDialog() creates and returns a new SaveFileDialogStruct. This dialog
+prompts the user to choose a location on their file system where a file should
+be saved.
API: OpenDirectoryDialog()
OpenDirectoryDialog() creates and returns a new instance of MessageDialog
+with an OpenDirectoryDialogType. This dialog enables the user to choose a
+directory from their file system.
API:
+On(eventType events.ApplicationEventType, callback func(event *Event)) func()
On() registers an event listener for specific application events. The callback
+function provided will be triggered when the corresponding event occurs. The
+function returns a function that can be called to remove the listener.
API:
+RegisterHook(eventType events.ApplicationEventType, callback func(event *Event)) func()
RegisterHook() registers a callback to be run as a hook during specific
+events. These hooks are run before listeners attached with On(). The function
+returns a function that can be called to remove the hook.
API: GetPrimaryScreen() (*Screen, error)
GetPrimaryScreen() returns the primary screen of the system.
API: GetScreens() ([]*Screen, error)
GetScreens() returns information about all screens attached to the system.
This is a brief summary of the exported methods in the provided App struct. Do
+note that for more detailed functionality or considerations, refer to the actual
+Go code or further internal documentation.
package application
+
+import (
+ "io/fs"
+ "log/slog"
+ "net/http"
+)
+
+type Options struct {
+ // Name is the name of the application (used in the default about box)
+ Name string
+
+ // Description is the description of the application (used in the default about box)
+ Description string
+
+ // Icon is the icon of the application (used in the default about box)
+ Icon []byte
+
+ // Mac is the Mac specific configuration for Mac builds
+ Mac MacOptions
+
+ // Windows is the Windows specific configuration for Windows builds
+ Windows WindowsOptions
+
+ // Bind allows you to bind Go methods to the frontend.
+ Bind []any
+
+ // BindAliases allows you to specify alias IDs for your bound methods.
+ // Example: `BindAliases: map[uint32]uint32{1: 1411160069}` states that alias ID 1 maps to the Go method with ID 1411160069.
+ BindAliases map[uint32]uint32
+
+ // Logger i a slog.Logger instance used for logging Wails system messages (not application messages).
+ // If not defined, a default logger is used.
+ Logger *slog.Logger
+
+ // LogLevel defines the log level of the Wails system logger.
+ LogLevel slog.Level
+
+ // Assets are the application assets to be used.
+ Assets AssetOptions
+
+ // Plugins is a map of plugins used by the application
+ Plugins map[string]Plugin
+
+ // Flags are key value pairs that are available to the frontend.
+ // This is also used by Wails to provide information to the frontend.
+ Flags map[string]any
+
+ // PanicHandler is called when a panic occurs
+ PanicHandler func(any)
+
+ // DisableDefaultSignalHandler disables the default signal handler
+ DisableDefaultSignalHandler bool
+
+ // KeyBindings is a map of key bindings to functions
+ KeyBindings map[string]func(window *WebviewWindow)
+
+ // OnShutdown is called when the application is about to terminate.
+ // This is useful for cleanup tasks.
+ // The shutdown process blocks until this function returns
+ OnShutdown func()
+
+ // ShouldQuit is a function that is called when the user tries to quit the application.
+ // If the function returns true, the application will quit.
+ // If the function returns false, the application will not quit.
+ ShouldQuit func() bool
+}
+
+// AssetOptions defines the configuration of the AssetServer.
+type AssetOptions struct {
+ // FS defines the static assets to be used. A GET request is first tried to be served from this FS. If the FS returns
+ // `os.ErrNotExist` for that file, the request handling will fallback to the Handler and tries to serve the GET
+ // request from it.
+ //
+ // If set to nil, all GET requests will be forwarded to Handler.
+ FS fs.FS
+
+ // Handler will be called for every GET request that can't be served from FS, due to `os.ErrNotExist`. Furthermore all
+ // non GET requests will always be served from this Handler.
+ //
+ // If not defined, the result is the following in cases where the Handler would have been called:
+ // GET request: `http.StatusNotFound`
+ // Other request: `http.StatusMethodNotAllowed`
+ Handler http.Handler
+
+ // Middleware is HTTP Middleware which allows to hook into the AssetServer request chain. It allows to skip the default
+ // request handler dynamically, e.g. implement specialized Routing etc.
+ // The Middleware is called to build a new `http.Handler` used by the AssetSever and it also receives the default
+ // handler used by the AssetServer as an argument.
+ //
+ // If not defined, the default AssetServer request chain is executed.
+ //
+ // Multiple Middlewares can be chained together with:
+ // ChainMiddleware(middleware ...Middleware) Middleware
+ Middleware Middleware
+
+ // DisableLogging disables logging of the AssetServer. By default, the AssetServer logs every request.
+ DisableLogging bool
+}
+
+// Middleware defines HTTP middleware that can be applied to the AssetServer.
+// The handler passed as next is the next handler in the chain. One can decide to call the next handler
+// or implement a specialized handling.
+type Middleware func(next http.Handler) http.Handler
+
+// ChainMiddleware allows chaining multiple middlewares to one middleware.
+func ChainMiddleware(middleware ...Middleware) Middleware {
+ return func(h http.Handler) http.Handler {
+ for i := len(middleware) - 1; i >= 0; i-- {
+ h = middleware[i](h)
+ }
+ return h
+ }
+}
+package application
+
+// WindowsOptions contains options for Windows applications.
+type WindowsOptions struct {
+
+ // WndProcInterceptor is a function that will be called for every message sent in the application.
+ // Use this to hook into the main message loop. This is useful for handling custom window messages.
+ // If `shouldReturn` is `true` then `returnCode` will be returned by the main message loop.
+ // If `shouldReturn` is `false` then returnCode will be ignored and the message will be processed by the main message loop.
+ WndProcInterceptor func(hwnd uintptr, msg uint32, wParam, lParam uintptr) (returnCode uintptr, shouldReturn bool)
+
+ // DisableQuitOnLastWindowClosed disables the auto quit of the application if the last window has been closed.
+ DisableQuitOnLastWindowClosed bool
+
+ // Path where the WebView2 stores the user data. If empty %APPDATA%\[BinaryName.exe] will be used.
+ // If the path is not valid, a messagebox will be displayed with the error and the app will exit with error code.
+ WebviewUserDataPath string
+
+ // Path to the directory with WebView2 executables. If empty WebView2 installed in the system will be used.
+ WebviewBrowserPath string
+}
+package application
+
+// ActivationPolicy is the activation policy for the application.
+type ActivationPolicy int
+
+const (
+ // ActivationPolicyRegular is used for applications that have a user interface,
+ ActivationPolicyRegular ActivationPolicy = iota
+ // ActivationPolicyAccessory is used for applications that do not have a main window,
+ // such as system tray applications or background applications.
+ ActivationPolicyAccessory
+ ActivationPolicyProhibited
+)
+
+// MacOptions contains options for macOS applications.
+type MacOptions struct {
+ // ActivationPolicy is the activation policy for the application. Defaults to
+ // applicationActivationPolicyRegular.
+ ActivationPolicy ActivationPolicy
+ // If set to true, the application will terminate when the last window is closed.
+ ApplicationShouldTerminateAfterLastWindowClosed bool
+}
+const (
+ DialogInfo = 0
+ DialogWarning = 1
+ DialogError = 2
+ DialogQuestion = 3
+ DialogOpenFile = 4
+ DialogSaveFile = 5
+)
+const (
+ WindowCenter = 0
+ WindowSetTitle = 1
+ WindowFullscreen = 2
+ WindowUnFullscreen = 3
+ WindowSetSize = 4
+ WindowSize = 5
+ WindowSetMaxSize = 6
+ WindowSetMinSize = 7
+ WindowSetAlwaysOnTop = 8
+ WindowSetRelativePosition = 9
+ WindowRelativePosition = 10
+ WindowScreen = 11
+ WindowHide = 12
+ WindowMaximise = 13
+ WindowUnMaximise = 14
+ WindowToggleMaximise = 15
+ WindowMinimise = 16
+ WindowUnMinimise = 17
+ WindowRestore = 18
+ WindowShow = 19
+ WindowClose = 20
+ WindowSetBackgroundColour = 21
+ WindowSetResizable = 22
+ WindowWidth = 23
+ WindowHeight = 24
+ WindowZoomIn = 25
+ WindowZoomOut = 26
+ WindowZoomReset = 27
+ WindowGetZoomLevel = 28
+ WindowSetZoomLevel = 29
+)
+const (
+ NSImageNone = iota
+ NSImageOnly
+ NSImageLeft
+ NSImageRight
+ NSImageBelow
+ NSImageAbove
+ NSImageOverlaps
+ NSImageLeading
+ NSImageTrailing
+)
+BuildInfo contains the build info for the application
+ +BuildSettings contains the build settings for the +application
+ +MacTitleBarDefault results in the default Mac +MacTitleBar
+var MacTitleBarDefault = MacTitleBar{
+ AppearsTransparent: false,
+ Hide: false,
+ HideTitle: false,
+ FullSizeContent: false,
+ UseToolbar: false,
+ HideToolbarSeparator: false,
+}
+MacTitleBarHidden results in a hidden title bar +and a full size content window, yet the title bar still has the standard window +controls (“traffic lights”) in the top left.
+var MacTitleBarHidden = MacTitleBar{
+ AppearsTransparent: true,
+ Hide: false,
+ HideTitle: true,
+ FullSizeContent: true,
+ UseToolbar: false,
+ HideToolbarSeparator: false,
+}
+MacTitleBarHiddenInset results in a hidden +title bar with an alternative look where the traffic light buttons are slightly +more inset from the window edge.
+var MacTitleBarHiddenInset = MacTitleBar{
+ AppearsTransparent: true,
+ Hide: false,
+ HideTitle: true,
+ FullSizeContent: true,
+ UseToolbar: true,
+ HideToolbarSeparator: true,
+}
+MacTitleBarHiddenInsetUnified +results in a hidden title bar with an alternative look where the traffic light +buttons are even more inset from the window edge.
+var MacTitleBarHiddenInsetUnified = MacTitleBar{
+ AppearsTransparent: true,
+ Hide: false,
+ HideTitle: true,
+ FullSizeContent: true,
+ UseToolbar: true,
+ HideToolbarSeparator: true,
+ ToolbarStyle: MacToolbarStyleUnified,
+}
+var VirtualKeyCodes = map[uint]string{
+ 0x01: "lbutton",
+ 0x02: "rbutton",
+ 0x03: "cancel",
+ 0x04: "mbutton",
+ 0x05: "xbutton1",
+ 0x06: "xbutton2",
+ 0x08: "back",
+ 0x09: "tab",
+ 0x0C: "clear",
+ 0x0D: "return",
+ 0x10: "shift",
+ 0x11: "control",
+ 0x12: "menu",
+ 0x13: "pause",
+ 0x14: "capital",
+ 0x15: "kana",
+ 0x17: "junja",
+ 0x18: "final",
+ 0x19: "hanja",
+ 0x1B: "escape",
+ 0x1C: "convert",
+ 0x1D: "nonconvert",
+ 0x1E: "accept",
+ 0x1F: "modechange",
+ 0x20: "space",
+ 0x21: "prior",
+ 0x22: "next",
+ 0x23: "end",
+ 0x24: "home",
+ 0x25: "left",
+ 0x26: "up",
+ 0x27: "right",
+ 0x28: "down",
+ 0x29: "select",
+ 0x2A: "print",
+ 0x2B: "execute",
+ 0x2C: "snapshot",
+ 0x2D: "insert",
+ 0x2E: "delete",
+ 0x2F: "help",
+ 0x30: "0",
+ 0x31: "1",
+ 0x32: "2",
+ 0x33: "3",
+ 0x34: "4",
+ 0x35: "5",
+ 0x36: "6",
+ 0x37: "7",
+ 0x38: "8",
+ 0x39: "9",
+ 0x41: "a",
+ 0x42: "b",
+ 0x43: "c",
+ 0x44: "d",
+ 0x45: "e",
+ 0x46: "f",
+ 0x47: "g",
+ 0x48: "h",
+ 0x49: "i",
+ 0x4A: "j",
+ 0x4B: "k",
+ 0x4C: "l",
+ 0x4D: "m",
+ 0x4E: "n",
+ 0x4F: "o",
+ 0x50: "p",
+ 0x51: "q",
+ 0x52: "r",
+ 0x53: "s",
+ 0x54: "t",
+ 0x55: "u",
+ 0x56: "v",
+ 0x57: "w",
+ 0x58: "x",
+ 0x59: "y",
+ 0x5A: "z",
+ 0x5B: "lwin",
+ 0x5C: "rwin",
+ 0x5D: "apps",
+ 0x5F: "sleep",
+ 0x60: "numpad0",
+ 0x61: "numpad1",
+ 0x62: "numpad2",
+ 0x63: "numpad3",
+ 0x64: "numpad4",
+ 0x65: "numpad5",
+ 0x66: "numpad6",
+ 0x67: "numpad7",
+ 0x68: "numpad8",
+ 0x69: "numpad9",
+ 0x6A: "multiply",
+ 0x6B: "add",
+ 0x6C: "separator",
+ 0x6D: "subtract",
+ 0x6E: "decimal",
+ 0x6F: "divide",
+ 0x70: "f1",
+ 0x71: "f2",
+ 0x72: "f3",
+ 0x73: "f4",
+ 0x74: "f5",
+ 0x75: "f6",
+ 0x76: "f7",
+ 0x77: "f8",
+ 0x78: "f9",
+ 0x79: "f10",
+ 0x7A: "f11",
+ 0x7B: "f12",
+ 0x7C: "f13",
+ 0x7D: "f14",
+ 0x7E: "f15",
+ 0x7F: "f16",
+ 0x80: "f17",
+ 0x81: "f18",
+ 0x82: "f19",
+ 0x83: "f20",
+ 0x84: "f21",
+ 0x85: "f22",
+ 0x86: "f23",
+ 0x87: "f24",
+ 0x88: "navigation_view",
+ 0x89: "navigation_menu",
+ 0x8A: "navigation_up",
+ 0x8B: "navigation_down",
+ 0x8C: "navigation_left",
+ 0x8D: "navigation_right",
+ 0x8E: "navigation_accept",
+ 0x8F: "navigation_cancel",
+ 0x90: "numlock",
+ 0x91: "scroll",
+ 0x92: "oem_nec_equal",
+ 0x93: "oem_fj_masshou",
+ 0x94: "oem_fj_touroku",
+ 0x95: "oem_fj_loya",
+ 0x96: "oem_fj_roya",
+ 0xA0: "lshift",
+ 0xA1: "rshift",
+ 0xA2: "lcontrol",
+ 0xA3: "rcontrol",
+ 0xA4: "lmenu",
+ 0xA5: "rmenu",
+ 0xA6: "browser_back",
+ 0xA7: "browser_forward",
+ 0xA8: "browser_refresh",
+ 0xA9: "browser_stop",
+ 0xAA: "browser_search",
+ 0xAB: "browser_favorites",
+ 0xAC: "browser_home",
+ 0xAD: "volume_mute",
+ 0xAE: "volume_down",
+ 0xAF: "volume_up",
+ 0xB0: "media_next_track",
+ 0xB1: "media_prev_track",
+ 0xB2: "media_stop",
+ 0xB3: "media_play_pause",
+ 0xB4: "launch_mail",
+ 0xB5: "launch_media_select",
+ 0xB6: "launch_app1",
+ 0xB7: "launch_app2",
+ 0xBA: "oem_1",
+ 0xBB: "oem_plus",
+ 0xBC: "oem_comma",
+ 0xBD: "oem_minus",
+ 0xBE: "oem_period",
+ 0xBF: "oem_2",
+ 0xC0: "oem_3",
+ 0xC3: "gamepad_a",
+ 0xC4: "gamepad_b",
+ 0xC5: "gamepad_x",
+ 0xC6: "gamepad_y",
+ 0xC7: "gamepad_right_shoulder",
+ 0xC8: "gamepad_left_shoulder",
+ 0xC9: "gamepad_left_trigger",
+ 0xCA: "gamepad_right_trigger",
+ 0xCB: "gamepad_dpad_up",
+ 0xCC: "gamepad_dpad_down",
+ 0xCD: "gamepad_dpad_left",
+ 0xCE: "gamepad_dpad_right",
+ 0xCF: "gamepad_menu",
+ 0xD0: "gamepad_view",
+ 0xD1: "gamepad_left_thumbstick_button",
+ 0xD2: "gamepad_right_thumbstick_button",
+ 0xD3: "gamepad_left_thumbstick_up",
+ 0xD4: "gamepad_left_thumbstick_down",
+ 0xD5: "gamepad_left_thumbstick_right",
+ 0xD6: "gamepad_left_thumbstick_left",
+ 0xD7: "gamepad_right_thumbstick_up",
+ 0xD8: "gamepad_right_thumbstick_down",
+ 0xD9: "gamepad_right_thumbstick_right",
+ 0xDA: "gamepad_right_thumbstick_left",
+ 0xDB: "oem_4",
+ 0xDC: "oem_5",
+ 0xDD: "oem_6",
+ 0xDE: "oem_7",
+ 0xDF: "oem_8",
+ 0xE1: "oem_ax",
+ 0xE2: "oem_102",
+ 0xE3: "ico_help",
+ 0xE4: "ico_00",
+ 0xE5: "processkey",
+ 0xE6: "ico_clear",
+ 0xE7: "packet",
+ 0xE9: "oem_reset",
+ 0xEA: "oem_jump",
+ 0xEB: "oem_pa1",
+ 0xEC: "oem_pa2",
+ 0xED: "oem_pa3",
+ 0xEE: "oem_wsctrl",
+ 0xEF: "oem_cusel",
+ 0xF0: "oem_attn",
+ 0xF1: "oem_finish",
+ 0xF2: "oem_copy",
+ 0xF3: "oem_auto",
+ 0xF4: "oem_enlw",
+ 0xF5: "oem_backtab",
+ 0xF6: "attn",
+ 0xF7: "crsel",
+ 0xF8: "exsel",
+ 0xF9: "ereof",
+ 0xFA: "play",
+ 0xFB: "zoom",
+ 0xFC: "noname",
+ 0xFD: "pa1",
+ 0xFE: "oem_clear",
+}
+var WebviewWindowDefaults = &WebviewWindowOptions{
+ Title: "",
+ Width: 800,
+ Height: 600,
+ URL: "",
+ BackgroundColour: RGBA{
+ Red: 255,
+ Green: 255,
+ Blue: 255,
+ Alpha: 255,
+ },
+}
+ActivationPolicy is the activation policy for the application.
+ + +const (
+ // ActivationPolicyRegular is used for applications that have a user interface,
+ ActivationPolicyRegular ActivationPolicy = iota
+ // ActivationPolicyAccessory is used for applications that do not have a main window,
+ // such as system tray applications or background applications.
+ ActivationPolicyAccessory
+ ActivationPolicyProhibited
+)
+type App struct {
+
+ // The main application menu
+ ApplicationMenu *Menu
+
+ Events *EventProcessor
+ Logger *slog.Logger
+ // contains filtered or unexported fields
+}
+func (a *App) RegisterHook(eventType events.ApplicationEventType, callback func(event *Event)) func()
+RegisterHook registers a hook for the given event type. Hooks are called before +the event listeners and can cancel the event. The returned function can be +called to remove the hook.
+ +AssetOptions defines the configuration of the AssetServer.
+type AssetOptions struct {
+ // FS defines the static assets to be used. A GET request is first tried to be served from this FS. If the FS returns
+ // `os.ErrNotExist` for that file, the request handling will fallback to the Handler and tries to serve the GET
+ // request from it.
+ //
+ // If set to nil, all GET requests will be forwarded to Handler.
+ FS fs.FS
+
+ // Handler will be called for every GET request that can't be served from FS, due to `os.ErrNotExist`. Furthermore all
+ // non GET requests will always be served from this Handler.
+ //
+ // If not defined, the result is the following in cases where the Handler would have been called:
+ // GET request: `http.StatusNotFound`
+ // Other request: `http.StatusMethodNotAllowed`
+ Handler http.Handler
+
+ // Middleware is HTTP Middleware which allows to hook into the AssetServer request chain. It allows to skip the default
+ // request handler dynamically, e.g. implement specialized Routing etc.
+ // The Middleware is called to build a new `http.Handler` used by the AssetSever and it also receives the default
+ // handler used by the AssetServer as an argument.
+ //
+ // If not defined, the default AssetServer request chain is executed.
+ //
+ // Multiple Middlewares can be chained together with:
+ // ChainMiddleware(middleware ...Middleware) Middleware
+ Middleware Middleware
+
+ // External URL can be set to a development server URL so that all requests are forwarded to it. This is useful
+ // when using a development server like `vite` or `snowpack` which serves the assets on a different port.
+ ExternalURL string
+}
+const (
+ Auto BackdropType = 0
+ None BackdropType = 1
+ Mica BackdropType = 2
+ Acrylic BackdropType = 3
+ Tabbed BackdropType = 4
+)
+const (
+ BackgroundTypeSolid BackgroundType = iota
+ BackgroundTypeTransparent
+ BackgroundTypeTranslucent
+)
+Add the given struct methods to the Bindings
+ +GenerateID generates a unique ID for a binding
+ +Get returns the bound method with the given name
+ +GetByID returns the bound method with the given ID
+ +BoundMethod defines all the data related to a Go method that is bound to the +Wails application
+type BoundMethod struct {
+ ID uint32 `json:"id"`
+ Name string `json:"name"`
+ Inputs []*Parameter `json:"inputs,omitempty"`
+ Outputs []*Parameter `json:"outputs,omitempty"`
+ Comments string `json:"comments,omitempty"`
+ Method reflect.Value `json:"-"`
+ PackageName string
+ StructName string
+ PackagePath string
+}
+Call will attempt to call this bound method with the given args
+ +type CallOptions struct {
+ MethodID uint32 `json:"methodID"`
+ PackageName string `json:"packageName"`
+ StructName string `json:"structName"`
+ MethodName string `json:"methodName"`
+ Args []any `json:"args"`
+}
+type ContextMenuData struct {
+ Id string `json:"id"`
+ X int `json:"x"`
+ Y int `json:"y"`
+ Data any `json:"data"`
+}
+const (
+ InfoDialogType DialogType = iota
+ QuestionDialogType
+ WarningDialogType
+ ErrorDialogType
+ OpenDirectoryDialogType
+)
+EventProcessor handles custom events
+ + +Emit sends an event to all listeners
+ +On is the equivalent of Javascript's `addEventListener`
+ +func (e *EventProcessor) OnMultiple(eventName string, callback func(event *WailsEvent), counter int) func()
+OnMultiple is the same as `On` but will unregister after `count` events
+ +Once is the same as `On` but will unregister after the first event
+ +RegisterHook provides a means of registering methods to be called before +emitting the event
+ +type FileFilter struct {
+ DisplayName string // Filter information EG: "Image Files (*.jpg, *.png)"
+ Pattern string // semicolon separated list of extensions, EG: "*.jpg;*.png"
+}
+MacAppearanceType is a type of Appearance for Cocoa windows
+ + +const (
+ // DefaultAppearance uses the default system value
+ DefaultAppearance MacAppearanceType = ""
+ // NSAppearanceNameAqua - The standard light system appearance.
+ NSAppearanceNameAqua MacAppearanceType = "NSAppearanceNameAqua"
+ // NSAppearanceNameDarkAqua - The standard dark system appearance.
+ NSAppearanceNameDarkAqua MacAppearanceType = "NSAppearanceNameDarkAqua"
+ // NSAppearanceNameVibrantLight - The light vibrant appearance
+ NSAppearanceNameVibrantLight MacAppearanceType = "NSAppearanceNameVibrantLight"
+ // NSAppearanceNameAccessibilityHighContrastAqua - A high-contrast version of the standard light system appearance.
+ NSAppearanceNameAccessibilityHighContrastAqua MacAppearanceType = "NSAppearanceNameAccessibilityHighContrastAqua"
+ // NSAppearanceNameAccessibilityHighContrastDarkAqua - A high-contrast version of the standard dark system appearance.
+ NSAppearanceNameAccessibilityHighContrastDarkAqua MacAppearanceType = "NSAppearanceNameAccessibilityHighContrastDarkAqua"
+ // NSAppearanceNameAccessibilityHighContrastVibrantLight - A high-contrast version of the light vibrant appearance.
+ NSAppearanceNameAccessibilityHighContrastVibrantLight MacAppearanceType = "NSAppearanceNameAccessibilityHighContrastVibrantLight"
+ // NSAppearanceNameAccessibilityHighContrastVibrantDark - A high-contrast version of the dark vibrant appearance.
+ NSAppearanceNameAccessibilityHighContrastVibrantDark MacAppearanceType = "NSAppearanceNameAccessibilityHighContrastVibrantDark"
+)
+MacBackdrop is the backdrop type for macOS
+ + +const (
+ // MacBackdropNormal - The default value. The window will have a normal opaque background.
+ MacBackdropNormal MacBackdrop = iota
+ // MacBackdropTransparent - The window will have a transparent background, with the content underneath it being visible
+ MacBackdropTransparent
+ // MacBackdropTranslucent - The window will have a translucent background, with the content underneath it being "fuzzy" or "frosted"
+ MacBackdropTranslucent
+)
+MacOptions contains options for macOS applications.
+type MacOptions struct {
+ // ActivationPolicy is the activation policy for the application. Defaults to
+ // applicationActivationPolicyRegular.
+ ActivationPolicy ActivationPolicy
+ // If set to true, the application will terminate when the last window is closed.
+ ApplicationShouldTerminateAfterLastWindowClosed bool
+}
+MacTitleBar contains options for the Mac titlebar
+type MacTitleBar struct {
+ // AppearsTransparent will make the titlebar transparent
+ AppearsTransparent bool
+ // Hide will hide the titlebar
+ Hide bool
+ // HideTitle will hide the title
+ HideTitle bool
+ // FullSizeContent will extend the window content to the full size of the window
+ FullSizeContent bool
+ // UseToolbar will use a toolbar instead of a titlebar
+ UseToolbar bool
+ // HideToolbarSeparator will hide the toolbar separator
+ HideToolbarSeparator bool
+ // ToolbarStyle is the style of toolbar to use
+ ToolbarStyle MacToolbarStyle
+}
+MacToolbarStyle is the style of toolbar for macOS
+ + +const (
+ // MacToolbarStyleAutomatic - The default value. The style will be determined by the window's given configuration
+ MacToolbarStyleAutomatic MacToolbarStyle = iota
+ // MacToolbarStyleExpanded - The toolbar will appear below the window title
+ MacToolbarStyleExpanded
+ // MacToolbarStylePreference - The toolbar will appear below the window title and the items in the toolbar will attempt to have equal widths when possible
+ MacToolbarStylePreference
+ // MacToolbarStyleUnified - The window title will appear inline with the toolbar when visible
+ MacToolbarStyleUnified
+ // MacToolbarStyleUnifiedCompact - Same as MacToolbarStyleUnified, but with reduced margins in the toolbar allowing more focus to be on the contents of the window
+ MacToolbarStyleUnifiedCompact
+)
+MacWindow contains macOS specific options for Webview Windows
+type MacWindow struct {
+ // Backdrop is the backdrop type for the window
+ Backdrop MacBackdrop
+ // DisableShadow will disable the window shadow
+ DisableShadow bool
+ // TitleBar contains options for the Mac titlebar
+ TitleBar MacTitleBar
+ // Appearance is the appearance type for the window
+ Appearance MacAppearanceType
+ // InvisibleTitleBarHeight defines the height of an invisible titlebar which responds to dragging
+ InvisibleTitleBarHeight int
+ // Maps events from platform specific to common event types
+ EventMapping map[events.WindowEventType]events.WindowEventType
+
+ // EnableFraudulentWebsiteWarnings will enable warnings for fraudulent websites.
+ // Default: false
+ EnableFraudulentWebsiteWarnings bool
+}
+type MessageDialogOptions struct {
+ DialogType DialogType
+ Title string
+ Message string
+ Buttons []*Button
+ Icon []byte
+ // contains filtered or unexported fields
+}
+Middleware defines HTTP middleware that can be applied to the AssetServer. The +handler passed as next is the next handler in the chain. One can decide to call +the next handler or implement a specialized handling.
+ + +ChainMiddleware allows chaining multiple middlewares to one middleware.
+ +type OpenFileDialogOptions struct {
+ CanChooseDirectories bool
+ CanChooseFiles bool
+ CanCreateDirectories bool
+ ShowHiddenFiles bool
+ ResolvesAliases bool
+ AllowsMultipleSelection bool
+ HideExtension bool
+ CanSelectHiddenExtension bool
+ TreatsFilePackagesAsDirectories bool
+ AllowsOtherFileTypes bool
+ Filters []FileFilter
+ Window *WebviewWindow
+
+ Title string
+ Message string
+ ButtonText string
+ Directory string
+}
+AddFilter adds a filter to the dialog. The filter is a display name and a +semicolon separated list of extensions. EG: AddFilter("Image Files", +"*.jpg;*.png")
+ +func (d *OpenFileDialogStruct) AllowsOtherFileTypes(allowsOtherFileTypes bool) *OpenFileDialogStruct
+func (d *OpenFileDialogStruct) CanChooseDirectories(canChooseDirectories bool) *OpenFileDialogStruct
+func (d *OpenFileDialogStruct) CanCreateDirectories(canCreateDirectories bool) *OpenFileDialogStruct
+func (d *OpenFileDialogStruct) CanSelectHiddenExtension(canSelectHiddenExtension bool) *OpenFileDialogStruct
+func (d *OpenFileDialogStruct) TreatsFilePackagesAsDirectories(treatsFilePackagesAsDirectories bool) *OpenFileDialogStruct
+type Options struct {
+ // Name is the name of the application
+ Name string
+
+ // Description is the description of the application (used in the default about box)
+ Description string
+
+ // Icon is the icon of the application (used in the default about box)
+ Icon []byte
+
+ // Mac is the Mac specific configuration for Mac builds
+ Mac MacOptions
+
+ // Windows is the Windows specific configuration for Windows builds
+ Windows WindowsOptions
+
+ // Bind allows you to bind Go methods to the frontend.
+ Bind []any
+
+ // BindAliases allows you to specify alias IDs for your bound methods.
+ // Example: `BindAliases: map[uint32]uint32{1: 1411160069}` states that alias ID 1 maps to the Go method with ID 1411160069.
+ BindAliases map[uint32]uint32
+
+ // Logger i a slog.Logger instance used for logging Wails system messages (not application messages).
+ // If not defined, a default logger is used.
+ Logger *slog.Logger
+
+ // LogLevel defines the log level of the Wails system logger.
+ LogLevel slog.Level
+
+ // Assets are the application assets to be used.
+ Assets AssetOptions
+
+ // Plugins is a map of plugins used by the application
+ Plugins map[string]Plugin
+
+ // Flags are key value pairs that are available to the frontend.
+ // This is also used by Wails to provide information to the frontend.
+ Flags map[string]any
+
+ // PanicHandler is a way to register a custom panic handler
+ PanicHandler func(any)
+
+ // KeyBindings is a map of key bindings to functions
+ KeyBindings map[string]func(window *WebviewWindow)
+}
+Parameter defines a Go method parameter
+type Parameter struct {
+ Name string `json:"name,omitempty"`
+ TypeName string `json:"type"`
+ ReflectType reflect.Type
+}
+IsError returns true if the parameter type is an error
+ +IsType returns true if the given
+ +type Plugin interface {
+ Name() string
+ Init() error
+ Shutdown()
+ CallableByJS() []string
+ InjectJS() string
+}
+func NewPluginManager(plugins map[string]Plugin, assetServer *assetserver.AssetServer) *PluginManager
+Role is a type to identify menu roles
+ +These constants need to be kept in sync with +`v2/internal/frontend/desktop/darwin/Role.h`
+const (
+ NoRole Role = iota
+ AppMenu Role = iota
+ EditMenu Role = iota
+ ViewMenu Role = iota
+ WindowMenu Role = iota
+ ServicesMenu Role = iota
+ HelpMenu Role = iota
+
+ Hide Role = iota
+ HideOthers Role = iota
+ UnHide Role = iota
+ About Role = iota
+ Undo Role = iota
+ Redo Role = iota
+ Cut Role = iota
+ Copy Role = iota
+ Paste Role = iota
+ PasteAndMatchStyle Role = iota
+ SelectAll Role = iota
+ Delete Role = iota
+ SpeechMenu Role = iota
+ Quit Role = iota
+ FileMenu Role = iota
+ Close Role = iota
+ Reload Role = iota
+ ForceReload Role = iota
+ ToggleDevTools Role = iota
+ ResetZoom Role = iota
+ ZoomIn Role = iota
+ ZoomOut Role = iota
+ ToggleFullscreen Role = iota
+
+ Minimize Role = iota
+ Zoom Role = iota
+ FullScreen Role = iota
+)
+type SaveFileDialogOptions struct {
+ CanCreateDirectories bool
+ ShowHiddenFiles bool
+ CanSelectHiddenExtension bool
+ AllowOtherFileTypes bool
+ HideExtension bool
+ TreatsFilePackagesAsDirectories bool
+ Title string
+ Message string
+ Directory string
+ Filename string
+ ButtonText string
+ Filters []FileFilter
+ Window *WebviewWindow
+}
+AddFilter adds a filter to the dialog. The filter is a display name and a +semicolon separated list of extensions. EG: AddFilter("Image Files", +"*.jpg;*.png")
+ +func (d *SaveFileDialogStruct) AllowsOtherFileTypes(allowOtherFileTypes bool) *SaveFileDialogStruct
+func (d *SaveFileDialogStruct) CanCreateDirectories(canCreateDirectories bool) *SaveFileDialogStruct
+func (d *SaveFileDialogStruct) CanSelectHiddenExtension(canSelectHiddenExtension bool) *SaveFileDialogStruct
+func (d *SaveFileDialogStruct) TreatsFilePackagesAsDirectories(treatsFilePackagesAsDirectories bool) *SaveFileDialogStruct
+type Screen struct {
+ ID string // A unique identifier for the display
+ Name string // The name of the display
+ Scale float32 // The scale factor of the display
+ X int // The x-coordinate of the top-left corner of the rectangle
+ Y int // The y-coordinate of the top-left corner of the rectangle
+ Size Size // The size of the display
+ Bounds Rect // The bounds of the display
+ WorkArea Rect // The work area of the display
+ IsPrimary bool // Whether this is the primary display
+ Rotation float32 // The rotation of the display
+}
+AttachWindow attaches a window to the system tray. The window will be shown when +the system tray icon is clicked. The window will be hidden when the system tray +icon is clicked again, or when the window loses focus.
+ +WindowDebounce is used by Windows to indicate how long to wait before responding +to a mouse up event on the notification icon. This prevents the window from +being hidden and then immediately shown when the user clicks on the system tray +icon. See +https://stackoverflow.com/questions/4585283/alternate-showing-hiding-window-when-notify-icon-is-clicked
+ +WindowOffset sets the gap in pixels between the system tray and the window
+ +const (
+ // SystemDefault will use whatever the system theme is. The application will follow system theme changes.
+ SystemDefault Theme = 0
+ // Dark Mode
+ Dark Theme = 1
+ // Light Mode
+ Light Theme = 2
+)
+ThemeSettings defines custom colours to use in dark or light mode. They may be +set using the hex values: 0x00BBGGRR
+type ThemeSettings struct {
+ DarkModeTitleBar int32
+ DarkModeTitleBarInactive int32
+ DarkModeTitleText int32
+ DarkModeTitleTextInactive int32
+ DarkModeBorder int32
+ DarkModeBorderInactive int32
+ LightModeTitleBar int32
+ LightModeTitleBarInactive int32
+ LightModeTitleText int32
+ LightModeTitleTextInactive int32
+ LightModeBorder int32
+ LightModeBorderInactive int32
+}
+type WailsEvent struct {
+ Name string `json:"name"`
+ Data any `json:"data"`
+ Sender string `json:"sender"`
+ Cancelled bool
+}
+AbsolutePosition returns the absolute position of the window to the screen
+ +Center centers the window on the screen
+ +Close closes the window
+ +ExecJS executes the given javascript in the context of the window.
+ +Flash flashes the window's taskbar button/icon. Windows only.
+ +ForceReload forces the window to reload the page assets
+ +Fullscreen sets the window to fullscreen mode. Min/Max size constraints are +disabled.
+ +GetScreen returns the screen that the window is on
+ +GetZoom returns the current zoom level of the window.
+ +Height returns the height of the window
+ +Hide hides the window.
+ +IsFocused returns true if the window is currently focused
+ +IsFullscreen returns true if the window is fullscreen
+ +IsMaximised returns true if the window is maximised
+ +IsMinimised returns true if the window is minimised
+ +IsVisible returns true if the window is visible
+ +Maximise maximises the window. Min/Max size constraints are disabled.
+ +Minimise minimises the window.
+ +Name returns the name of the window
+ +NativeWindowHandle returns the platform native window handle for the window.
+ +func (w *WebviewWindow) On(eventType events.WindowEventType, callback func(event *WindowEvent)) func()
+On registers a callback for the given window event
+ +RegisterContextMenu registers a context menu and assigns it the given name.
+ +func (w *WebviewWindow) RegisterHook(eventType events.WindowEventType, callback func(event *WindowEvent)) func()
+RegisterHook registers a hook for the given window event
+ +RelativePosition returns the relative position of the window to the screen
+ +Reload reloads the page assets
+ +Resizable returns true if the window is resizable.
+ +Restore restores the window to its previous state if it was previously +minimised, maximised or fullscreen.
+ +SetAlwaysOnTop sets the window to be always on top.
+ +SetBackgroundColour sets the background colour of the window
+ +SetFrameless removes the window frame and title bar
+ +SetHTML sets the HTML of the window to the given html string.
+ +SetMaxSize sets the maximum size of the window.
+ +SetMinSize sets the minimum size of the window.
+ +SetRelativePosition sets the position of the window.
+ +SetResizable sets whether the window is resizable.
+ +SetSize sets the size of the window
+ +SetTitle sets the title of the window
+ +SetZoom sets the zoom level of the window.
+ +Show shows the window.
+ +Size returns the size of the window
+ +ToggleFullscreen toggles the window between fullscreen and normal
+ +UnFullscreen un-fullscreens the window.
+ +UnMaximise un-maximises the window.
+ +UnMinimise un-minimises the window. Min/Max size constraints are re-enabled.
+ +Width returns the width of the window
+ +ZoomIn increases the zoom level of the webview content
+ +ZoomOut decreases the zoom level of the webview content
+ +ZoomReset resets the zoom level of the webview content to 100%
+ +type WebviewWindowOptions struct {
+ // Name is a unique identifier that can be given to a window.
+ Name string
+
+ // Title is the title of the window.
+ Title string
+
+ // Width is the starting width of the window.
+ Width int
+
+ // Height is the starting height of the window.
+ Height int
+
+ // AlwaysOnTop will make the window float above other windows.
+ AlwaysOnTop bool
+
+ // URL is the URL to load in the window.
+ URL string
+
+ // DisableResize will disable the ability to resize the window.
+ DisableResize bool
+
+ // Frameless will remove the window frame.
+ Frameless bool
+
+ // MinWidth is the minimum width of the window.
+ MinWidth int
+
+ // MinHeight is the minimum height of the window.
+ MinHeight int
+
+ // MaxWidth is the maximum width of the window.
+ MaxWidth int
+
+ // MaxHeight is the maximum height of the window.
+ MaxHeight int
+
+ // StartState indicates the state of the window when it is first shown.
+ // Default: WindowStateNormal
+ StartState WindowState
+
+ // Centered will center the window on the screen.
+ Centered bool
+
+ // BackgroundType is the type of background to use for the window.
+ // Default: BackgroundTypeSolid
+ BackgroundType BackgroundType
+
+ // BackgroundColour is the colour to use for the window background.
+ BackgroundColour RGBA
+
+ // HTML is the HTML to load in the window.
+ HTML string
+
+ // JS is the JavaScript to load in the window.
+ JS string
+
+ // CSS is the CSS to load in the window.
+ CSS string
+
+ // X is the starting X position of the window.
+ X int
+
+ // Y is the starting Y position of the window.
+ Y int
+
+ // TransparentTitlebar will make the titlebar transparent.
+ // TODO: Move to mac window options
+ FullscreenButtonEnabled bool
+
+ // Hidden will hide the window when it is first created.
+ Hidden bool
+
+ // Zoom is the zoom level of the window.
+ Zoom float64
+
+ // ZoomControlEnabled will enable the zoom control.
+ ZoomControlEnabled bool
+
+ // EnableDragAndDrop will enable drag and drop.
+ EnableDragAndDrop bool
+
+ // OpenInspectorOnStartup will open the inspector when the window is first shown.
+ OpenInspectorOnStartup bool
+
+ // Mac options
+ Mac MacWindow
+
+ // Windows options
+ Windows WindowsWindow
+
+ // Focused indicates the window should be focused when initially shown
+ Focused bool
+
+ // ShouldClose is called when the window is about to close.
+ // Return true to allow the window to close, or false to prevent it from closing.
+ ShouldClose func(window *WebviewWindow) bool
+
+ // If true, the window's devtools will be available (default true in builds without the `production` build tag)
+ DevToolsEnabled bool
+
+ // If true, the window's default context menu will be disabled (default false)
+ DefaultContextMenuDisabled bool
+
+ // KeyBindings is a map of key bindings to functions
+ KeyBindings map[string]func(window *WebviewWindow)
+}
+type WindowAttachConfig struct {
+ // Window is the window to attach to the system tray. If it's null, the request to attach will be ignored.
+ Window *WebviewWindow
+
+ // Offset indicates the gap in pixels between the system tray and the window
+ Offset int
+
+ // Debounce is used by Windows to indicate how long to wait before responding to a mouse
+ // up event on the notification icon. See https://stackoverflow.com/questions/4585283/alternate-showing-hiding-window-when-notify-icon-is-clicked
+ Debounce time.Duration
+ // contains filtered or unexported fields
+}
+const (
+ WindowStateNormal WindowState = iota
+ WindowStateMinimised
+ WindowStateMaximised
+ WindowStateFullscreen
+)
+WindowsOptions contains options for Windows applications.
+type WindowsOptions struct {
+
+ // WndProcInterceptor is a function that will be called for every message sent in the application.
+ // Use this to hook into the main message loop. This is useful for handling custom window messages.
+ // If `shouldReturn` is `true` then `returnCode` will be returned by the main message loop.
+ // If `shouldReturn` is `false` then returnCode will be ignored and the message will be processed by the main message loop.
+ WndProcInterceptor func(hwnd uintptr, msg uint32, wParam, lParam uintptr) (returnCode uintptr, shouldReturn bool)
+
+ // DisableQuitOnLastWindowClosed disables the auto quit of the application if the last window has been closed.
+ DisableQuitOnLastWindowClosed bool
+
+ // Path where the WebView2 stores the user data. If empty %APPDATA%\[BinaryName.exe] will be used.
+ // If the path is not valid, a messagebox will be displayed with the error and the app will exit with error code.
+ WebviewUserDataPath string
+
+ // Path to the directory with WebView2 executables. If empty WebView2 installed in the system will be used.
+ WebviewBrowserPath string
+}
+type WindowsWindow struct {
+ // Select the type of translucent backdrop. Requires Windows 11 22621 or later.
+ // Only used when window's `BackgroundType` is set to `BackgroundTypeTranslucent`.
+ // Default: Auto
+ BackdropType BackdropType
+
+ // Disable the icon in the titlebar
+ // Default: false
+ DisableIcon bool
+
+ // Theme (Dark / Light / SystemDefault)
+ // Default: SystemDefault - The application will follow system theme changes.
+ Theme Theme
+
+ // Specify custom colours to use for dark/light mode
+ // Default: nil
+ CustomTheme *ThemeSettings
+
+ // Disable all window decorations in Frameless mode, which means no "Aero Shadow" and no "Rounded Corner" will be shown.
+ // "Rounded Corners" are only available on Windows 11.
+ // Default: false
+ DisableFramelessWindowDecorations bool
+
+ // WindowMask is used to set the window shape. Use a PNG with an alpha channel to create a custom shape.
+ // Default: nil
+ WindowMask []byte
+
+ // WindowMaskDraggable is used to make the window draggable by clicking on the window mask.
+ // Default: false
+ WindowMaskDraggable bool
+
+ // WebviewGpuIsDisabled is used to enable / disable GPU acceleration for the webview
+ // Default: false
+ WebviewGpuIsDisabled bool
+
+ // ResizeDebounceMS is the amount of time to debounce redraws of webview2
+ // when resizing the window
+ // Default: 0
+ ResizeDebounceMS uint16
+
+ // Disable the menu bar for this window
+ // Default: false
+ DisableMenu bool
+
+ // Event mapping for the window. This allows you to define a translation from one event to another.
+ // Default: nil
+ EventMapping map[events.WindowEventType]events.WindowEventType
+
+ // HiddenOnTaskbar hides the window from the taskbar
+ // Default: false
+ HiddenOnTaskbar bool
+
+ // EnableSwipeGestures enables swipe gestures for the window
+ // Default: false
+ EnableSwipeGestures bool
+
+ // EnableFraudulentWebsiteWarnings will enable warnings for fraudulent websites.
+ // Default: false
+ EnableFraudulentWebsiteWarnings bool
+
+ // Menu is the menu to use for the window.
+ Menu *Menu
+}
+These methods are utility functions to run code on the main thread. This is +required when you want to run custom code on the UI thread.
+API: InvokeSync(fn func())
This function runs the passed function (fn) synchronously. It uses a WaitGroup
+(wg) to ensure that the main thread waits for the fn function to finish
+before it continues. If a panic occurs inside fn, it will be passed to the
+handler function PanicHandler, defined in the application options.
API: InvokeSyncWithResult[T any](fn func() T) (res T)
This function works similarly to InvokeSync(fn func()), however, it yields a
+result. Use this for calling any function with a single return.
API: InvokeSyncWithError(fn func() error) (err error)
This function runs fn synchronously and returns any error that fn produces.
+Note that this function will recover from a panic if one occurs during fn's
+execution.
API:
+InvokeSyncWithResultAndError[T any](fn func() (T, error)) (res T, err error)
This function runs fn synchronously and returns both a result of type T and
+an error.
API: InvokeAsync(fn func())
This function runs fn asynchronously. It runs the given function on the main
+thread. If a panic occurs inside fn, it will be passed to the handler function
+PanicHandler, defined in the application options.
Note: These functions will block execution until fn has finished. It's
+critical to ensure that fn doesn't block. If you need to run a function that
+blocks, use InvokeAsync instead.
Menus can be created and added to the application. They can be used to create +context menus, system tray menus and application menus.
+To create a new menu, call:
+ +The following operations are then available on the Menu type:
API: Add(label string) *MenuItem
This method takes a label of type string as an input and adds a new
+MenuItem with the given label to the menu. It returns the MenuItem added.
API: AddSeparator()
This method adds a new separator MenuItem to the menu.
API: AddCheckbox(label string, enabled bool) *MenuItem
This method takes a label of type string and enabled of type bool as
+inputs and adds a new checkbox MenuItem with the given label and enabled state
+to the menu. It returns the MenuItem added.
API: AddRadio(label string, enabled bool) *MenuItem
This method takes a label of type string and enabled of type bool as
+inputs and adds a new radio MenuItem with the given label and enabled state to
+the menu. It returns the MenuItem added.
API: Update()
This method processes any radio groups and updates the menu if a menu +implementation is not initialized.
+API: AddSubmenu(s string) *Menu
This method takes a s of type string as input and adds a new submenu
+MenuItem with the given label to the menu. It returns the submenu added.
API: AddRole(role Role) *Menu
This method takes role of type Role as input, adds it to the menu if it is
+not nil and returns the Menu.
API: SetLabel(label string)
This method sets the label of the Menu.
The system tray houses notification area on a desktop environment, which can +contain both icons of currently-running applications and specific system +notifications.
+You create a system tray by calling app.NewSystemTray():
The following methods are available on the SystemTray type:
API: SetLabel(label string)
The SetLabel method sets the tray's label.
API: Label() string
The Label method retrieves the tray's label.
API: PositionWindow(*WebviewWindow, offset int) error
The PositionWindow method calls both AttachWindow and WindowOffset
+methods.
API: SetIcon(icon []byte) *SystemTray
The SetIcon method sets the system tray's icon.
API: SetDarkModeIcon(icon []byte) *SystemTray
The SetDarkModeIcon method sets the system tray's icon when in dark mode.
API: SetMenu(menu *Menu) *SystemTray
The SetMenu method sets the system tray's menu.
API: Destroy()
The Destroy method destroys the system tray instance.
API: OnClick(handler func()) *SystemTray
The OnClick method sets the function to execute when the tray icon is clicked.
API: OnRightClick(handler func()) *SystemTray
The OnRightClick method sets the function to execute when right-clicking the
+tray icon.
API: OnDoubleClick(handler func()) *SystemTray
The OnDoubleClick method sets the function to execute when double-clicking the
+tray icon.
API: OnRightDoubleClick(handler func()) *SystemTray
The OnRightDoubleClick method sets the function to execute when right
+double-clicking the tray icon.
API: AttachWindow(window *WebviewWindow) *SystemTray
The AttachWindow method attaches a window to the system tray. The window will
+be shown when the system tray icon is clicked.
API: WindowOffset(offset int) *SystemTray
The WindowOffset method sets the gap in pixels between the system tray and the
+window.
API: WindowDebounce(debounce time.Duration) *SystemTray
The WindowDebounce method sets a debounce time. In the context of Windows,
+this is used to specify how long to wait before responding to a mouse up event
+on the notification icon.
API: OpenMenu()
The OpenMenu method opens the menu associated with the system tray.
To create a window, use +Application.NewWebviewWindow or +Application.NewWebviewWindowWithOptions. +The former creates a window with default options, while the latter allows you to +specify custom options.
+These methods are callable on the returned WebviewWindow object:
+API: SetTitle(title string) *WebviewWindow
This method updates the window title to the provided string. It returns the +WebviewWindow object, allowing for method chaining.
+API: Name() string
This function returns the name of the WebviewWindow.
+API: SetSize(width, height int) *WebviewWindow
This method sets the size of the WebviewWindow to the provided width and height +parameters. If the dimensions provided exceed the constraints, they are adjusted +appropriately.
+API: SetAlwaysOnTop(b bool) *WebviewWindow
This function sets the window to stay on top based on the boolean flag provided.
+API: Show() *WebviewWindow
Show method is used to make the window visible. If the window is not running,
+it first invokes the run method to start the window and then makes it visible.
API: Hide() *WebviewWindow
Hide method is used to hide the window. It sets the hidden status of the
+window to true and emits the window hide event.
API: SetURL(s string) *WebviewWindow
SetURL method is used to set the URL of the window to the given URL string.
API: SetZoom(magnification float64) *WebviewWindow
SetZoom method sets the zoom level of the window content to the provided
+magnification level.
API: GetZoom() float64
GetZoom function returns the current zoom level of the window content.
API: GetScreen() (*Screen, error)
GetScreen method returns the screen on which the window is displayed.
API: SetFrameless(frameless bool) *WebviewWindow
This function is used to remove the window frame and title bar. It toggles the +framelessness of the window according to the boolean value provided (true for +frameless, false for framed).
+API: RegisterContextMenu(name string, menu *Menu)
This function is used to register a context menu and assigns it the given name.
+API: NativeWindowHandle() (uintptr, error)
This function is used to fetch the platform native window handle for the window.
+API: Focus()
This function is used to focus the window.
+API: SetEnabled(enabled bool)
This function is used to enable/disable the window based on the provided boolean +value.
+API: SetAbsolutePosition(x int, y int)
This function sets the absolute position of the window in the screen.
+ + + + + + + + + + + + + +run:linux by @marcus-crane in #3146SetIcon method by @almas1992 in PROnShutdown by @almas1992 in PRgo.mod to use relative paths. Fixes Windows paths with spaces - @leaanthony.Note
+This is currently an unsorted brain dump of changes. It will be
+organised into a more readable format soon.
+The application options have been revised since v2.
+In v3, there are 3 types of events:
+Application events are events that are emitted by the application. These events
+include native events such as ApplicationDidFinishLaunching on macOS.
Window events are events that are emitted by a window. These events include
+native events such as WindowDidBecomeMain on macOS. Common events are also
+defined, so they work cross-platform, e.g. WindowClosing.
Events that the user defines are called WailsEvents. This is to differentiate
+them from the Event object that is used to communicate with the browser.
+WailsEvents are now objects that encapsulate all the details of an event. This
+includes the event name, the data, and the source of the event.
The data associated with a WailsEvent is now a single value. If multiple values +are required, then a struct can be used.
+Emit function signature#The signatures events callbacks (as used by On, Once & OnMultiple) have
+changed. In v2, the callback function received optional data. In v3, the
+callback function receives a WailsEvent object that contains all data related
+to the event.
Similarly, the Emit function has changed. Instead of taking a name and
+optional data, it now takes a single WailsEvent object that it will emit.
Off and OffAll#In v2, Off and OffAll calls would remove events in both JS and Go. Due to
+the multi-window nature of v3, this has been changed so that these methods only
+apply to the context they are called in. For example, if you call Off in a
+window, it will only remove events for that window. If you use Off in Go, it
+will only remove events for Go.
Event Hooks are a new feature in v3. They allow you to hook into the event
+system and perform actions when certain events are emitted. For example, you can
+hook into the WindowClosing event and perform some cleanup before the window
+closes. Hooks can be registered at the application level or at the window level
+using RegisterHook. Application level are for application events. Window level
+hooks will only be called for the window they are registered with.
Logging in v2 was confusing as both application logs and system (internal) logs +were using the same logger. We have simplified this as follows:
+slog logger. This is
+ configured using the logger option in the application options. By default,
+ this uses the tint logger.log plugin which
+ utilises slog under the hood. This plugin provides a simple API for logging
+ to the console. It is available in both Go and JS.When emitting an event in Go, it will dispatch the event to local Go listeners +and also each window in the application. When emitting an event in JS, it now +sends the event to the application. This will be processed as if it was emitted +in Go, however the sender ID will be that of the window.
+The Window API has largely remained the same, however the methods are now on an +instance of a window rather than the runtime. Some notable differences are:
+AbsolutePosition and ToggleDevTools.The clipboard API has been simplified. There is now a single Clipboard object
+that can be used to read and write to the clipboard. The Clipboard object is
+available in both Go and JS. SetText() to set the text and Text() to get the
+text.
Bindings work in a similar way to v2, by providing a means to bind struct
+methods to the frontend. These can be called in the frontend using the binding
+wrappers generated by the wails3 generate bindings command:
// @ts-check
+// Cynhyrchwyd y ffeil hon yn awtomatig. PEIDIWCH Â MODIWL
+// This file is automatically generated. DO NOT EDIT
+
+import { main } from "./models";
+
+window.go = window.go || {};
+window.go.main = {
+ GreetService: {
+ /**
+ * GreetService.Greet
+ * Greet greets a person
+ * @param name {string}
+ * @returns {Promise<string>}
+ **/
+ Greet: function (name) {
+ wails.CallByID(1411160069, ...Array.prototype.slice.call(arguments, 0));
+ },
+
+ /**
+ * GreetService.GreetPerson
+ * GreetPerson greets a person
+ * @param person {main.Person}
+ * @returns {Promise<string>}
+ **/
+ GreetPerson: function (person) {
+ wails.CallByID(4021313248, ...Array.prototype.slice.call(arguments, 0));
+ },
+ },
+};
+Bound methods are obfuscated by default, and are identified using uint32 IDs,
+calculated using the
+FNV hashing algorithm.
+This is to prevent the method name from being exposed in production builds. In
+debug mode, the method IDs are logged along with the calculated ID of the method
+to aid in debugging. If you wish to add an extra layer of obfuscation, you can
+use the BindAliases option. This allows you to specify a map of alias IDs to
+method IDs. When the frontend calls a method using an ID, the method ID will be
+looked up in the alias map first for a match. If it does not find it, it assumes
+it's a standard method ID and tries to find the method in the usual way.
Example:
+ app := application.New(application.Options{
+ Bind: []any{
+ &GreetService{},
+ },
+ BindAliases: map[uint32]uint32{
+ 1: 1411160069,
+ 2: 4021313248,
+ },
+ Assets: application.AssetOptions{
+ FS: assets,
+ },
+ Mac: application.MacOptions{
+ ApplicationShouldTerminateAfterLastWindowClosed: true,
+ },
+ })
+We can now call using this alias in the frontend: wails.Call(1, "world!").
If you don't mind your calls being available in plain text in your binary and
+have no intention of using garble, then
+you can use the insecure wails.CallByName() method. This method takes the
+fully qualified name of the method to call and the arguments to pass to it.
+Example:
```go
+wails.CallByName("main.GreetService.Greet", "world!")
+```
+Danger
+This is only provided as a convenience method for development. It is not recommended to use this in production.
+Dialogs are now available in JavaScript!
+Dialog buttons in Windows are not configurable and are constant depending on the
+type of dialog. To trigger a callback when a button is pressed, create a button
+with the same name as the button you wish to have the callback attached to.
+Example: Create a button with the label Ok and use OnClick() to set the
+callback method:
dialog := app.QuestionDialog().
+ SetTitle("Update").
+ SetMessage("The cancel button is selected when pressing escape")
+ ok := dialog.AddButton("Ok")
+ ok.OnClick(func() {
+ // Do something
+ })
+ no := dialog.AddButton("Cancel")
+ dialog.SetDefaultButton(ok)
+ dialog.SetCancelButton(no)
+ dialog.Show()
+Native drag and drop can be enabled per-window. Simply set the
+EnableDragAndDrop window config option to true and the window will allow
+files to be dragged onto it. When this happens, the events.FilesDropped event
+will be emitted. The filenames can then be retrieved from the
+WindowEvent.Context() using the DroppedFiles() method. This returns a slice
+of strings containing the filenames.
Context menus are contextual menus that are shown when the user right-clicks on
+an element. Creating a context menu is the same as creating a standard menu , by
+using app.NewMenu(). To make the context menu available to a window, call
+window.RegisterContextMenu(name, menu). The name will be the id of the context
+menu and used by the frontend.
To indicate that an element has a context menu, add the data-contextmenu
+attribute to the element. The value of this attribute should be the name of a
+context menu previously registered with the window.
It is possible to register a context menu at the application level, making it
+available to all windows. This can be done using
+app.RegisterContextMenu(name, menu). If a context menu cannot be found at the
+window level, the application context menus will be checked. A demo of this can
+be found in v3/examples/contextmenus.
The Wails Markup Language is a simple markup language that allows you to add +functionality to standard HTML elements without the use of Javascript.
+The following tags are currently supported:
+data-wml-event#This specifies that a Wails event will be emitted when the element is clicked. +The value of the attribute should be the name of the event to emit.
+Example:
+ +Sometimes you need the user to confirm an action. This can be done by adding the
+data-wml-confirm attribute to the element. The value of this attribute will be
+the message to display to the user.
Example:
+<button data-wml-event="delete-all-items" data-wml-confirm="Are you sure?">
+ Delete All Items
+</button>
+data-wml-window#Any wails.window method can be called by adding the data-wml-window
+attribute to an element. The value of the attribute should be the name of the
+method to call. The method name should be in the same case as the method.
data-wml-trigger#This attribute specifies which javascript event should trigger the action. The
+default is click.
Wails 3 comes with a built-in systray. This is a fully featured systray that has +been designed to be as simple as possible to use. It is possible to set the +icon, tooltip and menu of the systray. It is possible to also "attach" a window +to the systray. Doing this will provide the following functionality:
+On macOS, if there is no attached window, the systray will use the default +method of displaying the menu (any button). If there is an attached window but +no menu, the systray will toggle the window regardless of the button pressed.
+Plugins are a way to extend the functionality of your Wails application.
+Plugins are standard Go structure that adhere to the following interface:
+type Plugin interface {
+ Name() string
+ Init(*application.App) error
+ Shutdown()
+ CallableByJS() []string
+ InjectJS() string
+}
+The Name() method returns the name of the plugin. This is used for logging
+purposes.
The Init(*application.App) error method is called when the plugin is loaded.
+The *application.App parameter is the application that the plugin is being
+loaded into. Any errors will prevent the application from starting.
The Shutdown() method is called when the application is shutting down.
The CallableByJS() method returns a list of exported functions that can be
+called from the frontend. These method names must exactly match the names of the
+methods exported by the plugin.
The InjectJS() method returns JavaScript that should be injected into all
+windows as they are created. This is useful for adding custom JavaScript
+functions that complement the plugin.
In Go, enums are often defined as a type and a set of constants. For example:
+ +Due to incompatibility between Go and JavaScript, custom types cannot be used in +this way. The best strategy is to use a type alias for float64:
+ +In Javascript, you can then use the following:
+ +float64? Can't we use int?int. Everything is a
+ number, which translates to float64 in Go. There are also restrictions
+ on casting types in Go's reflection package, which means using int doesn't
+ work.In v2, this was a pointer to an RGBA struct. In v3, this is an RGBA struct
+value.
This flag has been removed. Now there is a BackgroundType flag that can be
+used to set the type of background the window should have. This flag can be set
+to any of the following values:
BackgroundTypeSolid - The window will have a solid backgroundBackgroundTypeTransparent - The window will have a transparent backgroundBackgroundTypeTranslucent - The window will have a translucent backgroundOn Windows, if the BackgroundType is set to BackgroundTypeTranslucent, the
+type of translucency can be set using the BackdropType flag in the
+WindowsWindow options. This can be set to any of the following values:
Auto - The window will use an effect determined by the systemNone - The window will have no backgroundMica - The window will use the Mica effectAcrylic - The window will use the acrylic effectTabbed - The window will use the tabbed effectIf this is set, the WndProc will be intercepted and the function will be called. +This allows you to handle Windows messages directly. The function should have +the following signature:
+ +The shouldReturn value should be set to true if the returnValue should be
+returned by the main wndProc method. If it is set to false, the return value
+will be ignored and the message will continue to be processed by the main
+wndProc method.
In v2, there was the HideWindowOnClose flag to hide the window when it closed.
+There was a logical overlap between this flag and the OnBeforeClose callback.
+In v3, the HideWindowOnClose flag has been removed and the OnBeforeClose
+callback has been renamed to ShouldClose. The ShouldClose callback is called
+when the user attempts to close a window. If the callback returns true, the
+window will close. If it returns false, the window will not close. This can be
+used to hide the window instead of closing it.
In v2, the --wails-drag attribute was used to indicate that an element could
+be used to drag the window. In v3, this has been replaced with
+--webkit-app-region to be more in line with the way other frameworks handle
+this. The --webkit-app-region attribute can be set to any of the following
+values:
drag - The element can be used to drag the windowno-drag - The element cannot be used to drag the windowWe would have ideally liked to use app-region, however this is not supported
+by the getComputedStyle call on webkit on macOS.
Note
+This guide is a work in progress.
+Thanks for wanting to help out with development of Wails! This guide will help +you get started.
+v3-alpha branch.Install the CLI: cd v3/cmd/wails3 && go install
Optional: If you are wanting to use the build system to build frontend code, + you will need to install npm.
+For simple programs, you can use the standard go build command. It's also
+possible to use go run.
Wails also comes with a build system that can be used to build more complex
+projects. It utilises the awesome Task build system. For
+more information, check out the task homepage or run wails task --help.
The project has the following structure:
+```
+v3
+├── cmd/wails3 // CLI
+├── examples // Examples of Wails apps
+├── internal // Internal packages
+| ├── runtime // The Wails JS runtime
+| └── templates // The supported project templates
+├── pkg
+| ├── application // The core Wails library
+| └── events // The event definitions
+| └── mac // macOS specific code used by plugins
+| └── w32 // Windows specific code
+├── plugins // Supported plugins
+├── tasks // General tasks
+└── Taskfile.yaml // Development tasks configuration
+```
+We are currently tracking known issues and tasks in the +Alpha Todo List. If you want to +help out, please check this list and follow the instructions in the +Feedback page.
+The preferred way to add window functionality is to add a new function to the
+pkg/application/webview_window.go file. This should implement all the
+functionality required for all platforms. Any platform specific code should be
+called via a webviewWindowImpl interface method. This interface is implemented
+by each of the target platforms to provide the platform specific functionality.
+In some cases, this may do nothing. Once you've added the interface method,
+ensure each platform implements it. A good example of this is the SetMinSize
+method.
webview_window_darwin.gowebview_window_windows.gowebview_window_linux.goMost, if not all, of the platform specific code should be run on the main
+thread. To simplify this, there are a number of invokeSync methods defined in
+application.go.
The runtime is located in v3/internal/runtime. When the runtime is updated,
+the following steps need to be taken:
Events are defined in v3/pkg/events. When adding a new event, the following
+steps need to be taken:
events.txt filewails3 task events:generateThere are a number of types of events: platform specific application and window +events + common events. The common events are useful for cross-platform event +handling, but you aren't limited to the "lowest common denominator". You can use +the platform specific events if you need to.
+When adding a common event, ensure that the platform specific events are mapped.
+An example of this is in window_webview_darwin.go:
// Translate ShouldClose to common WindowClosing event
+ w.parent.On(events.Mac.WindowShouldClose, func(_ *WindowEventContext) {
+ w.parent.emit(events.Common.WindowClosing)
+ })
+NOTE: We may try to automate this in the future by adding the mapping to the +event definition.
+Plugins are a way to extend the functionality of your Wails application.
+Plugins are standard Go structure that adhere to the following interface:
+type Plugin interface {
+ Name() string
+ Init(*application.App) error
+ Shutdown()
+ CallableByJS() []string
+ InjectJS() string
+}
+The Name() method returns the name of the plugin. This is used for logging
+purposes.
The Init(*application.App) error method is called when the plugin is loaded.
+The *application.App parameter is the application that the plugin is being
+loaded into. Any errors will prevent the application from starting.
The Shutdown() method is called when the application is shutting down.
The CallableByJS() method returns a list of exported functions that can be
+called from the frontend. These method names must exactly match the names of the
+methods exported by the plugin.
The InjectJS() method returns JavaScript that should be injected into all
+windows as they are created. This is useful for adding custom JavaScript
+functions that complement the plugin.
The built-in plugins can be found in the v3/plugins directory. Check them out
+for inspiration.
The Wails CLI uses the Task build system. It is imported
+as a library and used to run the tasks defined in Taskfile.yaml. The main
+interfacing with Task happens in v3/internal/commands/task.go.
To check if there's an upgrade for Taskfile, run wails3 task -version and
+check against the Task website.
To upgrade the version of Taskfile used, run:
+ +If there are incompatibilities then they should appear in the
+v3/internal/commands/task.go file.
Usually the best way to fix incompatibilities is to clone the task repo at
+https://github.com/go-task/task and look at the git history to determine what
+has changed and why.
To check all changes have worked correctly, re-install the CLI and check the +version again:
+ +Make sure that all PRs have a ticket associated with them providing context to
+the change. If there is no ticket, please create one first. Ensure that all PRs
+have updated the CHANGELOG.md file with the changes made. The CHANGELOG.md file
+is located in the mkdocs-website/docs directory.
The Wails CLI uses the Task build system. It is imported
+as a library and used to run the tasks defined in Taskfile.yaml. The main
+interfacing with Task happens in v3/internal/commands/task.go.
To check if there's an upgrade for Taskfile, run wails3 task -version and
+check against the Task website.
To upgrade the version of Taskfile used, run:
+ +If there are incompatibilities then they should appear in the
+v3/internal/commands/task.go file.
Usually the best way to fix incompatibilities is to clone the task repo at
+https://github.com/go-task/task and look at the git history to determine what
+has changed and why.
To check all changes have worked correctly, re-install the CLI and check the +version again:
+ + + + + + + + + + + + + + +Status of features in v3.
+Note
+This list is a mixture of public and internal API support.<br/>
+It is not complete and probably not up to date.
+Application interface methods
+| Method | +Windows | +Linux | +Mac | +Notes | +
|---|---|---|---|---|
| run() error | +Y | +Y | +Y | ++ |
| destroy() | ++ | Y | +Y | ++ |
| setApplicationMenu(menu *Menu) | +Y | +Y | +Y | ++ |
| name() string | ++ | Y | +Y | ++ |
| getCurrentWindowID() uint | +Y | +Y | +Y | ++ |
| showAboutDialog(name string, description string, icon []byte) | ++ | Y | +Y | ++ |
| setIcon(icon []byte) | +- | +Y | +Y | ++ |
| on(id uint) | ++ | + | Y | ++ |
| dispatchOnMainThread(fn func()) | +Y | +Y | +Y | ++ |
| hide() | +Y | +Y | +Y | ++ |
| show() | +Y | +Y | +Y | ++ |
| getPrimaryScreen() (*Screen, error) | ++ | Y | +Y | ++ |
| getScreens() ([]*Screen, error) | ++ | Y | +Y | ++ |
Webview Window Interface Methods
+| Method | +Windows | +Linux | +Mac | +Notes | +
|---|---|---|---|---|
| center() | +Y | +Y | +Y | ++ |
| close() | +y | +Y | +Y | ++ |
| destroy() | ++ | Y | +Y | ++ |
| execJS(js string) | +y | +Y | +Y | ++ |
| focus() | +Y | +Y | ++ | + |
| forceReload() | ++ | Y | +Y | ++ |
| fullscreen() | +Y | +Y | +Y | ++ |
| getScreen() (*Screen, error) | +y | +Y | +Y | ++ |
| getZoom() float64 | ++ | Y | +Y | ++ |
| height() int | +Y | +Y | +Y | ++ |
| hide() | +Y | +Y | +Y | ++ |
| isFullscreen() bool | +Y | +Y | +Y | ++ |
| isMaximised() bool | +Y | +Y | +Y | ++ |
| isMinimised() bool | +Y | +Y | +Y | ++ |
| maximise() | +Y | +Y | +Y | ++ |
| minimise() | +Y | +Y | +Y | ++ |
| nativeWindowHandle() (uintptr, error) | +Y | +Y | +Y | ++ |
| on(eventID uint) | +y | ++ | Y | ++ |
| openContextMenu(menu Menu, data ContextMenuData) | +y | +Y | +Y | ++ |
| relativePosition() (int, int) | +Y | +Y | +Y | ++ |
| reload() | +y | +Y | +Y | ++ |
| run() | +Y | +Y | +Y | ++ |
| setAlwaysOnTop(alwaysOnTop bool) | +Y | +Y | +Y | ++ |
| setBackgroundColour(color RGBA) | +Y | +Y | +Y | ++ |
| setEnabled(bool) | ++ | Y | +Y | ++ |
| setFrameless(bool) | ++ | Y | +Y | ++ |
| setFullscreenButtonEnabled(enabled bool) | +- | +Y | +Y | +There is no fullscreen button in Windows | +
| setHTML(html string) | +Y | +Y | +Y | ++ |
| setMaxSize(width, height int) | +Y | +Y | +Y | ++ |
| setMinSize(width, height int) | +Y | +Y | +Y | ++ |
| setRelativePosition(x int, y int) | +Y | +Y | +Y | ++ |
| setResizable(resizable bool) | +Y | +Y | +Y | ++ |
| setSize(width, height int) | +Y | +Y | +Y | ++ |
| setTitle(title string) | +Y | +Y | +Y | ++ |
| setURL(url string) | +Y | +Y | +Y | ++ |
| setZoom(zoom float64) | +Y | +Y | +Y | ++ |
| show() | +Y | +Y | +Y | ++ |
| size() (int, int) | +Y | +Y | +Y | ++ |
| toggleDevTools() | +Y | +Y | +Y | ++ |
| unfullscreen() | +Y | +Y | +Y | ++ |
| unmaximise() | +Y | +Y | +Y | ++ |
| unminimise() | +Y | +Y | +Y | ++ |
| width() int | +Y | +Y | +Y | ++ |
| zoom() | ++ | Y | +Y | ++ |
| zoomIn() | +Y | +Y | +Y | ++ |
| zoomOut() | +Y | +Y | +Y | ++ |
| zoomReset() | +Y | +Y | +Y | ++ |
| Feature | +Windows | +Linux | +Mac | +Notes | +
|---|---|---|---|---|
| Quit | +Y | +Y | +Y | ++ |
| Hide | +Y | +Y | +Y | ++ |
| Show | +Y | ++ | Y | ++ |
| Feature | +Windows | +Linux | +Mac | +Notes | +
|---|---|---|---|---|
| Info | +Y | +Y | +Y | ++ |
| Warning | +Y | +Y | +Y | ++ |
| Error | +Y | +Y | +Y | ++ |
| Question | +Y | +Y | +Y | ++ |
| OpenFile | +Y | +Y | +Y | ++ |
| SaveFile | +Y | +Y | +Y | ++ |
| Feature | +Windows | +Linux | +Mac | +Notes | +
|---|---|---|---|---|
| SetText | +Y | +Y | +Y | ++ |
| Text | +Y | +Y | +Y | ++ |
| Feature | +Windows | +Linux | +Mac | +Notes | +
|---|---|---|---|---|
| OpenContextMenu | +Y | +Y | +Y | ++ |
| On By Default | ++ | + | + | + |
| Control via HTML | +Y | ++ | + | + |
The default context menu is enabled by default for all elements that are
+contentEditable: true, <input> or <textarea> tags or have the
+--default-contextmenu: true style set. The --default-contextmenu: show style
+will always show the context menu The --default-contextmenu: hide style will
+always hide the context menu
Anything nested under a tag with --default-contextmenu: hide style will not
+show the context menu unless it is explicitly set with
+--default-contextmenu: show.
| Feature | +Windows | +Linux | +Mac | +Notes | +
|---|---|---|---|---|
| GetAll | +Y | +Y | +Y | ++ |
| GetPrimary | +Y | +Y | +Y | ++ |
| GetCurrent | +Y | +Y | +Y | ++ |
| Feature | +Windows | +Linux | +Mac | +Notes | +
|---|---|---|---|---|
| IsDarkMode | ++ | + | Y | ++ |
Y = Supported U = Untested
+| Feature | +Windows | +Linux | +Mac | +Notes | +
|---|---|---|---|---|
| Center | +Y | +Y | +Y | ++ |
| Focus | +Y | +Y | ++ | + |
| FullScreen | +Y | +Y | +Y | ++ |
| GetZoom | +Y | +Y | +Y | +Get current view scale | +
| Height | +Y | +Y | +Y | ++ |
| Hide | +Y | +Y | +Y | ++ |
| Maximise | +Y | +Y | +Y | ++ |
| Minimise | +Y | +Y | +Y | ++ |
| RelativePosition | +Y | +Y | +Y | ++ |
| Screen | +Y | +Y | +Y | +Get screen for window | +
| SetAlwaysOnTop | +Y | +Y | +Y | ++ |
| SetBackgroundColour | +Y | +Y | +Y | +https://github.com/MicrosoftEdge/WebView2Feedback/issues/1621#issuecomment-938234294 | +
| SetEnabled | +Y | +U | +- | +Set the window to be enabled/disabled | +
| SetMaxSize | +Y | +Y | +Y | ++ |
| SetMinSize | +Y | +Y | +Y | ++ |
| SetRelativePosition | +Y | +Y | +Y | ++ |
| SetResizable | +Y | +Y | +Y | ++ |
| SetSize | +Y | +Y | +Y | ++ |
| SetTitle | +Y | +Y | +Y | ++ |
| SetZoom | +Y | +Y | +Y | +Set view scale | +
| Show | +Y | +Y | +Y | ++ |
| Size | +Y | +Y | +Y | ++ |
| UnFullscreen | +Y | +Y | +Y | ++ |
| UnMaximise | +Y | +Y | +Y | ++ |
| UnMinimise | +Y | +Y | +Y | ++ |
| Width | +Y | +Y | +Y | ++ |
| ZoomIn | +Y | +Y | +Y | +Increase view scale | +
| ZoomOut | +Y | +Y | +Y | +Decrease view scale | +
| ZoomReset | +Y | +Y | +Y | +Reset view scale | +
A 'Y' in the table below indicates that the option has been tested and is +applied when the window is created. An 'X' indicates that the option is not +supported by the platform.
+| Feature | +Windows | +Linux | +Mac | +Notes | +
|---|---|---|---|---|
| AlwaysOnTop | +Y | +Y | ++ | + |
| BackgroundColour | +Y | +Y | ++ | + |
| BackgroundType | ++ | + | + | Acrylic seems to work but the others don't | +
| CSS | +Y | +Y | ++ | + |
| DevToolsEnabled | +Y | +Y | +Y | ++ |
| DisableResize | +Y | +Y | ++ | + |
| EnableDragAndDrop | ++ | Y | ++ | + |
| EnableFraudulentWebsiteWarnings | ++ | + | + | + |
| Focused | +Y | +Y | ++ | + |
| Frameless | +Y | +Y | ++ | + |
| FullscreenButtonEnabled | +Y | ++ | + | + |
| Height | +Y | +Y | ++ | + |
| Hidden | +Y | +Y | ++ | + |
| HTML | +Y | +Y | ++ | + |
| JS | +Y | +Y | ++ | + |
| Mac | +- | +- | ++ | + |
| MaxHeight | +Y | +Y | ++ | + |
| MaxWidth | +Y | +Y | ++ | + |
| MinHeight | +Y | +Y | ++ | + |
| MinWidth | +Y | +Y | ++ | + |
| Name | +Y | +Y | ++ | + |
| OpenInspectorOnStartup | ++ | + | + | + |
| StartState | +Y | ++ | + | + |
| Title | +Y | +Y | ++ | + |
| URL | +Y | +Y | ++ | + |
| Width | +Y | +Y | ++ | + |
| Windows | +Y | +- | +- | ++ |
| X | +Y | +Y | ++ | + |
| Y | +Y | +Y | ++ | + |
| Zoom | ++ | + | + | + |
| ZoomControlEnabled | ++ | + | + | + |
To log or not to log? System logger vs custom logger.
+| Event | +Windows | +Linux | +Mac | +Notes | +
|---|---|---|---|---|
| Default Application Menu | +Y | +Y | +Y | ++ |
| Feature | +Windows | +Linux | +Mac | +Notes | +
|---|---|---|---|---|
| Icon | +Y | +Y | +Y | +Windows has default icons for light/dark mode & supports PNG or ICO. | +
| Label | +- | +Y | +Y | ++ |
| Label (ANSI Codes) | +- | ++ | + | + |
| Menu | +Y | +Y | +Y | ++ |
| Method | +Windows | +Linux | +Mac | +Notes | +
|---|---|---|---|---|
| setLabel(label string) | +- | +Y | +Y | ++ |
| run() | +Y | +Y | +Y | ++ |
| setIcon(icon []byte) | +Y | +Y | +Y | ++ |
| setMenu(menu *Menu) | +Y | +Y | +Y | ++ |
| setIconPosition(position int) | +- | +Y | +Y | ++ |
| setTemplateIcon(icon []byte) | +- | +Y | +Y | ++ |
| destroy() | +Y | +Y | +Y | ++ |
| setDarkModeIcon(icon []byte) | +Y | +Y | +Y | +Darkmode isn't handled yet (linux) | +
Mapping native events to cross-platform events.
+| Event | +Windows | +Linux | +Mac | +Notes | +
|---|---|---|---|---|
| WindowWillClose | ++ | + | WindowWillClose | ++ |
| WindowDidClose | ++ | + | + | + |
| WindowDidResize | ++ | + | + | + |
| WindowDidHide | ++ | + | + | + |
| ApplicationWillTerminate | ++ | + | + | + |
... Add more
+Working well.
+Working well.
+Contains a lot needed for development.
+| Mode | +Windows | +Linux | +Mac | +Notes | +
|---|---|---|---|---|
| Dark | +Y | ++ | + | + |
| Light | +Y | ++ | + | + |
| System | +Y | ++ | + | + |
TBD
+All templates are working.
+Built-in plugin support:
+| Plugin | +Windows | +Linux | +Mac | +Notes | +
|---|---|---|---|---|
| Browser | +Y | ++ | Y | ++ |
| KV Store | +Y | +Y | +Y | ++ |
| Log | +Y | +Y | +Y | ++ |
| Single Instance | +Y | ++ | Y | ++ |
| SQLite | +Y | +Y | +Y | ++ |
| Start at login | +Y | ++ | Y | ++ |
| Server | ++ | + | + | + |
TODO:
+| + | Windows | +Linux | +Mac | +Notes | +
|---|---|---|---|---|
| Icon Generation | +Y | ++ | Y | ++ |
| Icon Embedding | +Y | ++ | Y | ++ |
| Info.plist | +- | ++ | Y | ++ |
| NSIS Installer | ++ | + | - | ++ |
| Mac bundle | +- | ++ | Y | ++ |
| Windows exe | +Y | ++ | - | ++ |
| Feature | +Windows | +Linux | +Mac | +Notes | +
|---|---|---|---|---|
| Resize | +Y | ++ | Y | ++ |
| Drag | +Y | +Y | +Y | +Linux - can always drag with Meta+left mouse |
+
| Feature | +Default | +Notes | +
|---|---|---|
| Backdrop | +MacBackdropNormal | +Standard solid window | +
| DisableShadow | +false | ++ |
| TitleBar | ++ | Standard window decorations by default | +
| Appearance | +DefaultAppearance | ++ |
| InvisibleTitleBarHeight | +0 | +Creates an invisible title bar for frameless windows | +
| DisableShadow | +false | +Disables the window drop shadow | +
| Feature | +Default | +Notes | +
|---|---|---|
| BackdropType | +Solid | ++ |
| DisableIcon | +false | ++ |
| Theme | +SystemDefault | ++ |
| CustomTheme | +nil | ++ |
| DisableFramelessWindowDecorations | +false | ++ |
| WindowMask | +nil | +Makes the window the contents of the bitmap | +
Implementation details for the functions utilized by the *_linux.go files are
+located in the following files:
By default CGO is utilized to compile the Linux port. This prevents easy +cross-compilation and so the PureGo implementation is also being simultaneously +developed.
+The examples can be compiled using the following command:
+CGO_ENABLED=0 go build -tags purego
+Note: things are currently not working after the refactor
+ + + + + + + + + + + + + +We welcome (and encourage) your feedback! Please search for existing tickets or +posts before creating new ones. Here are the different ways to provide feedback:
+If you find a bug, please let us know by posting into the v3 Alpha Feedback channel on Discord.
+Bug tag.wails doctor in your post.v3/example directory or create a new example in the v3/examples folder that clearly shows the issue.[v3 alpha test] <description of bug>.Warning
+Remember, unexpected behaviour isn't necessarily a bug - it might just not do what you expect it to do. Use Suggestions for this.
+If you have a fix for a bug or an update for documentation, please do the following:
+[v3 alpha].PR tag.If you have a suggestion, please let us know by posting into the v3 Alpha Feedback channel on Discord:
+Suggestion tag.Please feel free to reach out to us on Discord if you have any questions.
+
emoji. Please apply to any posts that are a priority for you.There is a list of known issues & work in progress can be found +here.
+To install the Wails CLI, ensure you have Go 1.21+ +installed and run:
+git clone https://github.com/wailsapp/wails.git
+cd wails
+git checkout v3-alpha
+cd v3/cmd/wails3
+go install
+Wails has a number of common dependencies that are required before installation:
+Download Go from the Go Downloads Page.
+Ensure that you follow the official Go installation instructions. You will also need to ensure that your PATH environment variable also includes the path to your ~/go/bin directory. Restart your terminal and do the following checks:
go version~/go/bin is in your PATH variable: echo $PATH | grep go/binAlthough Wails doesn't require npm to be installed, it is needed if you want to use the bundled templates.
+Download the latest node installer from the Node Downloads Page. It is best to use the latest release as that is what we generally test against.
+Run npm --version to verify.
The Wails CLI embeds a task runner called Task. It is optional, but recommended. If you do not wish to install Task, you can use the wails3 task command instead of task.
+Installing Task will give you the greatest flexibility.
You will also need to install platform specific dependencies:
+Wails requires that the xcode command line tools are installed. This can be +done by running:
+ +Wails requires that the WebView2 Runtime is installed. Some Windows installations will already have this installed. You can check using the wails doctor command.
Linux requires the standard gcc build tools plus libgtk3 and libwebkit. Rather than list a ton of commands for different distros, Wails can try to determine what the installation commands are for your specific distribution. Run wails doctor after installation to be shown how to install the dependencies. If your distro/package manager is not supported, please let us know on discord.
Running wails3 doctor will check if you have the correct dependencies
+installed. If not, it will advise on what is missing and help on how to rectify
+any problems.
wails3 command appears to be missing?#If your system is reporting that the wails3 command is missing, check the
+following:
go/bin directory is in the PATH environment variable.PATH variable.Now that you have created your first application, you can start exploring the other features that v3 alpha provides.
+The best place to start is the examples directory in the Wails repository.
+This contains a number of examples that you can run and play with.
To run an example, you can simply use:
+ +in the example directory.
+Note
+Some examples may not work during alpha development.
+Creating your first application with Wails v3 Alpha is an exciting journey into the world of modern desktop app development. This guide will walk you through the process of creating a basic application, showcasing the power and simplicity of Wails.
+Before you begin, ensure you have the following installed:
+Open your terminal and run the following command to create a new Wails project:
+wails3 init -n myfirstapp
This command creates a new directory called myfirstapp with all the necessary files.
Navigate to the myfirstapp directory. You'll find several files and folders:
build: Contains files used by the build process.frontend: Contains your web frontend code.go.mod & go.sum: Go module files.main.go: The entry point for your Wails application.Taskfile.yml: Defines all the tasks used by the build system. Learn more at the Task website.Take a moment to explore these files and familiarize yourself with the structure.
+Note
+Although Wails v3 uses Task as its default build system, there is nothing stopping you from using make or any other alternative build system.
To build your application, execute:
+wails3 build
This command compiles a debug version of your application and saves it in a new bin directory.
+You can run this like you would any normal application:
./bin/myfirstapp
bin\myfirstapp.exe
./bin/myfirstapp
You'll see a simple UI, the starting point for your application. As it is the debug version, you'll also see logs in the console window. This is useful for debugging purposes.
+Now, let's make a small change:
+frontend/main.js.<h1>Hello Wails!</h1> to <h1>Hello World!</h1>.Once you're happy with your changes, build your application again:
+wails3 build
You'll notice that the build time was faster this time. That's because the new build system only builds the parts of your application that have changed.
+You should see a new executable in the build directory.
Congratulations! You've just created and built your first Wails application. This is just the beginning of what you can achieve with Wails v3 Alpha. Explore the documentation, experiment with different features, and start building amazing applications!
+ + + + + + + + + + + + + +Welcome to the Wails v3 Alpha documentation. This is your starting point for exploring the latest version of Wails, a powerful framework for building desktop applications using Go and modern web technologies.
+Wails v3 Alpha is the latest iteration of the Wails project, bringing new features and improvements to make desktop application development more efficient and enjoyable. This version is still in alpha, so some features might change before the final release.
+Here are some of the exciting new features and improvements in Wails v3 Alpha:
+More information about these features and other changes can be found in the What's new section.
+To get started with Wails v3 Alpha:
+Please note that this is an alpha version of Wails v3. Features may be added, removed, or changed in future updates. This version is intended for early adopters and those who wish to contribute to the development of Wails.
+Your feedback is vital to making Wails better. If you encounter any issues or have suggestions, please use our Feedback process. Contributions to the project are also welcome!
+Thank you for trying out Wails v3 Alpha!
+ + + + + + + + + + + + + +The Wails runtime is the standard library for Wails applications. It provides a number of features that may +be used in your applications, including:
+The runtime is required for integration between Go and the frontend. There are 2 ways to integrate the runtime:
+@wailsio/runtime package@wailsio/runtime package#The @wailsio/runtime package is a JavaScript package that provides access to the Wails runtime. It is used in by all
+the standard templates and is the recommended way to integrate the runtime into your application. By using the package,
+you will only include the parts of the runtime that you use.
The package is available on npm and can be installed using:
+ +Some projects will not use a Javascript bundler and may prefer to use a pre-built version of the runtime. This is
+the default for the examples in v3/examples. The pre-built version of the runtime can be generated using the
+following command:
This will generate a runtime.js (and runtime.debug.js) file in the current directory.
+This file can be used by your application by adding it to your assets directory (normally frontend/dist) and then including it in your HTML:
The roadmap is a living document and is subject to change. If you have any +suggestions, please open an issue. Each milestone will have a set of goals that +we are aiming to achieve. These are subject to change.
+The Alpha 5 cycle aims to bring Linux to parity (Alpha 4)with the other platforms.
+Note
+Report any issues you find using this guide.
+The Alpha 4 cycle aims to provide the dev and package commands.
+The wails dev command should do the following:
+- Build the application
+- Start the application
+- Start the frontend dev server
+- Watch for changes to the application code and rebuild/restart as necessary
The wails package command should do the following:
+- Build the application
+- Package the application in a platform specific format
+ - Windows: Standard executable, NSIS Installer
+ - Linux: AppImage
+ - MacOS: Standard executable, App Bundle
+- Support obfuscation of the application code
Note
+Report any issues you find using this guide.
+wails3 doctor and ensure that all dependencies are installed. wails3 init.Test the wails3 dev command:
wails3 dev in the project directory. It should run the application in development mode.wails3 dev -help to view options.Test the wails3 package command:
wails3 package in the project directory.wails3 package -help to view options.Review the table below and look for untested scenarios.
+Basically, try to break it and let us know if you find any issues! 
wails3 dev command:
| + | Mac | +Windows | +Linux | +
|---|---|---|---|
wails3 dev |
++ | + | + |
Go changes cause the application to be built twice
+Mac is partially working:
+wails3 package command:
| + | Mac | +Windows | +Linux | +
|---|---|---|---|
| Standard Executable | ++ | + | + |
| macOS Application Bundle | ++ | + | + |
| NSIS | ++ | + | + |
The Alpha 3 cycle aims to provide bindings support. Wails 3 uses a new static analysis approach which allows us to provide +a better bindings experience than in Wails 2. +We also want to get all examples working on Linux.
+You can generate bindings using the wails3 generate bindings command. This will generate bindings for all exported struct methods bound to your project.
+Run wails3 generate bindings -help to view options that govern how bindings are generated.
The tests for the bindings generator can be found here with the test data located in the testdata directory.
Review the table below and look for untested scenarios. The parser code and tests are located in v3/internal/parser. All tests can be run using go test ./... from the v3 directory.
+Basically, try to break it and let us know if you find any issues!
Bindings for struct (CallByID):
+| Scenario | +Windows | +Mac | +Linux | +
|---|---|---|---|
| Same package | ++ | + | + |
| Different package | ++ | + | + |
| Different package with same name | +on hold | +on hold | +on hold | +
| Containing another struct from same package | ++ | + | + |
| Containing another struct from different package | ++ | + | + |
| Containing an anonymous struct | ++ | + | + |
Bindings for struct (CallByName):
+| Scenario | +Windows | +Mac | +Linux | +
|---|---|---|---|
| Same package | +: clipboardLock.RLock() | +nan | +nan | +
| defer clipboardLock.RUnlock() | +nan | +nan | +nan | +
| clipboardText := C.getClipboardText() | +nan | +nan | +nan | +
| result := C.GoString(clipboardText) | +nan | +nan | +nan | +
| return result | +true: | ++ | + |
| Different package | ++ | + | + |
| Different package with same name | +on hold | +on hold | +on hold | +
| Containing another struct from same package | ++ | + | + |
| Containing another struct from different package | ++ | + | + |
| Containing an anonymous struct | ++ | + | + |
Models:
+| Scenario | +Windows | +Mac | +Linux | +
|---|---|---|---|
| Class model for struct in same package | ++ | + | + |
| Class model for struct in different package | ++ | + | + |
| Interface model for struct in same package | ++ | + | + |
| Interface model for struct in different package | ++ | + | + |
| Enum in same package | ++ | + | + |
| Enum in different package | ++ | + | + |
| Interface using enum in same package | ++ | + | + |
| Interface using enum in different package | ++ | + | + |
Examples:
+Alpha 2 aims to introduce Taskfile support. This will +allow us to have a single, extensible build system that works on all platforms. +We also want to get all examples working on Linux.
+Init & Build commands
+- Working
+| + | Mac | +Windows | +Linux | +WSL | +
|---|---|---|---|---|
wails init |
++ | + | + | + |
wails build |
++ | + | + | + |
Alpha 1 is the initial release. It is intended to get feedback on the new API +and to get people experimenting with it. The main goal is to get most of the +examples working on all platforms.
+| + | Mac | +Windows | +Linux | +
|---|---|---|---|
| binding | ++ | + | + |
| build | ++ | + | + |
| clipboard | ++ | + | + |
| context menus | ++ | + | + |
| dialogs | ++ | + | + |
| drag-n-drop | ++ | + | + |
| events | ++ | + | + |
| frameless | ++ | + | + |
| keybindings | ++ | + | + |
| plain | ++ | + | + |
| screen | ++ | + | + |
| systray | ++ | + | + |
| video | ++ | + | + |
| window | ++ | + | + |
| wml | ++ | + | + |
Wails v3 Alpha moves from the v2's single-window, declarative API to a procedural one. This intuitive API makes code development easier, boosts readability, and unlocks complex multi-window apps. Wails v3 Alpha isn't just an improvement on past versions - it reimagines desktop application development capabilities with Go and modern web technologies.
+It's now possible to create multiple windows and configure each one +independently.
+package main
+
+import (
+ _ "embed"
+ "log"
+
+ "github.com/wailsapp/wails/v3/pkg/application"
+)
+
+//go:embed assets/*
+var assets embed.FS
+
+func main() {
+
+ app := application.New(application.Options{
+ Name: "Multi Window Demo",
+ Assets: application.AssetOptions{
+ FS: assets,
+ },
+ })
+
+ window1 := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{
+ Title: "Window 1",
+ })
+
+ window2 := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{
+ Title: "Window 2",
+ })
+
+ // load the embedded html from the embed.FS
+ window1.SetURL("/")
+ window1.Center()
+
+ // Load an external URL
+ window2.SetURL("https://wails.app")
+
+ err := app.Run()
+
+ if err != nil {
+ log.Fatal(err.Error())
+ }
+}
+Systrays allow you to add an icon in the system tray area of your desktop and +have the following features:
+package main
+
+import (
+ _ "embed"
+ "log"
+ "runtime"
+
+ "github.com/wailsapp/wails/v3/pkg/application"
+ "github.com/wailsapp/wails/v3/pkg/icons"
+)
+
+func main() {
+ app := application.New(application.Options{
+ Name: "Systray Demo",
+ Mac: application.MacOptions{
+ ActivationPolicy: application.ActivationPolicyAccessory,
+ },
+ })
+
+ window := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{
+ Width: 500,
+ Height: 800,
+ Frameless: true,
+ AlwaysOnTop: true,
+ Hidden: true,
+ Windows: application.WindowsWindow{
+ HiddenOnTaskbar: true,
+ },
+ })
+
+ systemTray := app.NewSystemTray()
+
+ // Support for template icons on macOS
+ if runtime.GOOS == "darwin" {
+ systemTray.SetTemplateIcon(icons.SystrayMacTemplate)
+ } else {
+ // Support for light/dark mode icons
+ systemTray.SetDarkModeIcon(icons.SystrayDark)
+ systemTray.SetIcon(icons.SystrayLight)
+ }
+
+ // Support for menu
+ myMenu := app.NewMenu()
+ myMenu.Add("Hello World!").OnClick(func(_ *application.Context) {
+ println("Hello World!")
+ })
+ systemTray.SetMenu(myMenu)
+
+ // This will center the window to the systray icon with a 5px offset
+ // It will automatically be shown when the systray icon is clicked
+ // and hidden when the window loses focus
+ systemTray.AttachWindow(window).WindowOffset(5)
+
+ err := app.Run()
+ if err != nil {
+ log.Fatal(err)
+ }
+}
+Plugins allow you to extend the functionality of the Wails system. Not only can +plugin methods be used in Go, but also called from Javascript. Included plugins:
+v3 uses a new static analyser to generate bindings. This makes it extremely fast +and maintains comments and parameter names in your bindings. By default, +bindings are generated with calls using IDs instead of strings. This provides a +performance boost and allows for using obfuscation tools such as +garble.
+Bindings are generated by simply running wails3 generate bindings in the
+project directory.
// @ts-check
+// Cynhyrchwyd y ffeil hon yn awtomatig. PEIDIWCH Â MODIWL
+// This file is automatically generated. DO NOT EDIT
+
+import { main } from "./models";
+
+window.go = window.go || {};
+window.go.main = {
+ GreetService: {
+ /**
+ * GreetService.Greet
+ * Greet greets a person
+ * @param name {string}
+ * @returns {Promise<string>}
+ **/
+ Greet: function (name) {
+ wails.CallByID(1411160069, ...Array.prototype.slice.call(arguments, 0));
+ },
+
+ /**
+ * GreetService.GreetPerson
+ * GreetPerson greets a person
+ * @param person {main.Person}
+ * @returns {Promise<string>}
+ **/
+ GreetPerson: function (person) {
+ wails.CallByID(4021313248, ...Array.prototype.slice.call(arguments, 0));
+ },
+ },
+};
+In v2, the build system was completely opaque and hard to customise. In v3, it's +possible to build everything using standard Go tooling.
+All the heavy lifting that the v2 build system did, such as icon generation, +have been added as tool commands in the CLI. We have incorporated +Taskfile into the CLI to orchestrate these calls to +bring the same developer experience as v2. However, this approach brings the +ultimate balance of flexibility and ease of use as you can now customise the +build process to your needs.
+You can even use make if that's your thing!
+build:darwin:
+ summary: Builds the application
+ platforms:
+ - darwin
+ cmds:
+ - task: pre-build
+ - task: build-frontend
+ - go build -gcflags=all="-N -l" -o bin/{{.APP_NAME}}
+ - task: post-build
+ env:
+ CGO_CFLAGS: "-mmacosx-version-min=10.13"
+ CGO_LDFLAGS: "-mmacosx-version-min=10.13"
+ MACOSX_DEPLOYMENT_TARGET: "10.13"
+Events are now emitted for a lot of the runtime operations, allowing you to hook +into application/system events. Cross-platform (common) events are also emitted +where there are common platform events, allowing you to write the same event +handling methods cross platform.
+Event hooks can also be registered. These are like the On method but are
+synchronous and allow you to cancel the event. An example of this would be to
+show a confirmation dialog before closing a window.
package main
+
+import (
+ _ "embed"
+ "log"
+ "time"
+
+ "github.com/wailsapp/wails/v3/pkg/application"
+ "github.com/wailsapp/wails/v3/pkg/events"
+)
+
+//go:embed assets
+var assets embed.FS
+
+func main() {
+
+ app := application.New(application.Options{
+ Name: "Events Demo",
+ Description: "A demo of the Events API",
+ Assets: application.AssetOptions{
+ FS: assets,
+ },
+ Mac: application.MacOptions{
+ ApplicationShouldTerminateAfterLastWindowClosed: true,
+ },
+ })
+
+ // Custom event handling
+ app.Events.On("myevent", func(e *application.WailsEvent) {
+ log.Printf("[Go] WailsEvent received: %+v\n", e)
+ })
+
+ // OS specific application events
+ app.On(events.Mac.ApplicationDidFinishLaunching, func(event *application.Event) {
+ println("events.Mac.ApplicationDidFinishLaunching fired!")
+ })
+
+ // Platform agnostic events
+ app.On(events.Common.ApplicationStarted, func(event *application.Event) {
+ println("events.Common.ApplicationStarted fired!")
+ })
+
+ win1 := app.NewWebviewWindowWithOptions(application.WebviewWindowOptions{
+ Title: "Takes 3 attempts to close me!",
+ })
+
+ var countdown = 3
+
+ // Register a hook to cancel the window closing
+ win1.RegisterHook(events.Common.WindowClosing, func(e *application.WindowEvent) {
+ countdown--
+ if countdown == 0 {
+ println("Closing!")
+ return
+ }
+ println("Nope! Not closing!")
+ e.Cancel()
+ })
+
+ win1.On(events.Common.WindowFocus, func(e *application.WindowEvent) {
+ println("[Event] Window focus!")
+ })
+
+ err := app.Run()
+
+ if err != nil {
+ log.Fatal(err.Error())
+ }
+}
+An experimental feature to call runtime methods using plain html, similar to +htmx.
+<!doctype html>
+<html lang="en">
+ <head>
+ <meta charset="UTF-8" />
+ <title>Wails ML Demo</title>
+ </head>
+ <body style="margin-top:50px; color: white; background-color: #191919">
+ <h2>Wails ML Demo</h2>
+ <p>This application contains no Javascript!</p>
+ <button wml-event="button-pressed">Press me!</button>
+ <button wml-event="delete-things" wml-confirm="Are you sure?">
+ Delete all the things!
+ </button>
+ <button wml-window="Close" wml-confirm="Are you sure?">
+ Close the Window?
+ </button>
+ <button wml-window="Center">Center</button>
+ <button wml-window="Minimise">Minimise</button>
+ <button wml-window="Maximise">Maximise</button>
+ <button wml-window="UnMaximise">UnMaximise</button>
+ <button wml-window="Fullscreen">Fullscreen</button>
+ <button wml-window="UnFullscreen">UnFullscreen</button>
+ <button wml-window="Restore">Restore</button>
+ <div
+ style="width: 200px; height: 200px; border: 2px solid white;"
+ wml-event="hover"
+ wml-trigger="mouseover"
+ >
+ Hover over me
+ </div>
+ </body>
+</html>
+There are more examples available in the examples directory. Check them out!
+ + + + + + + + + + + + + +