docs: sync translations (#3001)

Co-authored-by: leaanthony <leaanthony@users.noreply.github.com>
Co-authored-by: Lea Anthony <lea.anthony@gmail.com>

website/i18n/fr/docusaurus-plugin-content-docs/current/guides/custom-protocol-schemes.mdx

@@ -0,0 +1,204 @@
+# Custom Protocol Scheme association
+
+Custom Protocols feature allows you to associate specific custom protocol with your app so that when users open links with this protocol,
+your app is launched to handle them. This can be particularly useful to connect your desktop app with your web app.
+In this guide, we'll walk through the steps to implement custom protocols in Wails app.
+
+## Set Up Custom Protocol Schemes Association:
+
+To set up custom protocol, you need to modify your application's wails.json file.
+In "info" section add a "protocols" section specifying the protocols your app should be associated with.
+
+For example:
+
+```json
+{
+  "info": {
+    "protocols": [
+      {
+        "scheme": "myapp",
+        "description": "My App Protocol",
+        "role": "Editor"
+      }
+    ]
+  }
+}
+```
+
+| Property    | Description                                                                           |
+| :---------- | :------------------------------------------------------------------------------------ |
+| scheme      | Custom Protocol scheme. e.g. myapp                                                    |
+| description | Windows-only. The description.                                                        |
+| role        | macOS-only. The app’s role with respect to the type. Corresponds to CFBundleTypeRole. |
+
+## Platform Specifics:
+
+### macOS
+
+When you open custom protocol with your app, the system will launch your app and call the `OnUrlOpen` function in your Wails app. Example:
+
+```go title="main.go"
+func main() {
+	// Create application with options
+	err := wails.Run(&options.App{
+		Title:  "wails-open-file",
+		Width:  1024,
+		Height: 768,
+		AssetServer: &assetserver.Options{
+			Assets: assets,
+		},
+		BackgroundColour: &options.RGBA{R: 27, G: 38, B: 54, A: 1},
+		Mac: &mac.Options{
+			OnUrlOpen: func(url string) { println(url) },
+		},
+		Bind: []interface{}{
+			app,
+		},
+	})
+
+	if err != nil {
+		println("Error:", err.Error())
+	}
+}
+```
+
+### Windows
+
+On Windows Custom Protocol Schemes is supported only with NSIS installer. During installation, the installer will create a
+registry entry for your schemes. When you open url with your app, new instance of app is launched and url is passed
+as argument to your app. To handle this you should parse command line arguments in your app. Example:
+
+```go title="main.go"
+func main() {
+	argsWithoutProg := os.Args[1:]
+
+	if len(argsWithoutProg) != 0 {
+    println("launchArgs", argsWithoutProg)
+  }
+}
+```
+
+You also can enable single instance lock for your app. In this case, when you open url with your app, new instance of app is not launched
+and arguments are passed to already running instance. Check single instance lock guide for details. Example:
+
+```go title="main.go"
+func main() {
+	// Create application with options
+	err := wails.Run(&options.App{
+		Title:  "wails-open-file",
+		Width:  1024,
+		Height: 768,
+		AssetServer: &assetserver.Options{
+			Assets: assets,
+		},
+		BackgroundColour: &options.RGBA{R: 27, G: 38, B: 54, A: 1},
+		SingleInstanceLock: &options.SingleInstanceLock{
+			UniqueId:               "e3984e08-28dc-4e3d-b70a-45e961589cdc",
+			OnSecondInstanceLaunch: app.onSecondInstanceLaunch,
+		},
+		Bind: []interface{}{
+			app,
+		},
+	})
+}
+```
+
+### Linux
+
+Currently, Wails doesn't support bundling for Linux. So, you need to create file associations manually.
+For example if you distribute your app as a .deb package, you can create file associations by adding required files in you bundle.
+You can use [nfpm](https://nfpm.goreleaser.com/) to create .deb package for your app.
+
+1.  Create a .desktop file for your app and specify file associations there (note that `%u` is important in Exec). Example:
+
+```ini
+[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;
+```
+
+2.  Prepare postInstall/postRemove scripts for your package. Example:
+
+```sh
+# reload desktop database to load app in list of available
+update-desktop-database /usr/share/applications
+```
+
+3.  Configure nfpm to use your scripts and files. Example:
+
+```yaml
+name: "wails-open-file"
+arch: "arm64"
+platform: "linux"
+version: "1.0.0"
+section: "default"
+priority: "extra"
+maintainer: "FooBarCorp <FooBarCorp@gmail.com>"
+description: "Sample Package"
+vendor: "FooBarCorp"
+homepage: "http://example.com"
+license: "MIT"
+contents:
+- src: ../bin/wails-open-file
+  dst: /usr/bin/wails-open-file
+- src: ./main.desktop
+  dst: /usr/share/applications/wails-open-file.desktop
+- src: ../appicon.svg
+  dst: /usr/share/icons/hicolor/scalable/apps/wails-open-file.svg
+# copy icons to Yaru theme as well. For some reason Ubuntu didn't pick up fileicons from hicolor theme
+- src: ../appicon.svg
+  dst: /usr/share/icons/Yaru/scalable/apps/wails-open-file.svg
+scripts:
+  postinstall: ./postInstall.sh
+  postremove: ./postRemove.sh
+```
+
+6.  Build your .deb package using nfpm:
+
+```sh
+nfpm pkg --packager deb --target .
+```
+
+7.  Now when your package is installed, your app will be associated with custom protocol scheme. When you open url with your app,
+    new instance of app is launched and file path is passed as argument to your app.
+    To handle this you should parse command line arguments in your app. Example:
+
+```go title="main.go"
+func main() {
+	argsWithoutProg := os.Args[1:]
+
+	if len(argsWithoutProg) != 0 {
+    println("launchArgs", argsWithoutProg)
+  }
+}
+```
+
+You also can enable single instance lock for your app. In this case, when you open url with your app, new instance of app is not launched
+and arguments are passed to already running instance. Check single instance lock guide for details. Example:
+
+```go title="main.go"
+func main() {
+	// Create application with options
+	err := wails.Run(&options.App{
+		Title:  "wails-open-file",
+		Width:  1024,
+		Height: 768,
+		AssetServer: &assetserver.Options{
+			Assets: assets,
+		},
+		BackgroundColour: &options.RGBA{R: 27, G: 38, B: 54, A: 1},
+		SingleInstanceLock: &options.SingleInstanceLock{
+			UniqueId:               "e3984e08-28dc-4e3d-b70a-45e961589cdc",
+			OnSecondInstanceLaunch: app.onSecondInstanceLaunch,
+		},
+		Bind: []interface{}{
+			app,
+		},
+	})
+}
+```

website/i18n/fr/docusaurus-plugin-content-docs/current/guides/file-association.mdx

@@ -89,6 +89,31 @@ func main() {
 }
 ```
 
+You also can enable single instance lock for your app. In this case, when you open file with your app, new instance of app is not launched
+and arguments are passed to already running instance. Check single instance lock guide for details. Example:
+
+```go title="main.go"
+func main() {
+	// Create application with options
+	err := wails.Run(&options.App{
+		Title:  "wails-open-file",
+		Width:  1024,
+		Height: 768,
+		AssetServer: &assetserver.Options{
+			Assets: assets,
+		},
+		BackgroundColour: &options.RGBA{R: 27, G: 38, B: 54, A: 1},
+		SingleInstanceLock: &options.SingleInstanceLock{
+			UniqueId:               "e3984e08-28dc-4e3d-b70a-45e961589cdc",
+			OnSecondInstanceLaunch: app.onSecondInstanceLaunch,
+		},
+		Bind: []interface{}{
+			app,
+		},
+	})
+}
+```
+
 ### Linux
 
 Currently, Wails doesn't support bundling for Linux. So, you need to create file associations manually.
@@ -193,7 +218,27 @@ func main() {
 }
 ```
 
-## Limitations:
+You also can enable single instance lock for your app. In this case, when you open file with your app, new instance of app is not launched
+and arguments are passed to already running instance. Check single instance lock guide for details. Example:
 
-On Windows and Linux when associated file is opened, new instance of your app is launched.
+```go title="main.go"
-Currently, Wails doesn't support opening files in already running app. There is plugin for single instance support for v3 in development.
+func main() {
+	// Create application with options
+	err := wails.Run(&options.App{
+		Title:  "wails-open-file",
+		Width:  1024,
+		Height: 768,
+		AssetServer: &assetserver.Options{
+			Assets: assets,
+		},
+		BackgroundColour: &options.RGBA{R: 27, G: 38, B: 54, A: 1},
+		SingleInstanceLock: &options.SingleInstanceLock{
+			UniqueId:               "e3984e08-28dc-4e3d-b70a-45e961589cdc",
+			OnSecondInstanceLaunch: app.onSecondInstanceLaunch,
+		},
+		Bind: []interface{}{
+			app,
+		},
+	})
+}
+```

website/i18n/fr/docusaurus-plugin-content-docs/current/guides/single-instance-lock.mdx

@@ -0,0 +1,81 @@
+# Single Instance Lock
+
+Single instance lock is a mechanism that allows you to prevent multiple instances of your app from running at the same time.
+It is useful for apps that are designed to open files from the command line or from the OS file explorer.
+
+## Important
+
+Single Instance Lock does not implement a secure communications protocol between instances. When using single instance lock,
+your app should treat any data passed to it from second instance callback as untrusted.
+You should verify that args that you receive are valid and don't contain any malicious data.
+
+## How it works
+
+Windows: Single instance lock is implemented using a named mutex. The mutex name is generated from the unique id that you provide. Data is passed to the first instance via a shared window using [SendMessage](https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-sendmessage)
+macOS: Single instance lock is implemented using a named mutex. The mutex name is generated from the unique id that you provide. Data is passed to the first instance via [NSDistributedNotificationCenter](https://developer.apple.com/documentation/foundation/nsdistributednotificationcenter)
+Linux: Single instance lock is implemented using [dbus](https://www.freedesktop.org/wiki/Software/dbus/). The dbus name is generated from the unique id that you provide. Data is passed to the first instance via [dbus](https://www.freedesktop.org/wiki/Software/dbus/)
+
+## Usage
+
+When creating your app, you can enable single instance lock by passing a `SingleInstanceLock` struct to the `App` struct.
+Use the `UniqueId` field to specify a unique id for your app.
+This id is used to generate the mutex name on Windows and macOS and the dbus name on Linux. Use a UUID to ensure that the id is unique.
+The `OnSecondInstanceLaunch` field is used to specify a callback that is called when a second instance of your app is launched.
+The callback receives a `SecondInstanceData` struct that contains the command line arguments passed to the second instance and the working directory of the second instance.
+
+Note that OnSecondInstanceLaunch don't trigger windows focus.
+You need to call `runtime.WindowUnminimise` and `runtime.Show` to bring your app to the front.
+Note that on linux systems window managers may prevent your app from being brought to the front to avoid stealing focus.
+
+```go title="main.go"
+var wailsContext *context.Context
+
+// NewApp creates a new App application struct
+func NewApp() *App {
+	return &App{}
+}
+
+// startup is called when the app starts. The context is saved
+// so we can call the runtime methods
+func (a *App) startup(ctx context.Context) {
+	wailsContext = &ctx
+}
+
+func (a *App) onSecondInstanceLaunch(secondInstanceData options.SecondInstanceData) {
+	secondInstanceArgs = secondInstanceData.Args
+
+	println("user opened second instance", strings.Join(secondInstanceData.Args, ","))
+	println("user opened second from", secondInstanceData.WorkingDirectory)
+	runtime.WindowUnminimise(*wailsContext)
+	runtime.Show(*wailsContext)
+	go runtime.EventsEmit(*wailsContext, "launchArgs", secondInstanceArgs)
+}
+
+func main() {
+	// Create an instance of the app structure
+	app := NewApp()
+
+	// Create application with options
+	err := wails.Run(&options.App{
+		Title:  "wails-open-file",
+		Width:  1024,
+		Height: 768,
+		AssetServer: &assetserver.Options{
+			Assets: assets,
+		},
+		BackgroundColour: &options.RGBA{R: 27, G: 38, B: 54, A: 1},
+		OnStartup:        app.startup,
+		SingleInstanceLock: &options.SingleInstanceLock{
+			UniqueId:               "e3984e08-28dc-4e3d-b70a-45e961589cdc",
+			OnSecondInstanceLaunch: app.onSecondInstanceLaunch,
+		},
+		Bind: []interface{}{
+			app,
+		},
+	})
+
+	if err != nil {
+		println("Error:", err.Error())
+	}
+}
+```

website/i18n/fr/docusaurus-plugin-content-docs/current/introduction.mdx

@@ -42,7 +42,7 @@ Wails est livré avec un certain nombre de modèles préconfigurés qui vous per
 
 Wails utilise une bibliothèque conçue pour gérer les éléments natifs tels que les fenêtres, menus, boîtes de dialogues, etc, pour que vous puissiez construire des applications de bureau riches en fonctionnalités.
 
-**Il n'embarque pas de navigateur**, il est donc efficace sur les ressources. Au lieu de cela, il utilise le moteur de rendu natif de la plate-forme. Sous Windows, c'est la nouvelle bibliothèque Microsoft Webview2, construite sur Chromium.
+**It does not embed a browser**, so it delivers a small runtime. Instead, it reuses the native rendering engine for the platform. Sous Windows, c'est la nouvelle bibliothèque Microsoft Webview2, construite sur Chromium.
 
 ### Interopérabilité Go & Javascript
 

website/i18n/fr/docusaurus-plugin-content-pages/changelog.mdx

@@ -15,6 +15,8 @@ Le format est basé sur [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
 
 ### Ajouts
 
+- Update the description of `ZoomFactor` and `IsZoomControlEnabled` attributes in the document. Added by @biuaxia in [PR](https://github.com/wailsapp/wails/pull/3013)
+- Added Single Instance Lock support with passing arguments to first instance. Added by @APshenkin in [PR](https://github.com/wailsapp/wails/pull/2951)
 - Added support for enabling/disabling swipe gestures for Windows WebView2. Added by @leaanthony in [PR](https://github.com/wailsapp/wails/pull/2878)
 - When building with `-devtools` flag, CMD/CTRL+SHIFT+F12 can be used to open the devtools. Added by @leaanthony in [PR](https://github.com/wailsapp/wails/pull/2915) – Added file association support for macOS and Windows. Added by @APshenkin in [PR](https://github.com/wailsapp/wails/pull/2918)
 - Added support for setting some of the Webview preferences, `textInteractionEnabled` and `tabFocusesLinks` on Mac. Added by @fkhadra in [PR](https://github.com/wailsapp/wails/pull/2937)
@@ -23,6 +25,8 @@ Le format est basé sur [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
 - New task created for linting v2 `task v2:lint`. Workflow updated to run the task. Added by @mikeee in [PR](https://github.com/wailsapp/wails/pull/2957)
 - Added new community template wails-htmx-templ-chi-tailwind. Added by [@pylotlight](https://github.com/pylotlight) in [PR](https://github.com/wailsapp/wails/pull/2984)
 - Added CPU/GPU/Memory detection for `wails doctor`. Added by @leaanthony in #d51268b8d0680430f3a614775b13e6cd2b906d1c
+- The [AssetServer](/docs/reference/options#assetserver) now injects the runtime/IPC into all index html files and into all html files returned when requesting a folder path. Added by @stffabi in [PR](https://github.com/wailsapp/wails/pull/2203)
+- Added Custom Protocol Schemes associations support for macOS and Windows. Added by @APshenkin in [PR](https://github.com/wailsapp/wails/pull/3000)
 
 ### Changements
 
@@ -30,10 +34,12 @@ Le format est basé sur [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
 - AssetServer requests are now processed concurrently by spawning a goroutine per request. Changed by @stffabi in [PR](https://github.com/wailsapp/wails/pull/2926)
 - Now building with `-devtools` flag doesn't enable the default context-menu. Changed by @mmghv in [PR](https://github.com/wailsapp/wails/pull/2923)
 - Change Window Level. Changed by @almas1992 in [PR](https://github.com/wailsapp/wails/pull/2944)
+
 #### Corrections
 
 - Fixed typo on docs/reference/options page. Added by [@pylotlight](https://github.com/pylotlight) in [PR](https://github.com/wailsapp/wails/pull/2887)
 - Fixed issue with npm being called npm20 on openSUSE-Tumbleweed. Fixed by @TuffenDuffen in [PR] in (https://github.com/wailsapp/wails/pull/2941)
+- Fixed memory corruption on Windows when using accelerator keys. Fixed by @stffabi in [PR] in (https://github.com/wailsapp/wails/pull/3002)
 
 ## v2.6.0 - 2023-09-06
 

website/i18n/fr/docusaurus-plugin-content-pages/credits.mdx

@@ -2,9 +2,9 @@
 
 - [Lea Anthony](https://github.com/leaanthony) - Propriétaire du projet, développeur principal
 - [Stffabi](https://github.com/stffabi) - Chef technique, développeur et mainteneur
-- [Misite Bao](https://github.com/misitebao) - Sorcier de la documentation, traducteur chinois, testeur pour Windows, découvreur principal de bugs
 - [Travis McLane](https://github.com/tmclane) - Travaux de compilation sur plusieurs plateformes, testeur MacOS
 - [Lyimmi](https://github.com/Lyimmi) - Tout ce qui est Linux
+- [Simon Thomas](mailto:enquiries@wails.io) - Growth Hacker
 
 ## Partenaires
 <img src="/img/sponsors.svg" style={{"width":"85%","max-width":"800px;"}} />

website/i18n/ja/docusaurus-plugin-content-docs/current/guides/custom-protocol-schemes.mdx

@@ -0,0 +1,204 @@
+# Custom Protocol Scheme association
+
+Custom Protocols feature allows you to associate specific custom protocol with your app so that when users open links with this protocol,
+your app is launched to handle them. This can be particularly useful to connect your desktop app with your web app.
+In this guide, we'll walk through the steps to implement custom protocols in Wails app.
+
+## Set Up Custom Protocol Schemes Association:
+
+To set up custom protocol, you need to modify your application's wails.json file.
+In "info" section add a "protocols" section specifying the protocols your app should be associated with.
+
+For example:
+
+```json
+{
+  "info": {
+    "protocols": [
+      {
+        "scheme": "myapp",
+        "description": "My App Protocol",
+        "role": "Editor"
+      }
+    ]
+  }
+}
+```
+
+| Property    | Description                                                                           |
+| :---------- | :------------------------------------------------------------------------------------ |
+| scheme      | Custom Protocol scheme. e.g. myapp                                                    |
+| description | Windows-only. The description.                                                        |
+| role        | macOS-only. The app’s role with respect to the type. Corresponds to CFBundleTypeRole. |
+
+## Platform Specifics:
+
+### macOS
+
+When you open custom protocol with your app, the system will launch your app and call the `OnUrlOpen` function in your Wails app. Example:
+
+```go title="main.go"
+func main() {
+	// Create application with options
+	err := wails.Run(&options.App{
+		Title:  "wails-open-file",
+		Width:  1024,
+		Height: 768,
+		AssetServer: &assetserver.Options{
+			Assets: assets,
+		},
+		BackgroundColour: &options.RGBA{R: 27, G: 38, B: 54, A: 1},
+		Mac: &mac.Options{
+			OnUrlOpen: func(url string) { println(url) },
+		},
+		Bind: []interface{}{
+			app,
+		},
+	})
+
+	if err != nil {
+		println("Error:", err.Error())
+	}
+}
+```
+
+### Windows
+
+On Windows Custom Protocol Schemes is supported only with NSIS installer. During installation, the installer will create a
+registry entry for your schemes. When you open url with your app, new instance of app is launched and url is passed
+as argument to your app. To handle this you should parse command line arguments in your app. Example:
+
+```go title="main.go"
+func main() {
+	argsWithoutProg := os.Args[1:]
+
+	if len(argsWithoutProg) != 0 {
+    println("launchArgs", argsWithoutProg)
+  }
+}
+```
+
+You also can enable single instance lock for your app. In this case, when you open url with your app, new instance of app is not launched
+and arguments are passed to already running instance. Check single instance lock guide for details. Example:
+
+```go title="main.go"
+func main() {
+	// Create application with options
+	err := wails.Run(&options.App{
+		Title:  "wails-open-file",
+		Width:  1024,
+		Height: 768,
+		AssetServer: &assetserver.Options{
+			Assets: assets,
+		},
+		BackgroundColour: &options.RGBA{R: 27, G: 38, B: 54, A: 1},
+		SingleInstanceLock: &options.SingleInstanceLock{
+			UniqueId:               "e3984e08-28dc-4e3d-b70a-45e961589cdc",
+			OnSecondInstanceLaunch: app.onSecondInstanceLaunch,
+		},
+		Bind: []interface{}{
+			app,
+		},
+	})
+}
+```
+
+### Linux
+
+Currently, Wails doesn't support bundling for Linux. So, you need to create file associations manually.
+For example if you distribute your app as a .deb package, you can create file associations by adding required files in you bundle.
+You can use [nfpm](https://nfpm.goreleaser.com/) to create .deb package for your app.
+
+1.  Create a .desktop file for your app and specify file associations there (note that `%u` is important in Exec). Example:
+
+```ini
+[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;
+```
+
+2.  Prepare postInstall/postRemove scripts for your package. Example:
+
+```sh
+# reload desktop database to load app in list of available
+update-desktop-database /usr/share/applications
+```
+
+3.  Configure nfpm to use your scripts and files. Example:
+
+```yaml
+name: "wails-open-file"
+arch: "arm64"
+platform: "linux"
+version: "1.0.0"
+section: "default"
+priority: "extra"
+maintainer: "FooBarCorp <FooBarCorp@gmail.com>"
+description: "Sample Package"
+vendor: "FooBarCorp"
+homepage: "http://example.com"
+license: "MIT"
+contents:
+- src: ../bin/wails-open-file
+  dst: /usr/bin/wails-open-file
+- src: ./main.desktop
+  dst: /usr/share/applications/wails-open-file.desktop
+- src: ../appicon.svg
+  dst: /usr/share/icons/hicolor/scalable/apps/wails-open-file.svg
+# copy icons to Yaru theme as well. For some reason Ubuntu didn't pick up fileicons from hicolor theme
+- src: ../appicon.svg
+  dst: /usr/share/icons/Yaru/scalable/apps/wails-open-file.svg
+scripts:
+  postinstall: ./postInstall.sh
+  postremove: ./postRemove.sh
+```
+
+6.  Build your .deb package using nfpm:
+
+```sh
+nfpm pkg --packager deb --target .
+```
+
+7.  Now when your package is installed, your app will be associated with custom protocol scheme. When you open url with your app,
+    new instance of app is launched and file path is passed as argument to your app.
+    To handle this you should parse command line arguments in your app. Example:
+
+```go title="main.go"
+func main() {
+	argsWithoutProg := os.Args[1:]
+
+	if len(argsWithoutProg) != 0 {
+    println("launchArgs", argsWithoutProg)
+  }
+}
+```
+
+You also can enable single instance lock for your app. In this case, when you open url with your app, new instance of app is not launched
+and arguments are passed to already running instance. Check single instance lock guide for details. Example:
+
+```go title="main.go"
+func main() {
+	// Create application with options
+	err := wails.Run(&options.App{
+		Title:  "wails-open-file",
+		Width:  1024,
+		Height: 768,
+		AssetServer: &assetserver.Options{
+			Assets: assets,
+		},
+		BackgroundColour: &options.RGBA{R: 27, G: 38, B: 54, A: 1},
+		SingleInstanceLock: &options.SingleInstanceLock{
+			UniqueId:               "e3984e08-28dc-4e3d-b70a-45e961589cdc",
+			OnSecondInstanceLaunch: app.onSecondInstanceLaunch,
+		},
+		Bind: []interface{}{
+			app,
+		},
+	})
+}
+```

website/i18n/ja/docusaurus-plugin-content-docs/current/guides/file-association.mdx

@@ -89,6 +89,31 @@ func main() {
 }
 ```
 
+You also can enable single instance lock for your app. In this case, when you open file with your app, new instance of app is not launched
+and arguments are passed to already running instance. Check single instance lock guide for details. Example:
+
+```go title="main.go"
+func main() {
+	// Create application with options
+	err := wails.Run(&options.App{
+		Title:  "wails-open-file",
+		Width:  1024,
+		Height: 768,
+		AssetServer: &assetserver.Options{
+			Assets: assets,
+		},
+		BackgroundColour: &options.RGBA{R: 27, G: 38, B: 54, A: 1},
+		SingleInstanceLock: &options.SingleInstanceLock{
+			UniqueId:               "e3984e08-28dc-4e3d-b70a-45e961589cdc",
+			OnSecondInstanceLaunch: app.onSecondInstanceLaunch,
+		},
+		Bind: []interface{}{
+			app,
+		},
+	})
+}
+```
+
 ### Linux
 
 Currently, Wails doesn't support bundling for Linux. So, you need to create file associations manually.
@@ -193,7 +218,27 @@ func main() {
 }
 ```
 
-## Limitations:
+You also can enable single instance lock for your app. In this case, when you open file with your app, new instance of app is not launched
+and arguments are passed to already running instance. Check single instance lock guide for details. Example:
 
-On Windows and Linux when associated file is opened, new instance of your app is launched.
+```go title="main.go"
-Currently, Wails doesn't support opening files in already running app. There is plugin for single instance support for v3 in development.
+func main() {
+	// Create application with options
+	err := wails.Run(&options.App{
+		Title:  "wails-open-file",
+		Width:  1024,
+		Height: 768,
+		AssetServer: &assetserver.Options{
+			Assets: assets,
+		},
+		BackgroundColour: &options.RGBA{R: 27, G: 38, B: 54, A: 1},
+		SingleInstanceLock: &options.SingleInstanceLock{
+			UniqueId:               "e3984e08-28dc-4e3d-b70a-45e961589cdc",
+			OnSecondInstanceLaunch: app.onSecondInstanceLaunch,
+		},
+		Bind: []interface{}{
+			app,
+		},
+	})
+}
+```

website/i18n/ja/docusaurus-plugin-content-docs/current/guides/single-instance-lock.mdx

@@ -0,0 +1,81 @@
+# Single Instance Lock
+
+Single instance lock is a mechanism that allows you to prevent multiple instances of your app from running at the same time.
+It is useful for apps that are designed to open files from the command line or from the OS file explorer.
+
+## Important
+
+Single Instance Lock does not implement a secure communications protocol between instances. When using single instance lock,
+your app should treat any data passed to it from second instance callback as untrusted.
+You should verify that args that you receive are valid and don't contain any malicious data.
+
+## How it works
+
+Windows: Single instance lock is implemented using a named mutex. The mutex name is generated from the unique id that you provide. Data is passed to the first instance via a shared window using [SendMessage](https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-sendmessage)
+macOS: Single instance lock is implemented using a named mutex. The mutex name is generated from the unique id that you provide. Data is passed to the first instance via [NSDistributedNotificationCenter](https://developer.apple.com/documentation/foundation/nsdistributednotificationcenter)
+Linux: Single instance lock is implemented using [dbus](https://www.freedesktop.org/wiki/Software/dbus/). The dbus name is generated from the unique id that you provide. Data is passed to the first instance via [dbus](https://www.freedesktop.org/wiki/Software/dbus/)
+
+## Usage
+
+When creating your app, you can enable single instance lock by passing a `SingleInstanceLock` struct to the `App` struct.
+Use the `UniqueId` field to specify a unique id for your app.
+This id is used to generate the mutex name on Windows and macOS and the dbus name on Linux. Use a UUID to ensure that the id is unique.
+The `OnSecondInstanceLaunch` field is used to specify a callback that is called when a second instance of your app is launched.
+The callback receives a `SecondInstanceData` struct that contains the command line arguments passed to the second instance and the working directory of the second instance.
+
+Note that OnSecondInstanceLaunch don't trigger windows focus.
+You need to call `runtime.WindowUnminimise` and `runtime.Show` to bring your app to the front.
+Note that on linux systems window managers may prevent your app from being brought to the front to avoid stealing focus.
+
+```go title="main.go"
+var wailsContext *context.Context
+
+// NewApp creates a new App application struct
+func NewApp() *App {
+	return &App{}
+}
+
+// startup is called when the app starts. The context is saved
+// so we can call the runtime methods
+func (a *App) startup(ctx context.Context) {
+	wailsContext = &ctx
+}
+
+func (a *App) onSecondInstanceLaunch(secondInstanceData options.SecondInstanceData) {
+	secondInstanceArgs = secondInstanceData.Args
+
+	println("user opened second instance", strings.Join(secondInstanceData.Args, ","))
+	println("user opened second from", secondInstanceData.WorkingDirectory)
+	runtime.WindowUnminimise(*wailsContext)
+	runtime.Show(*wailsContext)
+	go runtime.EventsEmit(*wailsContext, "launchArgs", secondInstanceArgs)
+}
+
+func main() {
+	// Create an instance of the app structure
+	app := NewApp()
+
+	// Create application with options
+	err := wails.Run(&options.App{
+		Title:  "wails-open-file",
+		Width:  1024,
+		Height: 768,
+		AssetServer: &assetserver.Options{
+			Assets: assets,
+		},
+		BackgroundColour: &options.RGBA{R: 27, G: 38, B: 54, A: 1},
+		OnStartup:        app.startup,
+		SingleInstanceLock: &options.SingleInstanceLock{
+			UniqueId:               "e3984e08-28dc-4e3d-b70a-45e961589cdc",
+			OnSecondInstanceLaunch: app.onSecondInstanceLaunch,
+		},
+		Bind: []interface{}{
+			app,
+		},
+	})
+
+	if err != nil {
+		println("Error:", err.Error())
+	}
+}
+```

website/i18n/ja/docusaurus-plugin-content-docs/current/introduction.mdx

@@ -42,7 +42,7 @@ Wailsには、アプリの開発をすばやく始められるように、多数
 
 Wailsは、ウィンドウ、メニュー、ダイアログなどのネイティブ要素を処理する専用ライブラリを使用するため、見栄えが良く、リッチな機能を備えたデスクトップアプリを構築できます。
 
-**ブラウザを埋め込まないため**、無駄なリソースを割きません。 ブラウザを埋め込まない代わりに、OSプラットフォームのネイティブなレンダリングエンジンを使用します。 例えばWindowsの場合、Chromium上でビルトされているMicrosoft Webview2ライブラリを使用します。
+**It does not embed a browser**, so it delivers a small runtime. Instead, it reuses the native rendering engine for the platform. 例えばWindowsの場合、Chromium上でビルトされているMicrosoft Webview2ライブラリを使用します。
 
 ### GoとJavascriptのやり取り
 

website/i18n/ja/docusaurus-plugin-content-pages/changelog.mdx

@@ -15,6 +15,8 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 
 ### Added
 
+- Update the description of `ZoomFactor` and `IsZoomControlEnabled` attributes in the document. Added by @biuaxia in [PR](https://github.com/wailsapp/wails/pull/3013)
+- Added Single Instance Lock support with passing arguments to first instance. Added by @APshenkin in [PR](https://github.com/wailsapp/wails/pull/2951)
 - Added support for enabling/disabling swipe gestures for Windows WebView2. Added by @leaanthony in [PR](https://github.com/wailsapp/wails/pull/2878)
 - When building with `-devtools` flag, CMD/CTRL+SHIFT+F12 can be used to open the devtools. Added by @leaanthony in [PR](https://github.com/wailsapp/wails/pull/2915) – Added file association support for macOS and Windows. Added by @APshenkin in [PR](https://github.com/wailsapp/wails/pull/2918)
 - Added support for setting some of the Webview preferences, `textInteractionEnabled` and `tabFocusesLinks` on Mac. Added by @fkhadra in [PR](https://github.com/wailsapp/wails/pull/2937)
@@ -23,6 +25,8 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 - New task created for linting v2 `task v2:lint`. Workflow updated to run the task. Added by @mikeee in [PR](https://github.com/wailsapp/wails/pull/2957)
 - Added new community template wails-htmx-templ-chi-tailwind. Added by [@pylotlight](https://github.com/pylotlight) in [PR](https://github.com/wailsapp/wails/pull/2984)
 - Added CPU/GPU/Memory detection for `wails doctor`. Added by @leaanthony in #d51268b8d0680430f3a614775b13e6cd2b906d1c
+- The [AssetServer](/docs/reference/options#assetserver) now injects the runtime/IPC into all index html files and into all html files returned when requesting a folder path. Added by @stffabi in [PR](https://github.com/wailsapp/wails/pull/2203)
+- Added Custom Protocol Schemes associations support for macOS and Windows. Added by @APshenkin in [PR](https://github.com/wailsapp/wails/pull/3000)
 
 ### Changed
 
@@ -30,10 +34,12 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 - AssetServer requests are now processed concurrently by spawning a goroutine per request. Changed by @stffabi in [PR](https://github.com/wailsapp/wails/pull/2926)
 - Now building with `-devtools` flag doesn't enable the default context-menu. Changed by @mmghv in [PR](https://github.com/wailsapp/wails/pull/2923)
 - Change Window Level. Changed by @almas1992 in [PR](https://github.com/wailsapp/wails/pull/2944)
+
 #### Fixed
 
 - Fixed typo on docs/reference/options page. Added by [@pylotlight](https://github.com/pylotlight) in [PR](https://github.com/wailsapp/wails/pull/2887)
 - Fixed issue with npm being called npm20 on openSUSE-Tumbleweed. Fixed by @TuffenDuffen in [PR] in (https://github.com/wailsapp/wails/pull/2941)
+- Fixed memory corruption on Windows when using accelerator keys. Fixed by @stffabi in [PR] in (https://github.com/wailsapp/wails/pull/3002)
 
 ## v2.6.0 - 2023-09-06
 

website/i18n/ja/docusaurus-plugin-content-pages/credits.mdx

@@ -2,9 +2,9 @@
 
 - [Lea Anthony](https://github.com/leaanthony) - プロジェクトオーナー、開発リーダー
 - [Stffabi](https://github.com/stffabi) - テクニカルリーダー、開発担当、保守担当
-- [Misite Bao](https://github.com/misitebao) - ドキュメント専門担当、翻訳担当(中国語)、Windowsテスター、不具合収集担当
 - [Travis McLane](https://github.com/tmclane) - クロスコンパイル担当、MacOSテスター
 - [Lyimmi](https://github.com/Lyimmi) - Linux関連全般
+- [Simon Thomas](mailto:enquiries@wails.io) - Growth Hacker
 
 ## スポンサー
 <img src="/img/sponsors.svg" style={{"width":"85%","max-width":"800px;"}} />

website/i18n/ko/docusaurus-plugin-content-docs/current/guides/custom-protocol-schemes.mdx

@@ -0,0 +1,204 @@
+# Custom Protocol Scheme association
+
+Custom Protocols feature allows you to associate specific custom protocol with your app so that when users open links with this protocol,
+your app is launched to handle them. This can be particularly useful to connect your desktop app with your web app.
+In this guide, we'll walk through the steps to implement custom protocols in Wails app.
+
+## Set Up Custom Protocol Schemes Association:
+
+To set up custom protocol, you need to modify your application's wails.json file.
+In "info" section add a "protocols" section specifying the protocols your app should be associated with.
+
+For example:
+
+```json
+{
+  "info": {
+    "protocols": [
+      {
+        "scheme": "myapp",
+        "description": "My App Protocol",
+        "role": "Editor"
+      }
+    ]
+  }
+}
+```
+
+| Property    | Description                                                                           |
+| :---------- | :------------------------------------------------------------------------------------ |
+| scheme      | Custom Protocol scheme. e.g. myapp                                                    |
+| description | Windows-only. The description.                                                        |
+| role        | macOS-only. The app’s role with respect to the type. Corresponds to CFBundleTypeRole. |
+
+## Platform Specifics:
+
+### macOS
+
+When you open custom protocol with your app, the system will launch your app and call the `OnUrlOpen` function in your Wails app. Example:
+
+```go title="main.go"
+func main() {
+	// Create application with options
+	err := wails.Run(&options.App{
+		Title:  "wails-open-file",
+		Width:  1024,
+		Height: 768,
+		AssetServer: &assetserver.Options{
+			Assets: assets,
+		},
+		BackgroundColour: &options.RGBA{R: 27, G: 38, B: 54, A: 1},
+		Mac: &mac.Options{
+			OnUrlOpen: func(url string) { println(url) },
+		},
+		Bind: []interface{}{
+			app,
+		},
+	})
+
+	if err != nil {
+		println("Error:", err.Error())
+	}
+}
+```
+
+### Windows
+
+On Windows Custom Protocol Schemes is supported only with NSIS installer. During installation, the installer will create a
+registry entry for your schemes. When you open url with your app, new instance of app is launched and url is passed
+as argument to your app. To handle this you should parse command line arguments in your app. Example:
+
+```go title="main.go"
+func main() {
+	argsWithoutProg := os.Args[1:]
+
+	if len(argsWithoutProg) != 0 {
+    println("launchArgs", argsWithoutProg)
+  }
+}
+```
+
+You also can enable single instance lock for your app. In this case, when you open url with your app, new instance of app is not launched
+and arguments are passed to already running instance. Check single instance lock guide for details. Example:
+
+```go title="main.go"
+func main() {
+	// Create application with options
+	err := wails.Run(&options.App{
+		Title:  "wails-open-file",
+		Width:  1024,
+		Height: 768,
+		AssetServer: &assetserver.Options{
+			Assets: assets,
+		},
+		BackgroundColour: &options.RGBA{R: 27, G: 38, B: 54, A: 1},
+		SingleInstanceLock: &options.SingleInstanceLock{
+			UniqueId:               "e3984e08-28dc-4e3d-b70a-45e961589cdc",
+			OnSecondInstanceLaunch: app.onSecondInstanceLaunch,
+		},
+		Bind: []interface{}{
+			app,
+		},
+	})
+}
+```
+
+### Linux
+
+Currently, Wails doesn't support bundling for Linux. So, you need to create file associations manually.
+For example if you distribute your app as a .deb package, you can create file associations by adding required files in you bundle.
+You can use [nfpm](https://nfpm.goreleaser.com/) to create .deb package for your app.
+
+1.  Create a .desktop file for your app and specify file associations there (note that `%u` is important in Exec). Example:
+
+```ini
+[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;
+```
+
+2.  Prepare postInstall/postRemove scripts for your package. Example:
+
+```sh
+# reload desktop database to load app in list of available
+update-desktop-database /usr/share/applications
+```
+
+3.  Configure nfpm to use your scripts and files. Example:
+
+```yaml
+name: "wails-open-file"
+arch: "arm64"
+platform: "linux"
+version: "1.0.0"
+section: "default"
+priority: "extra"
+maintainer: "FooBarCorp <FooBarCorp@gmail.com>"
+description: "Sample Package"
+vendor: "FooBarCorp"
+homepage: "http://example.com"
+license: "MIT"
+contents:
+- src: ../bin/wails-open-file
+  dst: /usr/bin/wails-open-file
+- src: ./main.desktop
+  dst: /usr/share/applications/wails-open-file.desktop
+- src: ../appicon.svg
+  dst: /usr/share/icons/hicolor/scalable/apps/wails-open-file.svg
+# copy icons to Yaru theme as well. For some reason Ubuntu didn't pick up fileicons from hicolor theme
+- src: ../appicon.svg
+  dst: /usr/share/icons/Yaru/scalable/apps/wails-open-file.svg
+scripts:
+  postinstall: ./postInstall.sh
+  postremove: ./postRemove.sh
+```
+
+6.  Build your .deb package using nfpm:
+
+```sh
+nfpm pkg --packager deb --target .
+```
+
+7.  Now when your package is installed, your app will be associated with custom protocol scheme. When you open url with your app,
+    new instance of app is launched and file path is passed as argument to your app.
+    To handle this you should parse command line arguments in your app. Example:
+
+```go title="main.go"
+func main() {
+	argsWithoutProg := os.Args[1:]
+
+	if len(argsWithoutProg) != 0 {
+    println("launchArgs", argsWithoutProg)
+  }
+}
+```
+
+You also can enable single instance lock for your app. In this case, when you open url with your app, new instance of app is not launched
+and arguments are passed to already running instance. Check single instance lock guide for details. Example:
+
+```go title="main.go"
+func main() {
+	// Create application with options
+	err := wails.Run(&options.App{
+		Title:  "wails-open-file",
+		Width:  1024,
+		Height: 768,
+		AssetServer: &assetserver.Options{
+			Assets: assets,
+		},
+		BackgroundColour: &options.RGBA{R: 27, G: 38, B: 54, A: 1},
+		SingleInstanceLock: &options.SingleInstanceLock{
+			UniqueId:               "e3984e08-28dc-4e3d-b70a-45e961589cdc",
+			OnSecondInstanceLaunch: app.onSecondInstanceLaunch,
+		},
+		Bind: []interface{}{
+			app,
+		},
+	})
+}
+```

website/i18n/ko/docusaurus-plugin-content-docs/current/guides/file-association.mdx

@@ -89,6 +89,31 @@ func main() {
 }
 ```
 
+You also can enable single instance lock for your app. In this case, when you open file with your app, new instance of app is not launched
+and arguments are passed to already running instance. Check single instance lock guide for details. Example:
+
+```go title="main.go"
+func main() {
+	// Create application with options
+	err := wails.Run(&options.App{
+		Title:  "wails-open-file",
+		Width:  1024,
+		Height: 768,
+		AssetServer: &assetserver.Options{
+			Assets: assets,
+		},
+		BackgroundColour: &options.RGBA{R: 27, G: 38, B: 54, A: 1},
+		SingleInstanceLock: &options.SingleInstanceLock{
+			UniqueId:               "e3984e08-28dc-4e3d-b70a-45e961589cdc",
+			OnSecondInstanceLaunch: app.onSecondInstanceLaunch,
+		},
+		Bind: []interface{}{
+			app,
+		},
+	})
+}
+```
+
 ### Linux
 
 Currently, Wails doesn't support bundling for Linux. So, you need to create file associations manually.
@@ -193,7 +218,27 @@ func main() {
 }
 ```
 
-## Limitations:
+You also can enable single instance lock for your app. In this case, when you open file with your app, new instance of app is not launched
+and arguments are passed to already running instance. Check single instance lock guide for details. Example:
 
-On Windows and Linux when associated file is opened, new instance of your app is launched.
+```go title="main.go"
-Currently, Wails doesn't support opening files in already running app. There is plugin for single instance support for v3 in development.
+func main() {
+	// Create application with options
+	err := wails.Run(&options.App{
+		Title:  "wails-open-file",
+		Width:  1024,
+		Height: 768,
+		AssetServer: &assetserver.Options{
+			Assets: assets,
+		},
+		BackgroundColour: &options.RGBA{R: 27, G: 38, B: 54, A: 1},
+		SingleInstanceLock: &options.SingleInstanceLock{
+			UniqueId:               "e3984e08-28dc-4e3d-b70a-45e961589cdc",
+			OnSecondInstanceLaunch: app.onSecondInstanceLaunch,
+		},
+		Bind: []interface{}{
+			app,
+		},
+	})
+}
+```

website/i18n/ko/docusaurus-plugin-content-docs/current/guides/single-instance-lock.mdx

@@ -0,0 +1,81 @@
+# Single Instance Lock
+
+Single instance lock is a mechanism that allows you to prevent multiple instances of your app from running at the same time.
+It is useful for apps that are designed to open files from the command line or from the OS file explorer.
+
+## Important
+
+Single Instance Lock does not implement a secure communications protocol between instances. When using single instance lock,
+your app should treat any data passed to it from second instance callback as untrusted.
+You should verify that args that you receive are valid and don't contain any malicious data.
+
+## How it works
+
+Windows: Single instance lock is implemented using a named mutex. The mutex name is generated from the unique id that you provide. Data is passed to the first instance via a shared window using [SendMessage](https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-sendmessage)
+macOS: Single instance lock is implemented using a named mutex. The mutex name is generated from the unique id that you provide. Data is passed to the first instance via [NSDistributedNotificationCenter](https://developer.apple.com/documentation/foundation/nsdistributednotificationcenter)
+Linux: Single instance lock is implemented using [dbus](https://www.freedesktop.org/wiki/Software/dbus/). The dbus name is generated from the unique id that you provide. Data is passed to the first instance via [dbus](https://www.freedesktop.org/wiki/Software/dbus/)
+
+## Usage
+
+When creating your app, you can enable single instance lock by passing a `SingleInstanceLock` struct to the `App` struct.
+Use the `UniqueId` field to specify a unique id for your app.
+This id is used to generate the mutex name on Windows and macOS and the dbus name on Linux. Use a UUID to ensure that the id is unique.
+The `OnSecondInstanceLaunch` field is used to specify a callback that is called when a second instance of your app is launched.
+The callback receives a `SecondInstanceData` struct that contains the command line arguments passed to the second instance and the working directory of the second instance.
+
+Note that OnSecondInstanceLaunch don't trigger windows focus.
+You need to call `runtime.WindowUnminimise` and `runtime.Show` to bring your app to the front.
+Note that on linux systems window managers may prevent your app from being brought to the front to avoid stealing focus.
+
+```go title="main.go"
+var wailsContext *context.Context
+
+// NewApp creates a new App application struct
+func NewApp() *App {
+	return &App{}
+}
+
+// startup is called when the app starts. The context is saved
+// so we can call the runtime methods
+func (a *App) startup(ctx context.Context) {
+	wailsContext = &ctx
+}
+
+func (a *App) onSecondInstanceLaunch(secondInstanceData options.SecondInstanceData) {
+	secondInstanceArgs = secondInstanceData.Args
+
+	println("user opened second instance", strings.Join(secondInstanceData.Args, ","))
+	println("user opened second from", secondInstanceData.WorkingDirectory)
+	runtime.WindowUnminimise(*wailsContext)
+	runtime.Show(*wailsContext)
+	go runtime.EventsEmit(*wailsContext, "launchArgs", secondInstanceArgs)
+}
+
+func main() {
+	// Create an instance of the app structure
+	app := NewApp()
+
+	// Create application with options
+	err := wails.Run(&options.App{
+		Title:  "wails-open-file",
+		Width:  1024,
+		Height: 768,
+		AssetServer: &assetserver.Options{
+			Assets: assets,
+		},
+		BackgroundColour: &options.RGBA{R: 27, G: 38, B: 54, A: 1},
+		OnStartup:        app.startup,
+		SingleInstanceLock: &options.SingleInstanceLock{
+			UniqueId:               "e3984e08-28dc-4e3d-b70a-45e961589cdc",
+			OnSecondInstanceLaunch: app.onSecondInstanceLaunch,
+		},
+		Bind: []interface{}{
+			app,
+		},
+	})
+
+	if err != nil {
+		println("Error:", err.Error())
+	}
+}
+```

website/i18n/ko/docusaurus-plugin-content-pages/changelog.mdx

@@ -15,6 +15,8 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 
 ### Added
 
+- Update the description of `ZoomFactor` and `IsZoomControlEnabled` attributes in the document. Added by @biuaxia in [PR](https://github.com/wailsapp/wails/pull/3013)
+- Added Single Instance Lock support with passing arguments to first instance. Added by @APshenkin in [PR](https://github.com/wailsapp/wails/pull/2951)
 - Added support for enabling/disabling swipe gestures for Windows WebView2. Added by @leaanthony in [PR](https://github.com/wailsapp/wails/pull/2878)
 - When building with `-devtools` flag, CMD/CTRL+SHIFT+F12 can be used to open the devtools. Added by @leaanthony in [PR](https://github.com/wailsapp/wails/pull/2915) – Added file association support for macOS and Windows. Added by @APshenkin in [PR](https://github.com/wailsapp/wails/pull/2918)
 - Added support for setting some of the Webview preferences, `textInteractionEnabled` and `tabFocusesLinks` on Mac. Added by @fkhadra in [PR](https://github.com/wailsapp/wails/pull/2937)
@@ -23,6 +25,8 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 - New task created for linting v2 `task v2:lint`. Workflow updated to run the task. Added by @mikeee in [PR](https://github.com/wailsapp/wails/pull/2957)
 - Added new community template wails-htmx-templ-chi-tailwind. Added by [@pylotlight](https://github.com/pylotlight) in [PR](https://github.com/wailsapp/wails/pull/2984)
 - Added CPU/GPU/Memory detection for `wails doctor`. Added by @leaanthony in #d51268b8d0680430f3a614775b13e6cd2b906d1c
+- The [AssetServer](/docs/reference/options#assetserver) now injects the runtime/IPC into all index html files and into all html files returned when requesting a folder path. Added by @stffabi in [PR](https://github.com/wailsapp/wails/pull/2203)
+- Added Custom Protocol Schemes associations support for macOS and Windows. Added by @APshenkin in [PR](https://github.com/wailsapp/wails/pull/3000)
 
 ### Changed
 
@@ -30,10 +34,12 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 - AssetServer requests are now processed concurrently by spawning a goroutine per request. Changed by @stffabi in [PR](https://github.com/wailsapp/wails/pull/2926)
 - Now building with `-devtools` flag doesn't enable the default context-menu. Changed by @mmghv in [PR](https://github.com/wailsapp/wails/pull/2923)
 - Change Window Level. Changed by @almas1992 in [PR](https://github.com/wailsapp/wails/pull/2944)
+
 #### Fixed
 
 - Fixed typo on docs/reference/options page. Added by [@pylotlight](https://github.com/pylotlight) in [PR](https://github.com/wailsapp/wails/pull/2887)
 - Fixed issue with npm being called npm20 on openSUSE-Tumbleweed. Fixed by @TuffenDuffen in [PR] in (https://github.com/wailsapp/wails/pull/2941)
+- Fixed memory corruption on Windows when using accelerator keys. Fixed by @stffabi in [PR] in (https://github.com/wailsapp/wails/pull/3002)
 
 ## v2.6.0 - 2023-09-06
 

website/i18n/ko/docusaurus-plugin-content-pages/credits.mdx

@@ -2,9 +2,9 @@
 
 - [Lea Anthony](https://github.com/leaanthony) - Project owner, lead developer
 - [Stffabi](https://github.com/stffabi) - Technical lead, developer and maintainer
-- [Misite Bao](https://github.com/misitebao) - Documentation wizard, Chinese translation, Windows testing, Bug finder general
 - [Travis McLane](https://github.com/tmclane) - Cross-compilation work, MacOS testing
 - [Lyimmi](https://github.com/Lyimmi) - All things Linux
+- [Simon Thomas](mailto:enquiries@wails.io) - Growth Hacker
 
 ## Sponsors
 <img src="/img/sponsors.svg" style={{"width":"85%","max-width":"800px;"}} />

website/i18n/pt/docusaurus-plugin-content-docs/current/guides/custom-protocol-schemes.mdx

@@ -0,0 +1,204 @@
+# Custom Protocol Scheme association
+
+Custom Protocols feature allows you to associate specific custom protocol with your app so that when users open links with this protocol,
+your app is launched to handle them. This can be particularly useful to connect your desktop app with your web app.
+In this guide, we'll walk through the steps to implement custom protocols in Wails app.
+
+## Set Up Custom Protocol Schemes Association:
+
+To set up custom protocol, you need to modify your application's wails.json file.
+In "info" section add a "protocols" section specifying the protocols your app should be associated with.
+
+For example:
+
+```json
+{
+  "info": {
+    "protocols": [
+      {
+        "scheme": "myapp",
+        "description": "My App Protocol",
+        "role": "Editor"
+      }
+    ]
+  }
+}
+```
+
+| Property    | Description                                                                           |
+| :---------- | :------------------------------------------------------------------------------------ |
+| scheme      | Custom Protocol scheme. e.g. myapp                                                    |
+| description | Windows-only. The description.                                                        |
+| role        | macOS-only. The app’s role with respect to the type. Corresponds to CFBundleTypeRole. |
+
+## Platform Specifics:
+
+### macOS
+
+When you open custom protocol with your app, the system will launch your app and call the `OnUrlOpen` function in your Wails app. Example:
+
+```go title="main.go"
+func main() {
+	// Create application with options
+	err := wails.Run(&options.App{
+		Title:  "wails-open-file",
+		Width:  1024,
+		Height: 768,
+		AssetServer: &assetserver.Options{
+			Assets: assets,
+		},
+		BackgroundColour: &options.RGBA{R: 27, G: 38, B: 54, A: 1},
+		Mac: &mac.Options{
+			OnUrlOpen: func(url string) { println(url) },
+		},
+		Bind: []interface{}{
+			app,
+		},
+	})
+
+	if err != nil {
+		println("Error:", err.Error())
+	}
+}
+```
+
+### Windows
+
+On Windows Custom Protocol Schemes is supported only with NSIS installer. During installation, the installer will create a
+registry entry for your schemes. When you open url with your app, new instance of app is launched and url is passed
+as argument to your app. To handle this you should parse command line arguments in your app. Example:
+
+```go title="main.go"
+func main() {
+	argsWithoutProg := os.Args[1:]
+
+	if len(argsWithoutProg) != 0 {
+    println("launchArgs", argsWithoutProg)
+  }
+}
+```
+
+You also can enable single instance lock for your app. In this case, when you open url with your app, new instance of app is not launched
+and arguments are passed to already running instance. Check single instance lock guide for details. Example:
+
+```go title="main.go"
+func main() {
+	// Create application with options
+	err := wails.Run(&options.App{
+		Title:  "wails-open-file",
+		Width:  1024,
+		Height: 768,
+		AssetServer: &assetserver.Options{
+			Assets: assets,
+		},
+		BackgroundColour: &options.RGBA{R: 27, G: 38, B: 54, A: 1},
+		SingleInstanceLock: &options.SingleInstanceLock{
+			UniqueId:               "e3984e08-28dc-4e3d-b70a-45e961589cdc",
+			OnSecondInstanceLaunch: app.onSecondInstanceLaunch,
+		},
+		Bind: []interface{}{
+			app,
+		},
+	})
+}
+```
+
+### Linux
+
+Currently, Wails doesn't support bundling for Linux. So, you need to create file associations manually.
+For example if you distribute your app as a .deb package, you can create file associations by adding required files in you bundle.
+You can use [nfpm](https://nfpm.goreleaser.com/) to create .deb package for your app.
+
+1.  Create a .desktop file for your app and specify file associations there (note that `%u` is important in Exec). Example:
+
+```ini
+[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;
+```
+
+2.  Prepare postInstall/postRemove scripts for your package. Example:
+
+```sh
+# reload desktop database to load app in list of available
+update-desktop-database /usr/share/applications
+```
+
+3.  Configure nfpm to use your scripts and files. Example:
+
+```yaml
+name: "wails-open-file"
+arch: "arm64"
+platform: "linux"
+version: "1.0.0"
+section: "default"
+priority: "extra"
+maintainer: "FooBarCorp <FooBarCorp@gmail.com>"
+description: "Sample Package"
+vendor: "FooBarCorp"
+homepage: "http://example.com"
+license: "MIT"
+contents:
+- src: ../bin/wails-open-file
+  dst: /usr/bin/wails-open-file
+- src: ./main.desktop
+  dst: /usr/share/applications/wails-open-file.desktop
+- src: ../appicon.svg
+  dst: /usr/share/icons/hicolor/scalable/apps/wails-open-file.svg
+# copy icons to Yaru theme as well. For some reason Ubuntu didn't pick up fileicons from hicolor theme
+- src: ../appicon.svg
+  dst: /usr/share/icons/Yaru/scalable/apps/wails-open-file.svg
+scripts:
+  postinstall: ./postInstall.sh
+  postremove: ./postRemove.sh
+```
+
+6.  Build your .deb package using nfpm:
+
+```sh
+nfpm pkg --packager deb --target .
+```
+
+7.  Now when your package is installed, your app will be associated with custom protocol scheme. When you open url with your app,
+    new instance of app is launched and file path is passed as argument to your app.
+    To handle this you should parse command line arguments in your app. Example:
+
+```go title="main.go"
+func main() {
+	argsWithoutProg := os.Args[1:]
+
+	if len(argsWithoutProg) != 0 {
+    println("launchArgs", argsWithoutProg)
+  }
+}
+```
+
+You also can enable single instance lock for your app. In this case, when you open url with your app, new instance of app is not launched
+and arguments are passed to already running instance. Check single instance lock guide for details. Example:
+
+```go title="main.go"
+func main() {
+	// Create application with options
+	err := wails.Run(&options.App{
+		Title:  "wails-open-file",
+		Width:  1024,
+		Height: 768,
+		AssetServer: &assetserver.Options{
+			Assets: assets,
+		},
+		BackgroundColour: &options.RGBA{R: 27, G: 38, B: 54, A: 1},
+		SingleInstanceLock: &options.SingleInstanceLock{
+			UniqueId:               "e3984e08-28dc-4e3d-b70a-45e961589cdc",
+			OnSecondInstanceLaunch: app.onSecondInstanceLaunch,
+		},
+		Bind: []interface{}{
+			app,
+		},
+	})
+}
+```

website/i18n/pt/docusaurus-plugin-content-docs/current/guides/file-association.mdx

@@ -89,6 +89,31 @@ func main() {
 }
 ```
 
+You also can enable single instance lock for your app. In this case, when you open file with your app, new instance of app is not launched
+and arguments are passed to already running instance. Check single instance lock guide for details. Example:
+
+```go title="main.go"
+func main() {
+	// Create application with options
+	err := wails.Run(&options.App{
+		Title:  "wails-open-file",
+		Width:  1024,
+		Height: 768,
+		AssetServer: &assetserver.Options{
+			Assets: assets,
+		},
+		BackgroundColour: &options.RGBA{R: 27, G: 38, B: 54, A: 1},
+		SingleInstanceLock: &options.SingleInstanceLock{
+			UniqueId:               "e3984e08-28dc-4e3d-b70a-45e961589cdc",
+			OnSecondInstanceLaunch: app.onSecondInstanceLaunch,
+		},
+		Bind: []interface{}{
+			app,
+		},
+	})
+}
+```
+
 ### Linux
 
 Currently, Wails doesn't support bundling for Linux. So, you need to create file associations manually.
@@ -193,7 +218,27 @@ func main() {
 }
 ```
 
-## Limitations:
+You also can enable single instance lock for your app. In this case, when you open file with your app, new instance of app is not launched
+and arguments are passed to already running instance. Check single instance lock guide for details. Example:
 
-On Windows and Linux when associated file is opened, new instance of your app is launched.
+```go title="main.go"
-Currently, Wails doesn't support opening files in already running app. There is plugin for single instance support for v3 in development.
+func main() {
+	// Create application with options
+	err := wails.Run(&options.App{
+		Title:  "wails-open-file",
+		Width:  1024,
+		Height: 768,
+		AssetServer: &assetserver.Options{
+			Assets: assets,
+		},
+		BackgroundColour: &options.RGBA{R: 27, G: 38, B: 54, A: 1},
+		SingleInstanceLock: &options.SingleInstanceLock{
+			UniqueId:               "e3984e08-28dc-4e3d-b70a-45e961589cdc",
+			OnSecondInstanceLaunch: app.onSecondInstanceLaunch,
+		},
+		Bind: []interface{}{
+			app,
+		},
+	})
+}
+```

website/i18n/pt/docusaurus-plugin-content-docs/current/guides/single-instance-lock.mdx

@@ -0,0 +1,81 @@
+# Single Instance Lock
+
+Single instance lock is a mechanism that allows you to prevent multiple instances of your app from running at the same time.
+It is useful for apps that are designed to open files from the command line or from the OS file explorer.
+
+## Important
+
+Single Instance Lock does not implement a secure communications protocol between instances. When using single instance lock,
+your app should treat any data passed to it from second instance callback as untrusted.
+You should verify that args that you receive are valid and don't contain any malicious data.
+
+## How it works
+
+Windows: Single instance lock is implemented using a named mutex. The mutex name is generated from the unique id that you provide. Data is passed to the first instance via a shared window using [SendMessage](https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-sendmessage)
+macOS: Single instance lock is implemented using a named mutex. The mutex name is generated from the unique id that you provide. Data is passed to the first instance via [NSDistributedNotificationCenter](https://developer.apple.com/documentation/foundation/nsdistributednotificationcenter)
+Linux: Single instance lock is implemented using [dbus](https://www.freedesktop.org/wiki/Software/dbus/). The dbus name is generated from the unique id that you provide. Data is passed to the first instance via [dbus](https://www.freedesktop.org/wiki/Software/dbus/)
+
+## Usage
+
+When creating your app, you can enable single instance lock by passing a `SingleInstanceLock` struct to the `App` struct.
+Use the `UniqueId` field to specify a unique id for your app.
+This id is used to generate the mutex name on Windows and macOS and the dbus name on Linux. Use a UUID to ensure that the id is unique.
+The `OnSecondInstanceLaunch` field is used to specify a callback that is called when a second instance of your app is launched.
+The callback receives a `SecondInstanceData` struct that contains the command line arguments passed to the second instance and the working directory of the second instance.
+
+Note that OnSecondInstanceLaunch don't trigger windows focus.
+You need to call `runtime.WindowUnminimise` and `runtime.Show` to bring your app to the front.
+Note that on linux systems window managers may prevent your app from being brought to the front to avoid stealing focus.
+
+```go title="main.go"
+var wailsContext *context.Context
+
+// NewApp creates a new App application struct
+func NewApp() *App {
+	return &App{}
+}
+
+// startup is called when the app starts. The context is saved
+// so we can call the runtime methods
+func (a *App) startup(ctx context.Context) {
+	wailsContext = &ctx
+}
+
+func (a *App) onSecondInstanceLaunch(secondInstanceData options.SecondInstanceData) {
+	secondInstanceArgs = secondInstanceData.Args
+
+	println("user opened second instance", strings.Join(secondInstanceData.Args, ","))
+	println("user opened second from", secondInstanceData.WorkingDirectory)
+	runtime.WindowUnminimise(*wailsContext)
+	runtime.Show(*wailsContext)
+	go runtime.EventsEmit(*wailsContext, "launchArgs", secondInstanceArgs)
+}
+
+func main() {
+	// Create an instance of the app structure
+	app := NewApp()
+
+	// Create application with options
+	err := wails.Run(&options.App{
+		Title:  "wails-open-file",
+		Width:  1024,
+		Height: 768,
+		AssetServer: &assetserver.Options{
+			Assets: assets,
+		},
+		BackgroundColour: &options.RGBA{R: 27, G: 38, B: 54, A: 1},
+		OnStartup:        app.startup,
+		SingleInstanceLock: &options.SingleInstanceLock{
+			UniqueId:               "e3984e08-28dc-4e3d-b70a-45e961589cdc",
+			OnSecondInstanceLaunch: app.onSecondInstanceLaunch,
+		},
+		Bind: []interface{}{
+			app,
+		},
+	})
+
+	if err != nil {
+		println("Error:", err.Error())
+	}
+}
+```

website/i18n/pt/docusaurus-plugin-content-docs/current/introduction.mdx

@@ -42,7 +42,7 @@ Há uma série de modelos pré-configurados que permitem que o aplicativo entre
 
 Wails uses a purpose built library for handling native elements such as Window, Menus, Dialogs, etc, so you can build good-looking, feature rich desktop applications.
 
-**Ele não incorpora um navegador**, então é eficiente em recursos. Ao invés disso, ele usa o mecanismo de renderização nativo para a plataforma. No Windows, esta é a nova biblioteca da Microsoft Webview2, construída no Chromium.
+**It does not embed a browser**, so it delivers a small runtime. Instead, it reuses the native rendering engine for the platform. No Windows, esta é a nova biblioteca da Microsoft Webview2, construída no Chromium.
 
 ### Go & JavaScript Interoperability
 

website/i18n/pt/docusaurus-plugin-content-pages/changelog.mdx

@@ -15,6 +15,8 @@ O formato é baseado em [Manter um Log de Alterações](https://keepachangelog.c
 
 ### Adicionado
 
+- Update the description of `ZoomFactor` and `IsZoomControlEnabled` attributes in the document. Added by @biuaxia in [PR](https://github.com/wailsapp/wails/pull/3013)
+- Added Single Instance Lock support with passing arguments to first instance. Added by @APshenkin in [PR](https://github.com/wailsapp/wails/pull/2951)
 - Added support for enabling/disabling swipe gestures for Windows WebView2. Added by @leaanthony in [PR](https://github.com/wailsapp/wails/pull/2878)
 - When building with `-devtools` flag, CMD/CTRL+SHIFT+F12 can be used to open the devtools. Added by @leaanthony in [PR](https://github.com/wailsapp/wails/pull/2915) – Added file association support for macOS and Windows. Added by @APshenkin in [PR](https://github.com/wailsapp/wails/pull/2918)
 - Added support for setting some of the Webview preferences, `textInteractionEnabled` and `tabFocusesLinks` on Mac. Added by @fkhadra in [PR](https://github.com/wailsapp/wails/pull/2937)
@@ -23,6 +25,8 @@ O formato é baseado em [Manter um Log de Alterações](https://keepachangelog.c
 - New task created for linting v2 `task v2:lint`. Workflow updated to run the task. Added by @mikeee in [PR](https://github.com/wailsapp/wails/pull/2957)
 - Added new community template wails-htmx-templ-chi-tailwind. Added by [@pylotlight](https://github.com/pylotlight) in [PR](https://github.com/wailsapp/wails/pull/2984)
 - Added CPU/GPU/Memory detection for `wails doctor`. Added by @leaanthony in #d51268b8d0680430f3a614775b13e6cd2b906d1c
+- The [AssetServer](/docs/reference/options#assetserver) now injects the runtime/IPC into all index html files and into all html files returned when requesting a folder path. Added by @stffabi in [PR](https://github.com/wailsapp/wails/pull/2203)
+- Added Custom Protocol Schemes associations support for macOS and Windows. Added by @APshenkin in [PR](https://github.com/wailsapp/wails/pull/3000)
 
 ### Alterado
 
@@ -30,10 +34,12 @@ O formato é baseado em [Manter um Log de Alterações](https://keepachangelog.c
 - AssetServer requests are now processed concurrently by spawning a goroutine per request. Changed by @stffabi in [PR](https://github.com/wailsapp/wails/pull/2926)
 - Now building with `-devtools` flag doesn't enable the default context-menu. Changed by @mmghv in [PR](https://github.com/wailsapp/wails/pull/2923)
 - Change Window Level. Changed by @almas1992 in [PR](https://github.com/wailsapp/wails/pull/2944)
+
 #### Corrigido
 
 - Fixed typo on docs/reference/options page. Added by [@pylotlight](https://github.com/pylotlight) in [PR](https://github.com/wailsapp/wails/pull/2887)
 - Fixed issue with npm being called npm20 on openSUSE-Tumbleweed. Fixed by @TuffenDuffen in [PR] in (https://github.com/wailsapp/wails/pull/2941)
+- Fixed memory corruption on Windows when using accelerator keys. Fixed by @stffabi in [PR] in (https://github.com/wailsapp/wails/pull/3002)
 
 ## v2.6.0 - 2023-09-06
 

website/i18n/pt/docusaurus-plugin-content-pages/credits.mdx

@@ -2,9 +2,9 @@
 
 - [Lea Anthony](https://github.com/leaanthony) - Project owner, lead developer
 - [Stffabi](https://github.com/stffabi) - Technical lead, developer and maintainer
-- [Misite Bao](https://github.com/misitebao) - Documentation wizard, Chinese translation, Windows testing, Bug finder general
 - [Travis McLane](https://github.com/tmclane) - Cross-compilation work, MacOS testing
 - [Lyimmi](https://github.com/Lyimmi) - All things Linux
+- [Simon Thomas](mailto:enquiries@wails.io) - Growth Hacker
 
 ## Sponsors
 <img src="/img/sponsors.svg" style={{"width":"85%","max-width":"800px;"}} />

website/i18n/ru/docusaurus-plugin-content-docs/current/guides/custom-protocol-schemes.mdx

@@ -0,0 +1,204 @@
+# Custom Protocol Scheme association
+
+Custom Protocols feature allows you to associate specific custom protocol with your app so that when users open links with this protocol,
+your app is launched to handle them. This can be particularly useful to connect your desktop app with your web app.
+In this guide, we'll walk through the steps to implement custom protocols in Wails app.
+
+## Set Up Custom Protocol Schemes Association:
+
+To set up custom protocol, you need to modify your application's wails.json file.
+In "info" section add a "protocols" section specifying the protocols your app should be associated with.
+
+For example:
+
+```json
+{
+  "info": {
+    "protocols": [
+      {
+        "scheme": "myapp",
+        "description": "My App Protocol",
+        "role": "Editor"
+      }
+    ]
+  }
+}
+```
+
+| Property    | Description                                                                           |
+| :---------- | :------------------------------------------------------------------------------------ |
+| scheme      | Custom Protocol scheme. e.g. myapp                                                    |
+| description | Windows-only. The description.                                                        |
+| role        | macOS-only. The app’s role with respect to the type. Corresponds to CFBundleTypeRole. |
+
+## Platform Specifics:
+
+### macOS
+
+When you open custom protocol with your app, the system will launch your app and call the `OnUrlOpen` function in your Wails app. Example:
+
+```go title="main.go"
+func main() {
+	// Create application with options
+	err := wails.Run(&options.App{
+		Title:  "wails-open-file",
+		Width:  1024,
+		Height: 768,
+		AssetServer: &assetserver.Options{
+			Assets: assets,
+		},
+		BackgroundColour: &options.RGBA{R: 27, G: 38, B: 54, A: 1},
+		Mac: &mac.Options{
+			OnUrlOpen: func(url string) { println(url) },
+		},
+		Bind: []interface{}{
+			app,
+		},
+	})
+
+	if err != nil {
+		println("Error:", err.Error())
+	}
+}
+```
+
+### Windows
+
+On Windows Custom Protocol Schemes is supported only with NSIS installer. During installation, the installer will create a
+registry entry for your schemes. When you open url with your app, new instance of app is launched and url is passed
+as argument to your app. To handle this you should parse command line arguments in your app. Example:
+
+```go title="main.go"
+func main() {
+	argsWithoutProg := os.Args[1:]
+
+	if len(argsWithoutProg) != 0 {
+    println("launchArgs", argsWithoutProg)
+  }
+}
+```
+
+You also can enable single instance lock for your app. In this case, when you open url with your app, new instance of app is not launched
+and arguments are passed to already running instance. Check single instance lock guide for details. Example:
+
+```go title="main.go"
+func main() {
+	// Create application with options
+	err := wails.Run(&options.App{
+		Title:  "wails-open-file",
+		Width:  1024,
+		Height: 768,
+		AssetServer: &assetserver.Options{
+			Assets: assets,
+		},
+		BackgroundColour: &options.RGBA{R: 27, G: 38, B: 54, A: 1},
+		SingleInstanceLock: &options.SingleInstanceLock{
+			UniqueId:               "e3984e08-28dc-4e3d-b70a-45e961589cdc",
+			OnSecondInstanceLaunch: app.onSecondInstanceLaunch,
+		},
+		Bind: []interface{}{
+			app,
+		},
+	})
+}
+```
+
+### Linux
+
+Currently, Wails doesn't support bundling for Linux. So, you need to create file associations manually.
+For example if you distribute your app as a .deb package, you can create file associations by adding required files in you bundle.
+You can use [nfpm](https://nfpm.goreleaser.com/) to create .deb package for your app.
+
+1.  Create a .desktop file for your app and specify file associations there (note that `%u` is important in Exec). Example:
+
+```ini
+[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;
+```
+
+2.  Prepare postInstall/postRemove scripts for your package. Example:
+
+```sh
+# reload desktop database to load app in list of available
+update-desktop-database /usr/share/applications
+```
+
+3.  Configure nfpm to use your scripts and files. Example:
+
+```yaml
+name: "wails-open-file"
+arch: "arm64"
+platform: "linux"
+version: "1.0.0"
+section: "default"
+priority: "extra"
+maintainer: "FooBarCorp <FooBarCorp@gmail.com>"
+description: "Sample Package"
+vendor: "FooBarCorp"
+homepage: "http://example.com"
+license: "MIT"
+contents:
+- src: ../bin/wails-open-file
+  dst: /usr/bin/wails-open-file
+- src: ./main.desktop
+  dst: /usr/share/applications/wails-open-file.desktop
+- src: ../appicon.svg
+  dst: /usr/share/icons/hicolor/scalable/apps/wails-open-file.svg
+# copy icons to Yaru theme as well. For some reason Ubuntu didn't pick up fileicons from hicolor theme
+- src: ../appicon.svg
+  dst: /usr/share/icons/Yaru/scalable/apps/wails-open-file.svg
+scripts:
+  postinstall: ./postInstall.sh
+  postremove: ./postRemove.sh
+```
+
+6.  Build your .deb package using nfpm:
+
+```sh
+nfpm pkg --packager deb --target .
+```
+
+7.  Now when your package is installed, your app will be associated with custom protocol scheme. When you open url with your app,
+    new instance of app is launched and file path is passed as argument to your app.
+    To handle this you should parse command line arguments in your app. Example:
+
+```go title="main.go"
+func main() {
+	argsWithoutProg := os.Args[1:]
+
+	if len(argsWithoutProg) != 0 {
+    println("launchArgs", argsWithoutProg)
+  }
+}
+```
+
+You also can enable single instance lock for your app. In this case, when you open url with your app, new instance of app is not launched
+and arguments are passed to already running instance. Check single instance lock guide for details. Example:
+
+```go title="main.go"
+func main() {
+	// Create application with options
+	err := wails.Run(&options.App{
+		Title:  "wails-open-file",
+		Width:  1024,
+		Height: 768,
+		AssetServer: &assetserver.Options{
+			Assets: assets,
+		},
+		BackgroundColour: &options.RGBA{R: 27, G: 38, B: 54, A: 1},
+		SingleInstanceLock: &options.SingleInstanceLock{
+			UniqueId:               "e3984e08-28dc-4e3d-b70a-45e961589cdc",
+			OnSecondInstanceLaunch: app.onSecondInstanceLaunch,
+		},
+		Bind: []interface{}{
+			app,
+		},
+	})
+}
+```

website/i18n/ru/docusaurus-plugin-content-docs/current/guides/file-association.mdx

@@ -89,6 +89,31 @@ func main() {
 }
 ```
 
+You also can enable single instance lock for your app. In this case, when you open file with your app, new instance of app is not launched
+and arguments are passed to already running instance. Check single instance lock guide for details. Example:
+
+```go title="main.go"
+func main() {
+	// Create application with options
+	err := wails.Run(&options.App{
+		Title:  "wails-open-file",
+		Width:  1024,
+		Height: 768,
+		AssetServer: &assetserver.Options{
+			Assets: assets,
+		},
+		BackgroundColour: &options.RGBA{R: 27, G: 38, B: 54, A: 1},
+		SingleInstanceLock: &options.SingleInstanceLock{
+			UniqueId:               "e3984e08-28dc-4e3d-b70a-45e961589cdc",
+			OnSecondInstanceLaunch: app.onSecondInstanceLaunch,
+		},
+		Bind: []interface{}{
+			app,
+		},
+	})
+}
+```
+
 ### Linux
 
 Currently, Wails doesn't support bundling for Linux. So, you need to create file associations manually.
@@ -193,7 +218,27 @@ func main() {
 }
 ```
 
-## Limitations:
+You also can enable single instance lock for your app. In this case, when you open file with your app, new instance of app is not launched
+and arguments are passed to already running instance. Check single instance lock guide for details. Example:
 
-On Windows and Linux when associated file is opened, new instance of your app is launched.
+```go title="main.go"
-Currently, Wails doesn't support opening files in already running app. There is plugin for single instance support for v3 in development.
+func main() {
+	// Create application with options
+	err := wails.Run(&options.App{
+		Title:  "wails-open-file",
+		Width:  1024,
+		Height: 768,
+		AssetServer: &assetserver.Options{
+			Assets: assets,
+		},
+		BackgroundColour: &options.RGBA{R: 27, G: 38, B: 54, A: 1},
+		SingleInstanceLock: &options.SingleInstanceLock{
+			UniqueId:               "e3984e08-28dc-4e3d-b70a-45e961589cdc",
+			OnSecondInstanceLaunch: app.onSecondInstanceLaunch,
+		},
+		Bind: []interface{}{
+			app,
+		},
+	})
+}
+```

website/i18n/ru/docusaurus-plugin-content-docs/current/guides/single-instance-lock.mdx

@@ -0,0 +1,81 @@
+# Single Instance Lock
+
+Single instance lock is a mechanism that allows you to prevent multiple instances of your app from running at the same time.
+It is useful for apps that are designed to open files from the command line or from the OS file explorer.
+
+## Important
+
+Single Instance Lock does not implement a secure communications protocol between instances. When using single instance lock,
+your app should treat any data passed to it from second instance callback as untrusted.
+You should verify that args that you receive are valid and don't contain any malicious data.
+
+## How it works
+
+Windows: Single instance lock is implemented using a named mutex. The mutex name is generated from the unique id that you provide. Data is passed to the first instance via a shared window using [SendMessage](https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-sendmessage)
+macOS: Single instance lock is implemented using a named mutex. The mutex name is generated from the unique id that you provide. Data is passed to the first instance via [NSDistributedNotificationCenter](https://developer.apple.com/documentation/foundation/nsdistributednotificationcenter)
+Linux: Single instance lock is implemented using [dbus](https://www.freedesktop.org/wiki/Software/dbus/). The dbus name is generated from the unique id that you provide. Data is passed to the first instance via [dbus](https://www.freedesktop.org/wiki/Software/dbus/)
+
+## Usage
+
+When creating your app, you can enable single instance lock by passing a `SingleInstanceLock` struct to the `App` struct.
+Use the `UniqueId` field to specify a unique id for your app.
+This id is used to generate the mutex name on Windows and macOS and the dbus name on Linux. Use a UUID to ensure that the id is unique.
+The `OnSecondInstanceLaunch` field is used to specify a callback that is called when a second instance of your app is launched.
+The callback receives a `SecondInstanceData` struct that contains the command line arguments passed to the second instance and the working directory of the second instance.
+
+Note that OnSecondInstanceLaunch don't trigger windows focus.
+You need to call `runtime.WindowUnminimise` and `runtime.Show` to bring your app to the front.
+Note that on linux systems window managers may prevent your app from being brought to the front to avoid stealing focus.
+
+```go title="main.go"
+var wailsContext *context.Context
+
+// NewApp creates a new App application struct
+func NewApp() *App {
+	return &App{}
+}
+
+// startup is called when the app starts. The context is saved
+// so we can call the runtime methods
+func (a *App) startup(ctx context.Context) {
+	wailsContext = &ctx
+}
+
+func (a *App) onSecondInstanceLaunch(secondInstanceData options.SecondInstanceData) {
+	secondInstanceArgs = secondInstanceData.Args
+
+	println("user opened second instance", strings.Join(secondInstanceData.Args, ","))
+	println("user opened second from", secondInstanceData.WorkingDirectory)
+	runtime.WindowUnminimise(*wailsContext)
+	runtime.Show(*wailsContext)
+	go runtime.EventsEmit(*wailsContext, "launchArgs", secondInstanceArgs)
+}
+
+func main() {
+	// Create an instance of the app structure
+	app := NewApp()
+
+	// Create application with options
+	err := wails.Run(&options.App{
+		Title:  "wails-open-file",
+		Width:  1024,
+		Height: 768,
+		AssetServer: &assetserver.Options{
+			Assets: assets,
+		},
+		BackgroundColour: &options.RGBA{R: 27, G: 38, B: 54, A: 1},
+		OnStartup:        app.startup,
+		SingleInstanceLock: &options.SingleInstanceLock{
+			UniqueId:               "e3984e08-28dc-4e3d-b70a-45e961589cdc",
+			OnSecondInstanceLaunch: app.onSecondInstanceLaunch,
+		},
+		Bind: []interface{}{
+			app,
+		},
+	})
+
+	if err != nil {
+		println("Error:", err.Error())
+	}
+}
+```

website/i18n/ru/docusaurus-plugin-content-docs/current/introduction.mdx

@@ -42,7 +42,7 @@ Wails поставляется с рядом предварительно нас
 
 Wails использует специально созданную библиотеку для обработки системных элементов, таких как окна, меню, диалоги и так далее, чтобы вы могли создавать хорошо выглядящие, богатые функционалом приложения.
 
-**В нем нет встроенного браузера**, таким образом, это экономично с точки зрения ресурсов. Вместо этого он использует нативный движок отрисовки для необходимой платформы. На Windows это новая библиотека Microsoft Webview2, основанная на Chromium.
+**It does not embed a browser**, so it delivers a small runtime. Instead, it reuses the native rendering engine for the platform. На Windows это новая библиотека Microsoft Webview2, основанная на Chromium.
 
 ### Go & JavaScript Interoperability
 

website/i18n/ru/docusaurus-plugin-content-pages/changelog.mdx

@@ -15,6 +15,8 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 
 ### Added
 
+- Update the description of `ZoomFactor` and `IsZoomControlEnabled` attributes in the document. Added by @biuaxia in [PR](https://github.com/wailsapp/wails/pull/3013)
+- Added Single Instance Lock support with passing arguments to first instance. Added by @APshenkin in [PR](https://github.com/wailsapp/wails/pull/2951)
 - Added support for enabling/disabling swipe gestures for Windows WebView2. Added by @leaanthony in [PR](https://github.com/wailsapp/wails/pull/2878)
 - When building with `-devtools` flag, CMD/CTRL+SHIFT+F12 can be used to open the devtools. Added by @leaanthony in [PR](https://github.com/wailsapp/wails/pull/2915) – Added file association support for macOS and Windows. Added by @APshenkin in [PR](https://github.com/wailsapp/wails/pull/2918)
 - Added support for setting some of the Webview preferences, `textInteractionEnabled` and `tabFocusesLinks` on Mac. Added by @fkhadra in [PR](https://github.com/wailsapp/wails/pull/2937)
@@ -23,6 +25,8 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 - New task created for linting v2 `task v2:lint`. Workflow updated to run the task. Added by @mikeee in [PR](https://github.com/wailsapp/wails/pull/2957)
 - Added new community template wails-htmx-templ-chi-tailwind. Added by [@pylotlight](https://github.com/pylotlight) in [PR](https://github.com/wailsapp/wails/pull/2984)
 - Added CPU/GPU/Memory detection for `wails doctor`. Added by @leaanthony in #d51268b8d0680430f3a614775b13e6cd2b906d1c
+- The [AssetServer](/docs/reference/options#assetserver) now injects the runtime/IPC into all index html files and into all html files returned when requesting a folder path. Added by @stffabi in [PR](https://github.com/wailsapp/wails/pull/2203)
+- Added Custom Protocol Schemes associations support for macOS and Windows. Added by @APshenkin in [PR](https://github.com/wailsapp/wails/pull/3000)
 
 ### Changed
 
@@ -30,10 +34,12 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 - AssetServer requests are now processed concurrently by spawning a goroutine per request. Changed by @stffabi in [PR](https://github.com/wailsapp/wails/pull/2926)
 - Now building with `-devtools` flag doesn't enable the default context-menu. Changed by @mmghv in [PR](https://github.com/wailsapp/wails/pull/2923)
 - Change Window Level. Changed by @almas1992 in [PR](https://github.com/wailsapp/wails/pull/2944)
+
 #### Fixed
 
 - Fixed typo on docs/reference/options page. Added by [@pylotlight](https://github.com/pylotlight) in [PR](https://github.com/wailsapp/wails/pull/2887)
 - Fixed issue with npm being called npm20 on openSUSE-Tumbleweed. Fixed by @TuffenDuffen in [PR] in (https://github.com/wailsapp/wails/pull/2941)
+- Fixed memory corruption on Windows when using accelerator keys. Fixed by @stffabi in [PR] in (https://github.com/wailsapp/wails/pull/3002)
 
 ## v2.6.0 - 2023-09-06
 

website/i18n/ru/docusaurus-plugin-content-pages/credits.mdx

@@ -2,9 +2,9 @@
 
 - [Lea Anthony](https://github.com/leaanthony) - Project owner, lead developer
 - [Stffabi](https://github.com/stffabi) - Technical lead, developer and maintainer
-- [Misite Bao](https://github.com/misitebao) - Мастер документации, перевод на китайский язык, тестирование Windows, общий поиск ошибок
 - [Travis McLane](https://github.com/tmclane) - кросс-компиляция, тестирование MacOS
 - [Lyimmi](https://github.com/Lyimmi) - All things Linux
+- [Simon Thomas](mailto:enquiries@wails.io) - Growth Hacker
 
 ## Sponsors
 <img src="/img/sponsors.svg" style={{"width":"85%","max-width":"800px;"}} />

website/i18n/vi/docusaurus-plugin-content-docs/current/guides/custom-protocol-schemes.mdx

@@ -0,0 +1,204 @@
+# Custom Protocol Scheme association
+
+Custom Protocols feature allows you to associate specific custom protocol with your app so that when users open links with this protocol,
+your app is launched to handle them. This can be particularly useful to connect your desktop app with your web app.
+In this guide, we'll walk through the steps to implement custom protocols in Wails app.
+
+## Set Up Custom Protocol Schemes Association:
+
+To set up custom protocol, you need to modify your application's wails.json file.
+In "info" section add a "protocols" section specifying the protocols your app should be associated with.
+
+For example:
+
+```json
+{
+  "info": {
+    "protocols": [
+      {
+        "scheme": "myapp",
+        "description": "My App Protocol",
+        "role": "Editor"
+      }
+    ]
+  }
+}
+```
+
+| Property    | Description                                                                           |
+| :---------- | :------------------------------------------------------------------------------------ |
+| scheme      | Custom Protocol scheme. e.g. myapp                                                    |
+| description | Windows-only. The description.                                                        |
+| role        | macOS-only. The app’s role with respect to the type. Corresponds to CFBundleTypeRole. |
+
+## Platform Specifics:
+
+### macOS
+
+When you open custom protocol with your app, the system will launch your app and call the `OnUrlOpen` function in your Wails app. Example:
+
+```go title="main.go"
+func main() {
+	// Create application with options
+	err := wails.Run(&options.App{
+		Title:  "wails-open-file",
+		Width:  1024,
+		Height: 768,
+		AssetServer: &assetserver.Options{
+			Assets: assets,
+		},
+		BackgroundColour: &options.RGBA{R: 27, G: 38, B: 54, A: 1},
+		Mac: &mac.Options{
+			OnUrlOpen: func(url string) { println(url) },
+		},
+		Bind: []interface{}{
+			app,
+		},
+	})
+
+	if err != nil {
+		println("Error:", err.Error())
+	}
+}
+```
+
+### Windows
+
+On Windows Custom Protocol Schemes is supported only with NSIS installer. During installation, the installer will create a
+registry entry for your schemes. When you open url with your app, new instance of app is launched and url is passed
+as argument to your app. To handle this you should parse command line arguments in your app. Example:
+
+```go title="main.go"
+func main() {
+	argsWithoutProg := os.Args[1:]
+
+	if len(argsWithoutProg) != 0 {
+    println("launchArgs", argsWithoutProg)
+  }
+}
+```
+
+You also can enable single instance lock for your app. In this case, when you open url with your app, new instance of app is not launched
+and arguments are passed to already running instance. Check single instance lock guide for details. Example:
+
+```go title="main.go"
+func main() {
+	// Create application with options
+	err := wails.Run(&options.App{
+		Title:  "wails-open-file",
+		Width:  1024,
+		Height: 768,
+		AssetServer: &assetserver.Options{
+			Assets: assets,
+		},
+		BackgroundColour: &options.RGBA{R: 27, G: 38, B: 54, A: 1},
+		SingleInstanceLock: &options.SingleInstanceLock{
+			UniqueId:               "e3984e08-28dc-4e3d-b70a-45e961589cdc",
+			OnSecondInstanceLaunch: app.onSecondInstanceLaunch,
+		},
+		Bind: []interface{}{
+			app,
+		},
+	})
+}
+```
+
+### Linux
+
+Currently, Wails doesn't support bundling for Linux. So, you need to create file associations manually.
+For example if you distribute your app as a .deb package, you can create file associations by adding required files in you bundle.
+You can use [nfpm](https://nfpm.goreleaser.com/) to create .deb package for your app.
+
+1.  Create a .desktop file for your app and specify file associations there (note that `%u` is important in Exec). Example:
+
+```ini
+[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;
+```
+
+2.  Prepare postInstall/postRemove scripts for your package. Example:
+
+```sh
+# reload desktop database to load app in list of available
+update-desktop-database /usr/share/applications
+```
+
+3.  Configure nfpm to use your scripts and files. Example:
+
+```yaml
+name: "wails-open-file"
+arch: "arm64"
+platform: "linux"
+version: "1.0.0"
+section: "default"
+priority: "extra"
+maintainer: "FooBarCorp <FooBarCorp@gmail.com>"
+description: "Sample Package"
+vendor: "FooBarCorp"
+homepage: "http://example.com"
+license: "MIT"
+contents:
+- src: ../bin/wails-open-file
+  dst: /usr/bin/wails-open-file
+- src: ./main.desktop
+  dst: /usr/share/applications/wails-open-file.desktop
+- src: ../appicon.svg
+  dst: /usr/share/icons/hicolor/scalable/apps/wails-open-file.svg
+# copy icons to Yaru theme as well. For some reason Ubuntu didn't pick up fileicons from hicolor theme
+- src: ../appicon.svg
+  dst: /usr/share/icons/Yaru/scalable/apps/wails-open-file.svg
+scripts:
+  postinstall: ./postInstall.sh
+  postremove: ./postRemove.sh
+```
+
+6.  Build your .deb package using nfpm:
+
+```sh
+nfpm pkg --packager deb --target .
+```
+
+7.  Now when your package is installed, your app will be associated with custom protocol scheme. When you open url with your app,
+    new instance of app is launched and file path is passed as argument to your app.
+    To handle this you should parse command line arguments in your app. Example:
+
+```go title="main.go"
+func main() {
+	argsWithoutProg := os.Args[1:]
+
+	if len(argsWithoutProg) != 0 {
+    println("launchArgs", argsWithoutProg)
+  }
+}
+```
+
+You also can enable single instance lock for your app. In this case, when you open url with your app, new instance of app is not launched
+and arguments are passed to already running instance. Check single instance lock guide for details. Example:
+
+```go title="main.go"
+func main() {
+	// Create application with options
+	err := wails.Run(&options.App{
+		Title:  "wails-open-file",
+		Width:  1024,
+		Height: 768,
+		AssetServer: &assetserver.Options{
+			Assets: assets,
+		},
+		BackgroundColour: &options.RGBA{R: 27, G: 38, B: 54, A: 1},
+		SingleInstanceLock: &options.SingleInstanceLock{
+			UniqueId:               "e3984e08-28dc-4e3d-b70a-45e961589cdc",
+			OnSecondInstanceLaunch: app.onSecondInstanceLaunch,
+		},
+		Bind: []interface{}{
+			app,
+		},
+	})
+}
+```

website/i18n/vi/docusaurus-plugin-content-docs/current/guides/file-association.mdx

@@ -89,6 +89,31 @@ func main() {
 }
 ```
 
+You also can enable single instance lock for your app. In this case, when you open file with your app, new instance of app is not launched
+and arguments are passed to already running instance. Check single instance lock guide for details. Example:
+
+```go title="main.go"
+func main() {
+	// Create application with options
+	err := wails.Run(&options.App{
+		Title:  "wails-open-file",
+		Width:  1024,
+		Height: 768,
+		AssetServer: &assetserver.Options{
+			Assets: assets,
+		},
+		BackgroundColour: &options.RGBA{R: 27, G: 38, B: 54, A: 1},
+		SingleInstanceLock: &options.SingleInstanceLock{
+			UniqueId:               "e3984e08-28dc-4e3d-b70a-45e961589cdc",
+			OnSecondInstanceLaunch: app.onSecondInstanceLaunch,
+		},
+		Bind: []interface{}{
+			app,
+		},
+	})
+}
+```
+
 ### Linux
 
 Currently, Wails doesn't support bundling for Linux. So, you need to create file associations manually.
@@ -193,7 +218,27 @@ func main() {
 }
 ```
 
-## Limitations:
+You also can enable single instance lock for your app. In this case, when you open file with your app, new instance of app is not launched
+and arguments are passed to already running instance. Check single instance lock guide for details. Example:
 
-On Windows and Linux when associated file is opened, new instance of your app is launched.
+```go title="main.go"
-Currently, Wails doesn't support opening files in already running app. There is plugin for single instance support for v3 in development.
+func main() {
+	// Create application with options
+	err := wails.Run(&options.App{
+		Title:  "wails-open-file",
+		Width:  1024,
+		Height: 768,
+		AssetServer: &assetserver.Options{
+			Assets: assets,
+		},
+		BackgroundColour: &options.RGBA{R: 27, G: 38, B: 54, A: 1},
+		SingleInstanceLock: &options.SingleInstanceLock{
+			UniqueId:               "e3984e08-28dc-4e3d-b70a-45e961589cdc",
+			OnSecondInstanceLaunch: app.onSecondInstanceLaunch,
+		},
+		Bind: []interface{}{
+			app,
+		},
+	})
+}
+```

website/i18n/vi/docusaurus-plugin-content-docs/current/guides/single-instance-lock.mdx

@@ -0,0 +1,81 @@
+# Single Instance Lock
+
+Single instance lock is a mechanism that allows you to prevent multiple instances of your app from running at the same time.
+It is useful for apps that are designed to open files from the command line or from the OS file explorer.
+
+## Important
+
+Single Instance Lock does not implement a secure communications protocol between instances. When using single instance lock,
+your app should treat any data passed to it from second instance callback as untrusted.
+You should verify that args that you receive are valid and don't contain any malicious data.
+
+## How it works
+
+Windows: Single instance lock is implemented using a named mutex. The mutex name is generated from the unique id that you provide. Data is passed to the first instance via a shared window using [SendMessage](https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-sendmessage)
+macOS: Single instance lock is implemented using a named mutex. The mutex name is generated from the unique id that you provide. Data is passed to the first instance via [NSDistributedNotificationCenter](https://developer.apple.com/documentation/foundation/nsdistributednotificationcenter)
+Linux: Single instance lock is implemented using [dbus](https://www.freedesktop.org/wiki/Software/dbus/). The dbus name is generated from the unique id that you provide. Data is passed to the first instance via [dbus](https://www.freedesktop.org/wiki/Software/dbus/)
+
+## Usage
+
+When creating your app, you can enable single instance lock by passing a `SingleInstanceLock` struct to the `App` struct.
+Use the `UniqueId` field to specify a unique id for your app.
+This id is used to generate the mutex name on Windows and macOS and the dbus name on Linux. Use a UUID to ensure that the id is unique.
+The `OnSecondInstanceLaunch` field is used to specify a callback that is called when a second instance of your app is launched.
+The callback receives a `SecondInstanceData` struct that contains the command line arguments passed to the second instance and the working directory of the second instance.
+
+Note that OnSecondInstanceLaunch don't trigger windows focus.
+You need to call `runtime.WindowUnminimise` and `runtime.Show` to bring your app to the front.
+Note that on linux systems window managers may prevent your app from being brought to the front to avoid stealing focus.
+
+```go title="main.go"
+var wailsContext *context.Context
+
+// NewApp creates a new App application struct
+func NewApp() *App {
+	return &App{}
+}
+
+// startup is called when the app starts. The context is saved
+// so we can call the runtime methods
+func (a *App) startup(ctx context.Context) {
+	wailsContext = &ctx
+}
+
+func (a *App) onSecondInstanceLaunch(secondInstanceData options.SecondInstanceData) {
+	secondInstanceArgs = secondInstanceData.Args
+
+	println("user opened second instance", strings.Join(secondInstanceData.Args, ","))
+	println("user opened second from", secondInstanceData.WorkingDirectory)
+	runtime.WindowUnminimise(*wailsContext)
+	runtime.Show(*wailsContext)
+	go runtime.EventsEmit(*wailsContext, "launchArgs", secondInstanceArgs)
+}
+
+func main() {
+	// Create an instance of the app structure
+	app := NewApp()
+
+	// Create application with options
+	err := wails.Run(&options.App{
+		Title:  "wails-open-file",
+		Width:  1024,
+		Height: 768,
+		AssetServer: &assetserver.Options{
+			Assets: assets,
+		},
+		BackgroundColour: &options.RGBA{R: 27, G: 38, B: 54, A: 1},
+		OnStartup:        app.startup,
+		SingleInstanceLock: &options.SingleInstanceLock{
+			UniqueId:               "e3984e08-28dc-4e3d-b70a-45e961589cdc",
+			OnSecondInstanceLaunch: app.onSecondInstanceLaunch,
+		},
+		Bind: []interface{}{
+			app,
+		},
+	})
+
+	if err != nil {
+		println("Error:", err.Error())
+	}
+}
+```

website/i18n/vi/docusaurus-plugin-content-pages/changelog.mdx

@@ -15,6 +15,8 @@ Tất cả những thay đổi đáng chú ý sẽ được thêm vào tài li
 
 ### Added
 
+- Update the description of `ZoomFactor` and `IsZoomControlEnabled` attributes in the document. Added by @biuaxia in [PR](https://github.com/wailsapp/wails/pull/3013)
+- Added Single Instance Lock support with passing arguments to first instance. Added by @APshenkin in [PR](https://github.com/wailsapp/wails/pull/2951)
 - Added support for enabling/disabling swipe gestures for Windows WebView2. Added by @leaanthony in [PR](https://github.com/wailsapp/wails/pull/2878)
 - When building with `-devtools` flag, CMD/CTRL+SHIFT+F12 can be used to open the devtools. Added by @leaanthony in [PR](https://github.com/wailsapp/wails/pull/2915) – Added file association support for macOS and Windows. Added by @APshenkin in [PR](https://github.com/wailsapp/wails/pull/2918)
 - Added support for setting some of the Webview preferences, `textInteractionEnabled` and `tabFocusesLinks` on Mac. Added by @fkhadra in [PR](https://github.com/wailsapp/wails/pull/2937)
@@ -23,6 +25,8 @@ Tất cả những thay đổi đáng chú ý sẽ được thêm vào tài li
 - New task created for linting v2 `task v2:lint`. Workflow updated to run the task. Added by @mikeee in [PR](https://github.com/wailsapp/wails/pull/2957)
 - Added new community template wails-htmx-templ-chi-tailwind. Added by [@pylotlight](https://github.com/pylotlight) in [PR](https://github.com/wailsapp/wails/pull/2984)
 - Added CPU/GPU/Memory detection for `wails doctor`. Added by @leaanthony in #d51268b8d0680430f3a614775b13e6cd2b906d1c
+- The [AssetServer](/docs/reference/options#assetserver) now injects the runtime/IPC into all index html files and into all html files returned when requesting a folder path. Added by @stffabi in [PR](https://github.com/wailsapp/wails/pull/2203)
+- Added Custom Protocol Schemes associations support for macOS and Windows. Added by @APshenkin in [PR](https://github.com/wailsapp/wails/pull/3000)
 
 ### Changed
 
@@ -30,10 +34,12 @@ Tất cả những thay đổi đáng chú ý sẽ được thêm vào tài li
 - AssetServer requests are now processed concurrently by spawning a goroutine per request. Changed by @stffabi in [PR](https://github.com/wailsapp/wails/pull/2926)
 - Now building with `-devtools` flag doesn't enable the default context-menu. Changed by @mmghv in [PR](https://github.com/wailsapp/wails/pull/2923)
 - Change Window Level. Changed by @almas1992 in [PR](https://github.com/wailsapp/wails/pull/2944)
+
 #### Fixed
 
 - Fixed typo on docs/reference/options page. Added by [@pylotlight](https://github.com/pylotlight) in [PR](https://github.com/wailsapp/wails/pull/2887)
 - Fixed issue with npm being called npm20 on openSUSE-Tumbleweed. Fixed by @TuffenDuffen in [PR] in (https://github.com/wailsapp/wails/pull/2941)
+- Fixed memory corruption on Windows when using accelerator keys. Fixed by @stffabi in [PR] in (https://github.com/wailsapp/wails/pull/3002)
 
 ## v2.6.0 - 2023-09-06
 

website/i18n/vi/docusaurus-plugin-content-pages/credits.mdx

@@ -2,9 +2,9 @@
 
 - [Lea Anthony](https://github.com/leaanthony) - Project owner, lead developer
 - [Stffabi](https://github.com/stffabi) - Technical lead, developer and maintainer
-- [Misite Bao](https://github.com/misitebao) - Documentation wizard, Chinese translation, Windows testing, Bug finder general
 - [Travis McLane](https://github.com/tmclane) - Cross-compilation work, MacOS testing
 - [Lyimmi](https://github.com/Lyimmi) - All things Linux
+- [Simon Thomas](mailto:enquiries@wails.io) - Growth Hacker
 
 ## Sponsors
 <img src="/img/sponsors.svg" style={{"width":"85%","max-width":"800px;"}} />

website/i18n/zh-Hans/docusaurus-plugin-content-docs/current/community/templates.mdx

@@ -28,7 +28,6 @@ sidebar_position: 1
 - [wails-template-quasar-js](https://github.com/sgosiaco/wails-template-quasar-js) - 使用 JavaScript + Quasar V2（Vue 3, Vite, Sass, Pinia, ESLint, Prettier）的模板
 - [wails-template-quasar-ts](https://github.com/sgosiaco/wails-template-quasar-ts) - 使用 TypeScript + Quasar V2（Vue 3、Vite、Sass、Pinia、ESLint、Prettier、带 <script setup> 的Composition API）的模板
 - [wails-template-naive](https://github.com/tk103331/wails-template-naive) - 基于 Naive UI(一款 Vue 3 组件库)的 Wails 模板
-- [wails-template-vue-go-easy](https://github.com/duolabmeng6/wails-template-vue-go-easy) - 基于 GoEasyDesigner(一款用于 vue 可视化窗口设计软件)的 Wails 模板
 
 ## Angular
 

website/i18n/zh-Hans/docusaurus-plugin-content-docs/current/guides/custom-protocol-schemes.mdx

@@ -0,0 +1,204 @@
+# Custom Protocol Scheme association
+
+Custom Protocols feature allows you to associate specific custom protocol with your app so that when users open links with this protocol,
+your app is launched to handle them. This can be particularly useful to connect your desktop app with your web app.
+In this guide, we'll walk through the steps to implement custom protocols in Wails app.
+
+## Set Up Custom Protocol Schemes Association:
+
+To set up custom protocol, you need to modify your application's wails.json file.
+In "info" section add a "protocols" section specifying the protocols your app should be associated with.
+
+For example:
+
+```json
+{
+  "info": {
+    "protocols": [
+      {
+        "scheme": "myapp",
+        "description": "My App Protocol",
+        "role": "Editor"
+      }
+    ]
+  }
+}
+```
+
+| Property    | Description                                                                           |
+| :---------- | :------------------------------------------------------------------------------------ |
+| scheme      | Custom Protocol scheme. e.g. myapp                                                    |
+| description | Windows-only. The description.                                                        |
+| role        | macOS-only. The app’s role with respect to the type. Corresponds to CFBundleTypeRole. |
+
+## Platform Specifics:
+
+### macOS
+
+When you open custom protocol with your app, the system will launch your app and call the `OnUrlOpen` function in your Wails app. Example:
+
+```go title="main.go"
+func main() {
+	// Create application with options
+	err := wails.Run(&options.App{
+		Title:  "wails-open-file",
+		Width:  1024,
+		Height: 768,
+		AssetServer: &assetserver.Options{
+			Assets: assets,
+		},
+		BackgroundColour: &options.RGBA{R: 27, G: 38, B: 54, A: 1},
+		Mac: &mac.Options{
+			OnUrlOpen: func(url string) { println(url) },
+		},
+		Bind: []interface{}{
+			app,
+		},
+	})
+
+	if err != nil {
+		println("Error:", err.Error())
+	}
+}
+```
+
+### Windows
+
+On Windows Custom Protocol Schemes is supported only with NSIS installer. During installation, the installer will create a
+registry entry for your schemes. When you open url with your app, new instance of app is launched and url is passed
+as argument to your app. To handle this you should parse command line arguments in your app. Example:
+
+```go title="main.go"
+func main() {
+	argsWithoutProg := os.Args[1:]
+
+	if len(argsWithoutProg) != 0 {
+    println("launchArgs", argsWithoutProg)
+  }
+}
+```
+
+You also can enable single instance lock for your app. In this case, when you open url with your app, new instance of app is not launched
+and arguments are passed to already running instance. Check single instance lock guide for details. Example:
+
+```go title="main.go"
+func main() {
+	// Create application with options
+	err := wails.Run(&options.App{
+		Title:  "wails-open-file",
+		Width:  1024,
+		Height: 768,
+		AssetServer: &assetserver.Options{
+			Assets: assets,
+		},
+		BackgroundColour: &options.RGBA{R: 27, G: 38, B: 54, A: 1},
+		SingleInstanceLock: &options.SingleInstanceLock{
+			UniqueId:               "e3984e08-28dc-4e3d-b70a-45e961589cdc",
+			OnSecondInstanceLaunch: app.onSecondInstanceLaunch,
+		},
+		Bind: []interface{}{
+			app,
+		},
+	})
+}
+```
+
+### Linux
+
+Currently, Wails doesn't support bundling for Linux. So, you need to create file associations manually.
+For example if you distribute your app as a .deb package, you can create file associations by adding required files in you bundle.
+You can use [nfpm](https://nfpm.goreleaser.com/) to create .deb package for your app.
+
+1.  Create a .desktop file for your app and specify file associations there (note that `%u` is important in Exec). Example:
+
+```ini
+[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;
+```
+
+2.  Prepare postInstall/postRemove scripts for your package. Example:
+
+```sh
+# reload desktop database to load app in list of available
+update-desktop-database /usr/share/applications
+```
+
+3.  Configure nfpm to use your scripts and files. Example:
+
+```yaml
+name: "wails-open-file"
+arch: "arm64"
+platform: "linux"
+version: "1.0.0"
+section: "default"
+priority: "extra"
+maintainer: "FooBarCorp <FooBarCorp@gmail.com>"
+description: "Sample Package"
+vendor: "FooBarCorp"
+homepage: "http://example.com"
+license: "MIT"
+contents:
+- src: ../bin/wails-open-file
+  dst: /usr/bin/wails-open-file
+- src: ./main.desktop
+  dst: /usr/share/applications/wails-open-file.desktop
+- src: ../appicon.svg
+  dst: /usr/share/icons/hicolor/scalable/apps/wails-open-file.svg
+# copy icons to Yaru theme as well. For some reason Ubuntu didn't pick up fileicons from hicolor theme
+- src: ../appicon.svg
+  dst: /usr/share/icons/Yaru/scalable/apps/wails-open-file.svg
+scripts:
+  postinstall: ./postInstall.sh
+  postremove: ./postRemove.sh
+```
+
+6.  Build your .deb package using nfpm:
+
+```sh
+nfpm pkg --packager deb --target .
+```
+
+7.  Now when your package is installed, your app will be associated with custom protocol scheme. When you open url with your app,
+    new instance of app is launched and file path is passed as argument to your app.
+    To handle this you should parse command line arguments in your app. Example:
+
+```go title="main.go"
+func main() {
+	argsWithoutProg := os.Args[1:]
+
+	if len(argsWithoutProg) != 0 {
+    println("launchArgs", argsWithoutProg)
+  }
+}
+```
+
+You also can enable single instance lock for your app. In this case, when you open url with your app, new instance of app is not launched
+and arguments are passed to already running instance. Check single instance lock guide for details. Example:
+
+```go title="main.go"
+func main() {
+	// Create application with options
+	err := wails.Run(&options.App{
+		Title:  "wails-open-file",
+		Width:  1024,
+		Height: 768,
+		AssetServer: &assetserver.Options{
+			Assets: assets,
+		},
+		BackgroundColour: &options.RGBA{R: 27, G: 38, B: 54, A: 1},
+		SingleInstanceLock: &options.SingleInstanceLock{
+			UniqueId:               "e3984e08-28dc-4e3d-b70a-45e961589cdc",
+			OnSecondInstanceLaunch: app.onSecondInstanceLaunch,
+		},
+		Bind: []interface{}{
+			app,
+		},
+	})
+}
+```

website/i18n/zh-Hans/docusaurus-plugin-content-docs/current/guides/file-association.mdx

@@ -89,6 +89,31 @@ func main() {
 }
 ```
 
+You also can enable single instance lock for your app. In this case, when you open file with your app, new instance of app is not launched
+and arguments are passed to already running instance. Check single instance lock guide for details. Example:
+
+```go title="main.go"
+func main() {
+	// Create application with options
+	err := wails.Run(&options.App{
+		Title:  "wails-open-file",
+		Width:  1024,
+		Height: 768,
+		AssetServer: &assetserver.Options{
+			Assets: assets,
+		},
+		BackgroundColour: &options.RGBA{R: 27, G: 38, B: 54, A: 1},
+		SingleInstanceLock: &options.SingleInstanceLock{
+			UniqueId:               "e3984e08-28dc-4e3d-b70a-45e961589cdc",
+			OnSecondInstanceLaunch: app.onSecondInstanceLaunch,
+		},
+		Bind: []interface{}{
+			app,
+		},
+	})
+}
+```
+
 ### Linux
 
 Currently, Wails doesn't support bundling for Linux. So, you need to create file associations manually.
@@ -193,7 +218,27 @@ func main() {
 }
 ```
 
-## Limitations:
+You also can enable single instance lock for your app. In this case, when you open file with your app, new instance of app is not launched
+and arguments are passed to already running instance. Check single instance lock guide for details. Example:
 
-On Windows and Linux when associated file is opened, new instance of your app is launched.
+```go title="main.go"
-Currently, Wails doesn't support opening files in already running app. There is plugin for single instance support for v3 in development.
+func main() {
+	// Create application with options
+	err := wails.Run(&options.App{
+		Title:  "wails-open-file",
+		Width:  1024,
+		Height: 768,
+		AssetServer: &assetserver.Options{
+			Assets: assets,
+		},
+		BackgroundColour: &options.RGBA{R: 27, G: 38, B: 54, A: 1},
+		SingleInstanceLock: &options.SingleInstanceLock{
+			UniqueId:               "e3984e08-28dc-4e3d-b70a-45e961589cdc",
+			OnSecondInstanceLaunch: app.onSecondInstanceLaunch,
+		},
+		Bind: []interface{}{
+			app,
+		},
+	})
+}
+```

website/i18n/zh-Hans/docusaurus-plugin-content-docs/current/guides/single-instance-lock.mdx

@@ -0,0 +1,81 @@
+# Single Instance Lock
+
+Single instance lock is a mechanism that allows you to prevent multiple instances of your app from running at the same time.
+It is useful for apps that are designed to open files from the command line or from the OS file explorer.
+
+## Important
+
+Single Instance Lock does not implement a secure communications protocol between instances. When using single instance lock,
+your app should treat any data passed to it from second instance callback as untrusted.
+You should verify that args that you receive are valid and don't contain any malicious data.
+
+## How it works
+
+Windows: Single instance lock is implemented using a named mutex. The mutex name is generated from the unique id that you provide. Data is passed to the first instance via a shared window using [SendMessage](https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-sendmessage)
+macOS: Single instance lock is implemented using a named mutex. The mutex name is generated from the unique id that you provide. Data is passed to the first instance via [NSDistributedNotificationCenter](https://developer.apple.com/documentation/foundation/nsdistributednotificationcenter)
+Linux: Single instance lock is implemented using [dbus](https://www.freedesktop.org/wiki/Software/dbus/). The dbus name is generated from the unique id that you provide. Data is passed to the first instance via [dbus](https://www.freedesktop.org/wiki/Software/dbus/)
+
+## Usage
+
+When creating your app, you can enable single instance lock by passing a `SingleInstanceLock` struct to the `App` struct.
+Use the `UniqueId` field to specify a unique id for your app.
+This id is used to generate the mutex name on Windows and macOS and the dbus name on Linux. Use a UUID to ensure that the id is unique.
+The `OnSecondInstanceLaunch` field is used to specify a callback that is called when a second instance of your app is launched.
+The callback receives a `SecondInstanceData` struct that contains the command line arguments passed to the second instance and the working directory of the second instance.
+
+Note that OnSecondInstanceLaunch don't trigger windows focus.
+You need to call `runtime.WindowUnminimise` and `runtime.Show` to bring your app to the front.
+Note that on linux systems window managers may prevent your app from being brought to the front to avoid stealing focus.
+
+```go title="main.go"
+var wailsContext *context.Context
+
+// NewApp creates a new App application struct
+func NewApp() *App {
+	return &App{}
+}
+
+// startup is called when the app starts. The context is saved
+// so we can call the runtime methods
+func (a *App) startup(ctx context.Context) {
+	wailsContext = &ctx
+}
+
+func (a *App) onSecondInstanceLaunch(secondInstanceData options.SecondInstanceData) {
+	secondInstanceArgs = secondInstanceData.Args
+
+	println("user opened second instance", strings.Join(secondInstanceData.Args, ","))
+	println("user opened second from", secondInstanceData.WorkingDirectory)
+	runtime.WindowUnminimise(*wailsContext)
+	runtime.Show(*wailsContext)
+	go runtime.EventsEmit(*wailsContext, "launchArgs", secondInstanceArgs)
+}
+
+func main() {
+	// Create an instance of the app structure
+	app := NewApp()
+
+	// Create application with options
+	err := wails.Run(&options.App{
+		Title:  "wails-open-file",
+		Width:  1024,
+		Height: 768,
+		AssetServer: &assetserver.Options{
+			Assets: assets,
+		},
+		BackgroundColour: &options.RGBA{R: 27, G: 38, B: 54, A: 1},
+		OnStartup:        app.startup,
+		SingleInstanceLock: &options.SingleInstanceLock{
+			UniqueId:               "e3984e08-28dc-4e3d-b70a-45e961589cdc",
+			OnSecondInstanceLaunch: app.onSecondInstanceLaunch,
+		},
+		Bind: []interface{}{
+			app,
+		},
+	})
+
+	if err != nil {
+		println("Error:", err.Error())
+	}
+}
+```

website/i18n/zh-Hans/docusaurus-plugin-content-docs/current/introduction.mdx

@@ -42,7 +42,7 @@ Wails 带有许多预配置的模板，可让您快速启动和运行应用程
 
 Wails 使用专门构建的库来处理窗口、菜单、对话框等原生元素，因此您可以构建美观、功能丰富的桌面应用程序。
 
-**它不嵌入浏览器**，因此性能高。 相反，它使用平台的原生渲染引擎。 在 Windows 上，是基于 Chromium 构建的新 Microsoft Webview2 库。
+**It does not embed a browser**, so it delivers a small runtime. Instead, it reuses the native rendering engine for the platform. 在 Windows 上，是基于 Chromium 构建的新 Microsoft Webview2 库。
 
 ### Go 和 JavaScript 互操作
 

website/i18n/zh-Hans/docusaurus-plugin-content-pages/changelog.mdx

@@ -15,6 +15,8 @@
 
 ### 新增
 
+- Update the description of `ZoomFactor` and `IsZoomControlEnabled` attributes in the document. Added by @biuaxia in [PR](https://github.com/wailsapp/wails/pull/3013)
+- Added Single Instance Lock support with passing arguments to first instance. Added by @APshenkin in [PR](https://github.com/wailsapp/wails/pull/2951)
 - Added support for enabling/disabling swipe gestures for Windows WebView2. Added by @leaanthony in [PR](https://github.com/wailsapp/wails/pull/2878)
 - When building with `-devtools` flag, CMD/CTRL+SHIFT+F12 can be used to open the devtools. Added by @leaanthony in [PR](https://github.com/wailsapp/wails/pull/2915) – Added file association support for macOS and Windows. Added by @APshenkin in [PR](https://github.com/wailsapp/wails/pull/2918)
 - Added support for setting some of the Webview preferences, `textInteractionEnabled` and `tabFocusesLinks` on Mac. Added by @fkhadra in [PR](https://github.com/wailsapp/wails/pull/2937)
@@ -23,6 +25,8 @@
 - New task created for linting v2 `task v2:lint`. Workflow updated to run the task. Added by @mikeee in [PR](https://github.com/wailsapp/wails/pull/2957)
 - Added new community template wails-htmx-templ-chi-tailwind. Added by [@pylotlight](https://github.com/pylotlight) in [PR](https://github.com/wailsapp/wails/pull/2984)
 - Added CPU/GPU/Memory detection for `wails doctor`. Added by @leaanthony in #d51268b8d0680430f3a614775b13e6cd2b906d1c
+- The [AssetServer](/docs/reference/options#assetserver) now injects the runtime/IPC into all index html files and into all html files returned when requesting a folder path. Added by @stffabi in [PR](https://github.com/wailsapp/wails/pull/2203)
+- Added Custom Protocol Schemes associations support for macOS and Windows. Added by @APshenkin in [PR](https://github.com/wailsapp/wails/pull/3000)
 
 ### 变更
 
@@ -30,10 +34,12 @@
 - AssetServer requests are now processed concurrently by spawning a goroutine per request. Changed by @stffabi in [PR](https://github.com/wailsapp/wails/pull/2926)
 - Now building with `-devtools` flag doesn't enable the default context-menu. Changed by @mmghv in [PR](https://github.com/wailsapp/wails/pull/2923)
 - Change Window Level. Changed by @almas1992 in [PR](https://github.com/wailsapp/wails/pull/2944)
+
 #### 修复
 
 - Fixed typo on docs/reference/options page. Added by [@pylotlight](https://github.com/pylotlight) in [PR](https://github.com/wailsapp/wails/pull/2887)
 - Fixed issue with npm being called npm20 on openSUSE-Tumbleweed. Fixed by @TuffenDuffen in [PR] in (https://github.com/wailsapp/wails/pull/2941)
+- Fixed memory corruption on Windows when using accelerator keys. Fixed by @stffabi in [PR] in (https://github.com/wailsapp/wails/pull/3002)
 
 ## v2.6.0 - 2023-09-06
 

website/i18n/zh-Hans/docusaurus-plugin-content-pages/credits.mdx

@@ -2,9 +2,9 @@
 
 - [Lea Anthony](https://github.com/leaanthony) - 项目所有者，首席开发人员
 - [Stffabi](https://github.com/stffabi) - 技术领导、 开发者和维护者
-- [Misite Bao](https://github.com/misitebao) - 文档向导，中文翻译，Windows 测试，常规 Bug 发现
 - [Travis McLane](https://github.com/tmclane) - 处理交叉编译相关工作, MacOS 平台的测试
 - [Lyimmi](https://github.com/Lyimmi) - Linux 的所有事物
+- [Simon Thomas](mailto:enquiries@wails.io) - Growth Hacker
 
 ## 赞助商
 <img src="/img/sponsors.svg" style={{"width":"85%","max-width":"800px;"}} />