Wails

https://wails.io/docs
Admin
Wails is a lightweight framework for building desktop applications using Go and web technologies,...
Tokens:108,745
Snippets:1,019
Trust Score:9.1
Update:1 week ago
Show doc for...
Tokens:
Raw
### List Android emulators, start emulator, and run app

Source: https://wails.io/docs/guides/mobile

Use emulator -list-avds to list available Android emulators, start one with emulator -avd Pixel_7_API_34, then install and run the app with task android:run.

```bash
# List available emulators  

emulator -list-avds  

  

# Start emulator  

emulator -avd Pixel_7_API_34  

  

# Install and run  

task android:run  

```

--------------------------------

### Install and remove dependencies

Source: https://wails.io/docs/guides/sveltekit

Run these commands in the 'frontend' folder to install dependencies, remove the auto adapter, and install the static adapter.

```bash
npm i
```

```bash
npm uninstall @sveltejs/adapter-auto
```

```bash
npm i -D @sveltejs/adapter-static
```

--------------------------------

### Run Wails application with extended Windows privileges

Source: https://wails.io/docs/guides/troubleshooting

This example demonstrates how to re-launch the application with SeBackupPrivilege, SeDebugPrivilege, and SeRestorePrivilege to allow WebView2 to function correctly when running as administrator. It uses a custom data directory and ensures the process token is configured before starting the Wails application.

```go
package main  
  
  

import (  

	"embed"  

	"os"  

	"runtime"  

  

	"github.com/fourcorelabs/wintoken"  

	"github.com/hectane/go-acl"  

	"github.com/wailsapp/wails/v2"  

	"github.com/wailsapp/wails/v2/pkg/options"  

	"github.com/wailsapp/wails/v2/pkg/options/assetserver"  

	"github.com/wailsapp/wails/v2/pkg/options/windows"  

)  

  

//go:embed all:frontend/dist  

var assets embed.FS  

  

const (  

	fixedTokenKey = "SAMPLE_RANDOM_KEY"  

	fixedTokenVal = "with-fixed-token"  

	webviewDir    = "C:\\ProgramData\\Sample"  

)  

  

func runWithFixedToken() {  

	println("Re-launching self")  

	token, err := wintoken.OpenProcessToken(0, wintoken.TokenPrimary) //pass 0 for own process  

	if err != nil {  

		panic(err)  

	}  

	defer token.Close()  

  

	token.EnableTokenPrivileges([]string{  

		"SeBackupPrivilege",  

		"SeDebugPrivilege",  

		"SeRestorePrivilege",  

	})  

  

	cmd := exec.Command(os.Args[0])  

	cmd.Args = os.Args  

	cmd.Env = os.Environ()  

	cmd.Env = append(cmd.Env, fmt.Sprintf("%v=%v", fixedTokenKey, fixedTokenVal))  

	cmd.Stdin = os.Stdin  

	cmd.Stdout = os.Stdout  

	cmd.Stderr = os.Stderr  

	cmd.SysProcAttr = &syscall.SysProcAttr{Token: syscall.Token(token.Token())}  

	if err := cmd.Run(); err != nil {  

		println("Error after launching self:", err)  

		os.Exit(1)  

	}  

	println("Clean self launch :)")  

	os.Exit(0)  

}  

  

func main() {  

	if runtime.GOOS == "windows" && os.Getenv(fixedTokenKey) != fixedTokenVal {  

		runWithFixedToken()  

	}  

  

	println("Setting data dir to", webviewDir)  

	if err := os.MkdirAll(webviewDir, os.ModePerm); err != nil {  

		println("Failed creating dir:", err)  

	}  

	if err := acl.Chmod(webviewDir, 0777); err != nil {  

		println("Failed setting ACL on dir:", err)  

	}  

  

	app := NewApp()  

  

	err := wails.Run(&options.App{  

		Title:  "sample-data-dir",  

		Width:  1024,  

		Height: 768,  

		AssetServer: &assetserver.Options{  

			Assets: assets,  

		},  

		Bind: []interface{}{  

			app,  

		},  

		Windows: &windows.Options{  

			WebviewUserDataPath: webviewDir,  

		},  

	})  

  

	if err != nil {  

		println("Error:", err.Error())  

	}  

}
```

--------------------------------

### Example Info.plist file

Source: https://wails.io/docs/guides/signing

An example Info.plist file for a MacOS application. Ensure the bundle ID matches the one used in gon-sign.json.

```xml
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">  

<plist version="1.0"><dict>  

	<key>CFBundlePackageType</key><string>APPL</string>  

	<key>CFBundleName</key><string>MyApp</string>  

	<key>CFBundleExecutable</key><string>app</string>  

	<key>CFBundleIdentifier</key><string>app.myapp</string>  

	<key>CFBundleVersion</key><string>0.1.0</string>  

	<key>CFBundleGetInfoString</key><string>My app is cool and nice and chill and</string>  

	<key>CFBundleShortVersionString</key><string>0.1.0</string>  

	<key>CFBundleIconFile</key><string>iconfile</string>  

	<key>LSMinimumSystemVersion</key><string>10.13.0</string>  

	<key>NSHighResolutionCapable</key><string>true</string>  

	<key>LSApplicationCategoryType</key><string>public.app-category.utilities</string>  

	<key>NSHumanReadableCopyright</key><string>© Me</string>  

</dict></plist>
```

--------------------------------

### v2: Runtime example with context

Source: https://wails.io/docs/guides/migrating

In v2, the runtime is in its own package and each method takes a `context.Context` passed to the `OnStartup` method. This example shows a `startup` method that logs an info message using `runtime.LogInfo`.

```go
package main  

  

import "github.com/wailsapp/wails/v2/pkg/runtime"  

  

type Basic struct {  

	ctx context.Context  

}  

  

// startup is called at application startup  

func (a *App) startup(ctx context.Context) {  

	a.ctx = ctx  

	runtime.LogInfo(ctx, "Application Startup called!")  

}  
```

--------------------------------

### Windows: Parse command-line arguments for file association

Source: https://wails.io/docs/guides/file-association

On Windows, when a file is opened with the app, a new instance is launched and the file path is passed as a command-line argument. This example shows how to parse os.Args to get the file path.

```go
func main() {  

	argsWithoutProg := os.Args[1:]  

  

	if len(argsWithoutProg) != 0 {  

    println("launchArgs", argsWithoutProg)  

  }  

}  

```

--------------------------------

### Verify Go Installation

Source: https://wails.io/docs/gettingstarted/installation

Commands to verify that Go is installed and that the Go binary directory is correctly included in your system PATH.

```bash
go version
```

```bash
echo $PATH | grep go/bin
```

--------------------------------

### Install frontend dependencies manually

Source: https://wails.io/docs/guides/manual-builds

The frontend dependency installation step can be performed manually using the standard npm install command.

```bash
npm install
```

--------------------------------

### Install gst-plugins-good on Fedora

Source: https://wails.io/docs/guides/linux

Install command for Fedora systems.

```bash
dnf install gstreamer1-plugins-good
```

--------------------------------

### MessageDialog Question example

Source: https://wails.io/docs/reference/runtime/dialog

Example of a question dialog with a custom default button.

```go
	result, err := runtime.MessageDialog(a.ctx, runtime.MessageDialogOptions{  

		Type:          runtime.QuestionDialog,  

		Title:         "Question",  

		Message:       "Do you want to continue?",  

		DefaultButton: "No",  

	})  
```

--------------------------------

### Installation commands for runtime dependencies

Source: https://wails.io/docs/guides/linux-distro-support

Commands to install GTK3 and WebKit2GTK runtime libraries on various Linux distributions. Use the command matching the target distribution.

```bash
apt install libgtk-3-0 libwebkit2gtk-4.1-0
```

```bash
apt install libgtk-3-0 libwebkit2gtk-4.0-37
```

```bash
dnf install gtk3 webkit2gtk4.1
```

```bash
dnf install gtk3 webkit2gtk3
```

```bash
zypper install libgtk-3-0 libwebkit2gtk-4_1-0
```

```bash
pacman -S gtk3 webkit2gtk-4.1
```

--------------------------------

### Install Wails CLI from source

Source: https://wails.io/docs/guides/local-development

Commands to clone the Wails repository and install the CLI tool from the local source code.

```bash
git clone https://github.com/wailsapp/wails
cd wails/v2/cmd/wails
go install
```

--------------------------------

### Install gst-plugins-good on Arch

Source: https://wails.io/docs/guides/linux

Install command for Arch-based systems.

```bash
pacman -S gst-plugins-good
```

--------------------------------

### Example go.mod replace directives

Source: https://wails.io/docs/guides/local-development

Platform-specific examples for the replace directive in go.mod.

```text
On Windows: replace github.com/wailsapp/wails/v2 => C:\Users\leaan\Documents\wails-v2-beta\wails\v2
On 'nix: replace github.com/wailsapp/wails/v2 => /home/me/projects/wails/v2
```

--------------------------------

### Install gon via Homebrew

Source: https://wails.io/docs/guides/signing

Command to install the 'gon' tool for code signing and notarization on macOS runners.

```bash
- name: MacOS download gon for code signing and app notarization  

  if: matrix.platform == 'macos-latest'  

  run: |  

    brew install Bearer/tap/gon  
```

--------------------------------

### Code Sample: Emitting and Listening to Events

Source: https://wails.io/docs/reference/runtime/events

Example showing how to emit an event from Go and listen for it on the frontend using the Wails runtime.

```APIDOC
## Code Sample: Emitting and Listening to Events

### Description
This example demonstrates how to trigger an event from Go and listen for it on the frontend.

### Frontend (React)
```javascript
import {EventsOn, EventsOff } from "../wailsjs/runtime/runtime";
import { Auth } from "../wailsjs/go/main/App";

useEffect(() => {
    const handler = (event: any) => {
        // Handle event
        console.log(event);
    };

    EventsOn("auth:success", handler);

    return () => {
        EventsOff("auth:success");
    };
},[])

<button onClick={Auth}> verify auth </button>
```

### Go
```go
//app.go
import "github.com/wailsapp/wails/v2/pkg/runtime"

func (a *App) Auth() {
    runtime.EventsEmit(a.ctx, "auth:success", "user-123")
}
```
```

--------------------------------

### Accelerator parsing example

Source: https://wails.io/docs/reference/menus

Parses an accelerator string using Electron-like syntax, useful for storing accelerators in config files.

```go
    // Defines cmd+o on Mac and ctrl-o on Window/Linux  

    myShortcut, err := keys.Parse("Ctrl+Option+A")  
```

--------------------------------

### Output of 'wails build'

Source: https://wails.io/docs/tutorials/helloworld

Example output from the 'wails build' command. It shows the build configuration and the path to the compiled .exe file.

```text
Wails CLI v2.0.0  

App Type:               desktop  
Platforms:              windows/amd64  
Compiler:               C:\Users\leaan\go\go1.18.3\bin\go.exe  
Build Mode:             Production  
Devtools:               false  
Skip Frontend:          false  
Compress:               false  
Package:                true  
Clean Build Dir:        false  
LDFlags:                ""  
Tags:                   []  
Race Detector:          false  

Building target: windows/amd64  
------------------------------  
  - Installing frontend dependencies: Done.  
  - Compiling frontend: Done.  
  - Generating bundle assets: Done.  
  - Compiling application: Done.  
Built 'C:\Users\leaan\tutorial\helloworld\build\bin\helloworld.exe' in 10.616s.  
```

--------------------------------

### Backend method with variadic parameters

Source: https://wails.io/docs/guides/troubleshooting

Example of a Go backend method definition using variadic parameters.

```go
func (a *App) TestFunc(msg string, args ...interface{}) error {  

    // Code  

}  
```

--------------------------------

### Generate installer with wails build

Source: https://wails.io/docs/guides/windows-installer

Use the -nsis flag with the wails build command to generate the installer in the build/bin directory.

```bash
wails build -nsis  
```

--------------------------------

### OnBeforeClose callback example

Source: https://wails.io/docs/reference/options

Example of an OnBeforeClose callback that shows a confirmation dialog before quitting. Returning true prevents the application from closing, false continues shutdown.

```go
func (b *App) beforeClose(ctx context.Context) (prevent bool) {  

    dialog, err := runtime.MessageDialog(ctx, runtime.MessageDialogOptions{  

        Type:          runtime.QuestionDialog,  

        Title:         "Quit?",  

        Message:       "Are you sure you want to quit?",  

    })  

  

    if err != nil {  

        return false  

    }  

    return dialog != "Yes"  

}  
```

--------------------------------

### Test installation with wails dev

Source: https://wails.io/docs/guides/sveltekit

Run this command from the Wails project root to test the installation. If the application doesn't run, check the previous steps.

```bash
wails dev
```

--------------------------------

### Configure Wails Info section

Source: https://wails.io/docs/guides/windows-installer

The installer configuration uses the Info section from the project's wails.json file.

```json
// ...  

 "Info": {  

    "companyName": "My Company Name",  

    "productName": "Wails Vite",  

    "productVersion": "1.0.0",  

    "copyright": "Copyright.........",  

    "comments": "Built using Wails (https://wails.io)"  

  },  
```

--------------------------------

### Verify and Set NDK Path

Source: https://wails.io/docs/guides/mobile

Verify the NDK installation and set the NDK path explicitly to resolve the 'NDK not found' error. The path should point to the installed NDK version.

```bash
# Verify NDK installation  

ls $ANDROID_HOME/ndk  

  

# Set NDK path explicitly  

export ANDROID_NDK_HOME=$ANDROID_HOME/ndk/26.1.10909125  

```

--------------------------------

### Accelerator example using CmdOrCtrl

Source: https://wails.io/docs/reference/menus

Defines a keyboard shortcut that maps to cmd+o on Mac and ctrl-o on Windows/Linux.

```go
    // Defines cmd+o on Mac and ctrl-o on Window/Linux  

    myShortcut := keys.CmdOrCtrl("o")  
```

--------------------------------

### wails doctor output example

Source: https://wails.io/docs/reference/cli

Example output from running `wails doctor`. It shows the system scan results, installed dependencies (including optional ones marked with *), and a final diagnosis confirming the system is ready for Wails development.

```text
Wails CLI v2.0.0-beta  

  

Scanning system - Please wait (this may take a long time)...Done.  

System  

------  

OS:             Windows 10 Pro  

Version:        2009 (Build: 19043)  

ID:             21H1  

Go Version:     go1.18  

Platform:       windows  

Architecture:   amd64  

Dependency      Package Name    Status          Version  

----------      ------------    ------          -------  

WebView2        N/A             Installed       93.0.961.52  

npm             N/A             Installed       6.14.15  

*upx            N/A             Installed       upx 3.96  

* - Optional Dependency  

Diagnosis  

---------  

Your system is ready for Wails development!  

```

--------------------------------

### Output of 'wails init -n helloworld'

Source: https://wails.io/docs/tutorials/helloworld

Example output from the 'wails init -n helloworld' command. It confirms the project was created successfully.

```text
Wails CLI v2.0.0  

Initialising Project 'helloworld'  
---------------------------------  

Project Name:      helloworld  
Project Directory: C:\Users\leaan\tutorial\helloworld  
Project Template:  vanilla  
Template Support:  https://wails.io  

Initialised project 'helloworld' in 232ms.  
```

--------------------------------

### Example of macOS compilation error

Source: https://wails.io/docs/guides/troubleshooting

This error output indicates a potential mismatch between the OS version and the installed Xcode Command Line Tools.

```text
# github.com/wailsapp/wails/v2/internal/frontend/desktop/darwin  

In file included from ../../pkg/mod/github.com/wailsapp/wails/v2@v2.0.0-beta.44.2/internal/frontend/desktop/darwin/callbacks.go:9:  

In file included from /Library/Developer/CommandLineTools/SDKs/MacOSX12.1.sdk/System/Library/Frameworks/Foundation.framework/Headers/Foundation.h:12:  

/Library/Developer/CommandLineTools/SDKs/MacOSX12.1.sdk/System/Library/Frameworks/Foundation.framework/Headers/NSBundle.h:91:143: error: function does not return NSString  

- (NSAttributedString *)localizedAttributedStringForKey:(NSString *)key value:(nullable NSString *)value table:(nullable NSString *)tableName NS_FORMAT_ARGUMENT(1) NS_REFINED_FOR_SWIFT API_AVAILABLE(macos(12.0), ios(15.0), watchos(8.0), tvos(15.0));  

                                                         ~~~~~~~~~~~~~~                                                                       ^                  ~  

/Library/Developer/CommandLineTools/SDKs/MacOSX12.1.sdk/System/Library/Frameworks/Foundation.framework/Headers/NSObjCRuntime.h:103:48: note: expanded from macro 'NS_FORMAT_ARGUMENT'  

        #define NS_FORMAT_ARGUMENT(A) __attribute__ ((format_arg(A)))
```

--------------------------------

### React HashRouter

Source: https://wails.io/docs/guides/routing

Use HashRouter from react-router-dom to enable hash-based routing in React. The example shows a basic setup with routes for /, /page1, and /page2.

```jsx
import { HashRouter, Routes, Route } from "react-router-dom";  

ReactDOM.render(  
  <HashRouter basename={"/"}>  
    {/* The rest of your app goes here */}  
    <Routes>  
      <Route path="/" element={<Page0 />} exact />  
      <Route path="/page1" element={<Page1 />} />  
      <Route path="/page2" element={<Page2 />} />  
      {/* more... */}  
    </Routes>  
  </HashRouter>,  
  root  
);  

```

--------------------------------

### Configure and run application in main.go

Source: https://wails.io/docs/guides/application-development

The main.go file initializes the application struct and calls wails.Run with the desired configuration and lifecycle callbacks.

```go

func main() {  

  
	app := NewApp()  

  
	err := wails.Run(&options.App{  

		Title:             "My App",  

		Width:             800,  

		Height:            600,  

		OnStartup:  app.startup,  

		OnShutdown: app.shutdown,  

	})  

	if err != nil {  

		log.Fatal(err)  

	}  

}  


```

--------------------------------

### Create SvelteKit frontend with Svelte CLI

Source: https://wails.io/docs/guides/sveltekit

Run this command in the Wails project root to create a new SvelteKit project as the frontend. Follow the prompts; nothing Wails specific is needed.

```bash
npx sv create frontend
```

--------------------------------

### Create a template from an existing project

Source: https://wails.io/docs/guides/templates

Generate a template by pointing to an existing frontend project directory.

```bash
> wails generate template -name wails-vue3-template -frontend .\vue3-base\  

Extracting base template files...  

Migrating existing project files to frontend directory...  

Updating package.json data...  

Renaming package.json -> package.tmpl.json...  

Updating package-lock.json data...  

Renaming package-lock.json -> package-lock.tmpl.json...
```

--------------------------------

### v1: Create app with wails.CreateApp

Source: https://wails.io/docs/guides/migrating

In v1, the application is created with `wails.CreateApp`, bindings are added with `app.Bind`, and the app is run with `app.Run()`. This example shows the v1 pattern with title, dimensions, JS, CSS, and color options.

```go
 app := wails.CreateApp(&wails.AppConfig{  

    Title:  "MyApp",  

    Width:  1024,  

    Height: 768,  

    JS:     js,  

    CSS:    css,  

    Colour: "#131313",  

  })  

  app.Bind(basic)  

  app.Run()  
```

--------------------------------

### Install gst-plugins-good on Debian/Ubuntu

Source: https://wails.io/docs/guides/linux

Install command for Debian/Ubuntu systems.

```bash
apt-get install gstreamer1.0-plugins-good
```

--------------------------------

### CustomTheme usage example

Source: https://wails.io/docs/reference/options

Shows how to set CustomTheme with windows.ThemeSettings, using windows.RGB to convert RGB values to the Windows format. Any value not provided defaults to black.

```go
CustomTheme: &windows.ThemeSettings{  

    // Theme to use when window is active  

    DarkModeTitleBar:   windows.RGB(255, 0, 0),   // Red  

    DarkModeTitleText:  windows.RGB(0, 255, 0),   // Green  

    DarkModeBorder:     windows.RGB(0, 0, 255),   // Blue  

    LightModeTitleBar:  windows.RGB(200, 200, 200),  

    LightModeTitleText: windows.RGB(20, 20, 20),  

    LightModeBorder:    windows.RGB(200, 200, 200),  

    // Theme to use when window is inactive  

    DarkModeTitleBarInactive:   windows.RGB(128, 0, 0),  

    DarkModeTitleTextInactive:  windows.RGB(0, 128, 0),  

    DarkModeBorderInactive:     windows.RGB(0, 0, 128),  

    LightModeTitleBarInactive:  windows.RGB(100, 100, 100),  

    LightModeTitleTextInactive: windows.RGB(10, 10, 10),  

    LightModeBorderInactive:    windows.RGB(100, 100, 100),  

},  

```

--------------------------------

### v2: Create app with wails.Run

Source: https://wails.io/docs/guides/migrating

In v2, the application is created and run with a single `wails.Run()` call that accepts application options. This example shows the v2 pattern with title, dimensions, asset server, and bindings.

```go
	err := wails.Run(&options.App{  

		Title:  "MyApp",  

		Width:  800,  

		Height: 600,  

		AssetServer: &assetserver.Options{  

			Assets: assets,  

		},  

		Bind:   []interface{}{  

			basic,  

		},  

	})  
```

--------------------------------

### Verify NPM Installation

Source: https://wails.io/docs/gettingstarted/installation

Command to verify that NPM is installed correctly.

```bash
npm --version
```

--------------------------------

### Install NSIS with Chocolatey

Source: https://wails.io/docs/guides/windows-installer

Use the Chocolatey package manager to install NSIS.

```bash
choco install nsis  
```

--------------------------------

### Create .desktop file for custom protocol scheme

Source: https://wails.io/docs/guides/custom-protocol-schemes

Specifies the MimeType as x-scheme-handler/myapp and uses %u in Exec to pass the URL as an argument.

```desktop
[Desktop Entry]  

Categories=Office  

Exec=/usr/bin/wails-open-file %u  

Icon=wails-open-file.png  

Name=wails-open-file  

Terminal=false  

Type=Application  

MimeType=x-scheme-handler/myapp;  

```

--------------------------------

### Basic Wails Application Configuration

Source: https://wails.io/docs/howdoesitwork

A standard main.go file demonstrating the wails.Run() call, application options, and method binding.

```go
package main  
  
  

import (  

	"embed"  

	"log"  

  

	"github.com/wailsapp/wails/v2"  

	"github.com/wailsapp/wails/v2/pkg/options"  

  "github.com/wailsapp/wails/v2/pkg/options/assetserver"  

)  

  

//go:embed all:frontend/dist  

var assets embed.FS  

  

func main() {  

  

	app := &App{}  

  

	err := wails.Run(&options.App{  

		Title:  "Basic Demo",  

		Width:  1024,  

		Height: 768,  

		AssetServer: &assetserver.Options{  

			Assets: assets,  

		},  

		OnStartup:  app.startup,  

		OnShutdown: app.shutdown,  

		Bind: []interface{}{  

			app,  

		},  

	})  

	if err != nil {  

		log.Fatal(err)  

	}  

}  

  

  

  

type App struct {  

	ctx context.Context  

}  

  

func (b *App) startup(ctx context.Context) {  

	b.ctx = ctx  

}  

  

func (b *App) shutdown(ctx context.Context) {}  

  

func (b *App) Greet(name string) string {  

	return fmt.Sprintf("Hello %s!", name)  

}
```

--------------------------------

### Install NSIS with Winget

Source: https://wails.io/docs/guides/windows-installer

Use Winget to install NSIS on Windows 10 or later.

```bash
winget install NSIS.NSIS --silent  
```

--------------------------------

### Install NSIS with Scoop

Source: https://wails.io/docs/guides/windows-installer

Use Scoop to install NSIS, which automatically adds it to your PATH.

```bash
scoop bucket add extras  

scoop install nsis  
```

--------------------------------

### MessageDialog Mac buttons example

Source: https://wails.io/docs/reference/runtime/dialog

Example of a message dialog on Mac with multiple buttons.

```go
selection, err := runtime.MessageDialog(b.ctx, runtime.MessageDialogOptions{  

    Title:        "It's your turn!",  

    Message:      "Select a number",  

    Buttons:      []string{"one", "two", "three", "four"},  

})  
```

--------------------------------

### Install Wails CLI

Source: https://wails.io/docs/gettingstarted/installation

Command to install the latest version of the Wails CLI via Go.

```bash
go install github.com/wailsapp/wails/v2/cmd/wails@latest
```

--------------------------------

### InitializeNotifications - Go and JavaScript

Source: https://wails.io/docs/reference/runtime/notification

Initializes the notification system during app startup. Returns an error if initialization fails.

```go
err := runtime.InitializeNotifications(ctx)  

if err != nil {  

    log.Fatal(err)  

}  

```

```javascript
await runtime.InitializeNotifications();  

```

--------------------------------

### Install macOS Xcode Tools

Source: https://wails.io/docs/gettingstarted/installation

Command to install the required Xcode command line tools on macOS.

```bash
xcode-select --install
```

--------------------------------

### Build with clean and output filename

Source: https://wails.io/docs/reference/cli

Builds the project, cleaning the build/bin directory and specifying the output filename as myproject.exe.

```bash
wails build -clean -o myproject.exe
```

--------------------------------

### MessageDialog Mac default button example

Source: https://wails.io/docs/reference/runtime/dialog

Example of a message dialog on Mac specifying a default button.

```go
selection, err := runtime.MessageDialog(b.ctx, runtime.MessageDialogOptions{  

    Title:         "It's your turn!",  

    Message:       "Select a number",  

    Buttons:       []string{"one", "two", "three", "four"},  

    DefaultButton: "two",  

})  
```

--------------------------------

### Project layout for assets

Source: https://wails.io/docs/guides/migrating

This example shows a typical project layout where all final assets are placed in the `frontend/dist` directory, which Wails scans for `index.html` to use as the root path for other assets.

```text
.  

├── build/  

├── frontend/  

│   └── dist/  

│       ├── index.html  

│       ├── main.js  

│       ├── main.css  

│       └── logo.svg  

├── main.go  

└── wails.json  
```

--------------------------------

### MessageDialog Mac cancel button example

Source: https://wails.io/docs/reference/runtime/dialog

Example of a message dialog on Mac specifying both default and cancel buttons.

```go
selection, err := runtime.MessageDialog(b.ctx, runtime.MessageDialogOptions{  

    Title:         "It's your turn!",  

    Message:       "Select a number",  

    Buttons:       []string{"one", "two", "three", "four"},  

    DefaultButton: "two",  

    CancelButton:  "three",  

})  
```

--------------------------------

### Files created by 'wails init'

Source: https://wails.io/docs/tutorials/helloworld

Lists the files generated in the 'helloworld' project directory by the init command.

```text
build/       - Contains the build files + compiled application  
frontend/    - Contains the frontend files  
app.go       - Contains the application code  
main.go      - The main program with the application configuration  
wails.json   - The project configuration file  
go.mod       - The go module file  
go.sum       - The go module checksum file  
```

--------------------------------

### Verify Go Version for Wails

Source: https://wails.io/docs/gettingstarted/installation

Command to check the installed Go version if you encounter template pattern errors during installation.

```bash
go version
```

--------------------------------

### Parse command line arguments on Windows

Source: https://wails.io/docs/guides/custom-protocol-schemes

On Windows, when a custom protocol URL is opened, a new instance is launched and the URL is passed as a command-line argument. This example prints the arguments.

```go
func main() {
	argsWithoutProg := os.Args[1:]

	if len(argsWithoutProg) != 0 {
    println("launchArgs", argsWithoutProg)
  }
}
```

--------------------------------

### Bind a struct instance in main.go

Source: https://wails.io/docs/howdoesitwork

Creates an App instance and passes it to the Bind option in wails.Run. The App struct has a Greet method that returns a formatted string. Requires importing the necessary Wails packages and embedding frontend assets.

```go
package main

import (
	"embed"
	"log"

	"github.com/wailsapp/wails/v2"
	"github.com/wailsapp/wails/v2/pkg/options"
  "github.com/wailsapp/wails/v2/pkg/options/assetserver"
)

//go:embed all:frontend/dist
var assets embed.FS

func main() {

	app := &App{}

	err := wails.Run(&options.App{
		Title:  "Basic Demo",
		Width:  1024,
		Height: 768,
		AssetServer: &assetserver.Options{
			Assets: assets,
		},
		Bind: []interface{}{
			app,
		},
	})
	if err != nil {
		log.Fatal(err)
	}
}


type App struct {
	ctx context.Context
}

func (a *App) Greet(name string) string {
	return fmt.Sprintf("Hello %s!", name)
}
```

--------------------------------

### Example of creating notification actions (Go)

Source: https://wails.io/docs/reference/runtime/notification

Shows how to create a slice of NotificationAction values. The Destructive flag is ignored on Windows and Linux, but on macOS it renders the button in red.

```go
actions := []runtime.NotificationAction{  

    {ID: "SAVE", Title: "Save"},  

    {ID: "DELETE", Title: "Delete", Destructive: true}, // Shows as red button on macOS  

}  
```

--------------------------------

### Example Entitlements File

Source: https://wails.io/docs/guides/mac-appstore

An example entitlements.plist file required for Apple's App Sandbox. Replace TEAM_ID and APP_NAME with your specific identifiers.

```xml
<?xml version="1.0" encoding="UTF-8"?>  

<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">  

<plist version="1.0">  

<dict>  

    <key>com.apple.security.app-sandbox</key>  

    <true/>  

    <key>com.apple.security.network.client</key>  

    <true/>  

    <key>com.apple.security.network.server</key>  

    <true/>  

    <key>com.apple.security.files.user-selected.read-write</key>  

    <true/>  

    <key>com.apple.security.files.downloads.read-write</key>  

    <true/>  

    <key>com.apple.application-identifier</key>  

    <string>TEAM_ID.APP_NAME</string>  

    <key>com.apple.developer.team-identifier</key>  

    <string>TEAM_ID</string>  

</dict>  

</plist>
```
Tokens:
Raw