snapshot of https://github.com/tauri-apps/plugins-workspace.git (v2, 2026-09-23; blobs > 131072B omitted)

2026-09-23 17:17:10 +05:00
commit 9ad64ec987
1469 changed files with 115067 additions and 0 deletions
--- a/plugins/single-instance/CHANGELOG.md
+++ b/plugins/single-instance/CHANGELOG.md
@@ -0,0 +1,268 @@
+# Changelog
+
+## [2.4.5]
+
+- [`67cd25a1`](https://github.com/tauri-apps/plugins-workspace/commit/67cd25a10ce3deb1b935e725228e528766f24ad7) ([#3592](https://github.com/tauri-apps/plugins-workspace/pull/3592)) On Windows, the second instance now allows the first instance to bring its window to the front before exiting, so focusing a window from the callback no longer gets refused by Windows.
+
+## [2.4.4]
+
+- [`f8053e65`](https://github.com/tauri-apps/plugins-workspace/commit/f8053e659e4ccd85c1f52833411ff8417cbc5e69) ([#3527](https://github.com/tauri-apps/plugins-workspace/pull/3527) by [@Legend-Master](https://github.com/tauri-apps/plugins-workspace/../../Legend-Master)) Documented Cargo feature flags in each plugin's crate-level documentation.
+
+### Dependencies
+
+- Upgraded to `deep-link@2.4.10`
+
+## \[2.4.3]
+
+- [`d1573877`](https://github.com/tauri-apps/plugins-workspace/commit/d1573877226e609461761aa538cd0ca4f24d22be) ([#3466](https://github.com/tauri-apps/plugins-workspace/pull/3466) by [@bajoca05](https://github.com/tauri-apps/plugins-workspace/../../bajoca05)) Fix blocked thread on the single-instance plugin for MacOS: replace standard `UnixListener` with `tokio::net::UnixListener`, so the task can yield.
+
+## \[2.4.2]
+
+### Dependencies
+
+- Upgraded to `deep-link@2.4.9`
+
+## \[2.4.1]
+
+### Dependencies
+
+- Upgraded to `deep-link@2.4.8`
+
+## \[2.4.0]
+
+### Dependencies
+
+- Upgraded to `deep-link@2.4.7`
+
+### fix
+
+- [`98e2c11e`](https://github.com/tauri-apps/plugins-workspace/commit/98e2c11eefc3ee562f1ed280efe7e8ea6ff0f3b0) ([#3194](https://github.com/tauri-apps/plugins-workspace/pull/3194) by [@mrquantumoff](https://github.com/tauri-apps/plugins-workspace/../../mrquantumoff)) **Breaking Change:** On Linux, the DBus ID/name will now be `<bundle-id>.SingleInstance` instead of `org.<bundle_id_underscores>.SingleInstance` to follow DBus specifications.
+
+  This will break the single-instance mechanism across different app versions if the app was installed multiple times.
+
+  Added `dbus_id` builder method, which can be used to restore previous behavior. For a bundle identifier of `com.tauri.my-example` this would be `dbus_id("org.com_tauri_my_example")`.
+
+## \[2.3.7]
+
+### Dependencies
+
+- Upgraded to `deep-link@2.4.6`
+
+## \[2.3.6]
+
+- [`93426f85`](https://github.com/tauri-apps/plugins-workspace/commit/93426f85120f49beb9f40222bff45185a32d54a9) Fixed an issue that caused docs.rs builds to fail. No user facing changes.
+
+### Dependencies
+
+- Upgraded to `deep-link@2.4.5`
+
+## \[2.3.5]
+
+### Dependencies
+
+- Upgraded to `deep-link@2.4.4`
+
+## \[2.3.4]
+
+### Dependencies
+
+- Upgraded to `deep-link@2.4.3`
+
+## \[2.3.3]
+
+### Dependencies
+
+- Upgraded to `deep-link@2.4.2`
+
+## \[2.3.2]
+
+### Dependencies
+
+- Upgraded to `deep-link@2.4.1`
+
+## \[2.3.1]
+
+- [`6f345870`](https://github.com/tauri-apps/plugins-workspace/commit/6f345870df4e7b187deb869df03b79858e03b4fe) ([#2860](https://github.com/tauri-apps/plugins-workspace/pull/2860) by [@MorpheusXAUT](https://github.com/tauri-apps/plugins-workspace/../../MorpheusXAUT)) Fix D-Bus name replacement logic on Linux to prevent multiple instances from acquiring the same well-known name.\
+  This patch updates the `zbus` dependency to the latest compatible version (`^5.9`) and explicitly sets `RequestNameFlags` to ensure a second instance fails to acquire the D-Bus name when another one is already running.
+
+## \[2.3.0]
+
+- [`f209b2f2`](https://github.com/tauri-apps/plugins-workspace/commit/f209b2f23cb29133c97ad5961fb46ef794dbe063) ([#2804](https://github.com/tauri-apps/plugins-workspace/pull/2804) by [@renovate](https://github.com/tauri-apps/plugins-workspace/../../renovate)) Updated tauri to 2.6
+
+### Dependencies
+
+- Upgraded to `deep-link@2.4.0`
+
+## \[2.2.4]
+
+- [`dc84f8d8`](https://github.com/tauri-apps/plugins-workspace/commit/dc84f8d8bbaa70de3bb3185fbacb472993b996ef) ([#2609](https://github.com/tauri-apps/plugins-workspace/pull/2609) by [@Simon-Laux](https://github.com/tauri-apps/plugins-workspace/../../Simon-Laux)) fix `cwd` in single instance on macOS, which was the cwd of the first instance, instead of the second (like it is on windows and linux)
+
+### Dependencies
+
+- Upgraded to `deep-link@2.3.0`
+
+## \[2.2.3]
+
+### Dependencies
+
+- Upgraded to `deep-link@2.2.1`
+
+## \[2.2.2]
+
+- [`1ab5f157`](https://github.com/tauri-apps/plugins-workspace/commit/1ab5f1576333174095bc7dad4bef7a8576bb29ab) ([#2452](https://github.com/tauri-apps/plugins-workspace/pull/2452) by [@FabianLars](https://github.com/tauri-apps/plugins-workspace/../../FabianLars)) Fixed `null pointer dereference` panic on rust nightly on Windows.
+
+## \[2.2.1]
+
+- [`da5c59e2`](https://github.com/tauri-apps/plugins-workspace/commit/da5c59e2fe879d177e3cfd52fcacce85440423cb) ([#2271](https://github.com/tauri-apps/plugins-workspace/pull/2271) by [@renovate](https://github.com/tauri-apps/plugins-workspace/../../renovate)) Updated `zbus` dependency to version 5. No API changes.
+
+## \[2.2.0]
+
+- [`3a79266b`](https://github.com/tauri-apps/plugins-workspace/commit/3a79266b8cf96a55b1ae6339d725567d45a44b1d) ([#2173](https://github.com/tauri-apps/plugins-workspace/pull/2173) by [@FabianLars](https://github.com/tauri-apps/plugins-workspace/../../FabianLars)) Bumped all plugins to `v2.2.0`. From now, the versions for the Rust and JavaScript packages of each plugin will be in sync with each other.
+
+### Dependencies
+
+- Upgraded to `deep-link@2.1.0`
+
+## \[2.0.2]
+
+### Dependencies
+
+- Upgraded to `deep-link@2.0.2`
+
+## \[2.0.1]
+
+- [`a1a82208`](https://github.com/tauri-apps/plugins-workspace/commit/a1a82208ed4ab87f83310be0dc95428aec9ab241) ([#1873](https://github.com/tauri-apps/plugins-workspace/pull/1873) by [@lucasfernog](https://github.com/tauri-apps/plugins-workspace/../../lucasfernog)) Downgrade MSRV to 1.77.2 to support Windows 7.
+
+### Dependencies
+
+- Upgraded to `deep-link@2.0.1`
+
+## \[2.0.0]
+
+- [`e2c4dfb6`](https://github.com/tauri-apps/plugins-workspace/commit/e2c4dfb6af43e5dd8d9ceba232c315f5febd55c1) Update to tauri v2 stable release.
+
+### Dependencies
+
+- Upgraded to `deep-link@2.0.0`
+
+## \[2.0.0-rc.5]
+
+### Dependencies
+
+- Upgraded to `deep-link@2.0.0-rc.7`
+
+## \[2.0.0-rc.4]
+
+### Dependencies
+
+- Upgraded to `deep-link@2.0.0-rc.6`
+
+## \[2.0.0-rc.3]
+
+- [`b2269333`](https://github.com/tauri-apps/plugins-workspace/commit/b2269333e39afe32629a11763a8e25d0b12b132b) ([#1766](https://github.com/tauri-apps/plugins-workspace/pull/1766) by [@Legend-Master](https://github.com/tauri-apps/plugins-workspace/../../Legend-Master)) Put deep link integration behined a feature
+
+### Dependencies
+
+- Upgraded to `deep-link@2.0.0-rc.5`
+
+## \[2.0.0-rc.2]
+
+- [`64a6240f`](https://github.com/tauri-apps/plugins-workspace/commit/64a6240f79fcd52267c8d721b727ae695055d7ff) ([#1759](https://github.com/tauri-apps/plugins-workspace/pull/1759) by [@lucasfernog](https://github.com/tauri-apps/plugins-workspace/../../lucasfernog)) Integrate with the deep link plugin out of the box.
+
+### Dependencies
+
+- Upgraded to `deep-link@2.0.0-rc.4`
+
+## \[2.0.0-rc.1]
+
+- [`3c52f30e`](https://github.com/tauri-apps/plugins-workspace/commit/3c52f30ea4ec29c51f7021aa7871614d72e43258) ([#1665](https://github.com/tauri-apps/plugins-workspace/pull/1665) by [@amrbashir](https://github.com/tauri-apps/plugins-workspace/../../amrbashir)) Updated `windows-sys` crate to `0.59`
+- [`e2e97db5`](https://github.com/tauri-apps/plugins-workspace/commit/e2e97db51983267f5be84d4f6f0278d58834d1f5) ([#1701](https://github.com/tauri-apps/plugins-workspace/pull/1701) by [@lucasfernog](https://github.com/tauri-apps/plugins-workspace/../../lucasfernog)) Update to tauri 2.0.0-rc.8
+
+## \[2.0.0-rc.0]
+
+- [`9887d1`](https://github.com/tauri-apps/plugins-workspace/commit/9887d14bd0e971c4c0f5c1188fc4005d3fc2e29e) Update to tauri RC.
+
+## \[2.0.0-beta.12]
+
+- [`e847cedc`](https://github.com/tauri-apps/plugins-workspace/commit/e847cedc1f46f3e7a2ad81ea579b620bc5b992d7) ([#1402](https://github.com/tauri-apps/plugins-workspace/pull/1402) by [@Legend-Master](https://github.com/tauri-apps/plugins-workspace/../../Legend-Master)) Use no default features on tauri for all plugins so that consumers can use `default-features = false` on tauri, note that this will still enable wry feature on iOS
+- [`6de87966`](https://github.com/tauri-apps/plugins-workspace/commit/6de87966ecc00ad9d91c25be452f1f46bd2b7e1f) ([#1597](https://github.com/tauri-apps/plugins-workspace/pull/1597) by [@Legend-Master](https://github.com/tauri-apps/plugins-workspace/../../Legend-Master)) Update to tauri beta.25.
+
+## \[2.0.0-beta.11]
+
+- [`22a17980`](https://github.com/tauri-apps/plugins-workspace/commit/22a17980ff4f6f8c40adb1b8f4ffc6dae2fe7e30) ([#1537](https://github.com/tauri-apps/plugins-workspace/pull/1537) by [@lucasfernog](https://github.com/tauri-apps/plugins-workspace/../../lucasfernog)) Update to tauri beta.24.
+
+## \[2.0.0-beta.10]
+
+- [`76daee7a`](https://github.com/tauri-apps/plugins-workspace/commit/76daee7aafece34de3092c86e531cf9eb1138989) ([#1512](https://github.com/tauri-apps/plugins-workspace/pull/1512) by [@renovate](https://github.com/tauri-apps/plugins-workspace/../../renovate)) Update to tauri beta.23.
+
+## \[2.0.0-beta.9]
+
+- [`9013854f`](https://github.com/tauri-apps/plugins-workspace/commit/9013854f42a49a230b9dbb9d02774765528a923f)([#1382](https://github.com/tauri-apps/plugins-workspace/pull/1382)) Update to tauri beta.22.
+
+## \[2.0.0-beta.8]
+
+- [`430bd6f4`](https://github.com/tauri-apps/plugins-workspace/commit/430bd6f4f379bee5d232ae6b098ae131db7f178a)([#1363](https://github.com/tauri-apps/plugins-workspace/pull/1363)) Update to tauri beta.20.
+
+## \[2.0.0-beta.7]
+
+- [`bd1ed590`](https://github.com/tauri-apps/plugins-workspace/commit/bd1ed5903ffcce5500310dac1e59e8c67674ef1e)([#1237](https://github.com/tauri-apps/plugins-workspace/pull/1237)) Update to tauri beta.17.
+
+## \[2.0.0-beta.6]
+
+- [`ed46dca`](https://github.com/tauri-apps/plugins-workspace/commit/ed46dca74ff3947dbbcb26a7b571c129bf925698) Added the `semver` feature flag to make the single instance mechanism only trigger for semver compatible versions.
+
+## \[2.0.0-beta.5]
+
+- [`dabac0e`](https://github.com/tauri-apps/plugins-workspace/commit/dabac0eedfd6e6d192c6c5a214e708b3c0223f6f)([#1035](https://github.com/tauri-apps/plugins-workspace/pull/1035)) Added implementation for MacOS.
+
+## \[2.0.0-beta.4]
+
+- [`a04ea2f`](https://github.com/tauri-apps/plugins-workspace/commit/a04ea2f38294d5a3987578283badc8eec87a7752)([#1071](https://github.com/tauri-apps/plugins-workspace/pull/1071)) The global API script is now only added to the binary when the `withGlobalTauri` config is true.
+
+## \[2.0.0-beta.3]
+
+- [`2397ec5`](https://github.com/tauri-apps/plugins-workspace/commit/2397ec5937e594397e533925ccd257cae30b4cd1)([#1019](https://github.com/tauri-apps/plugins-workspace/pull/1019)) Fix doesn't shutdown immediately.
+- [`99bea25`](https://github.com/tauri-apps/plugins-workspace/commit/99bea2559c2c0648c2519c50a18cd124dacef57b)([#1005](https://github.com/tauri-apps/plugins-workspace/pull/1005)) Update to tauri beta.8.
+
+## \[2.0.0-beta.2]
+
+- [`6d1e621`](https://github.com/tauri-apps/plugins-workspace/commit/6d1e6218b5877ef91f589f790f7251acda9c9605)([#981](https://github.com/tauri-apps/plugins-workspace/pull/981)) Fix `zbus::blocking::connection::Builder` import.
+
+## \[2.0.0-beta.1]
+
+- [`14f381a`](https://github.com/tauri-apps/plugins-workspace/commit/14f381acf8fe690acecc676922c6f05939b95734) Update MSRV to 1.75.
+- [`569defb`](https://github.com/tauri-apps/plugins-workspace/commit/569defbe9492e38938554bb7bdc1be9151456d21) Update to tauri beta.4.
+
+## \[2.0.0-beta.0]
+
+- [`d198c01`](https://github.com/tauri-apps/plugins-workspace/commit/d198c014863ee260cb0de88a14b7fc4356ef7474)([#862](https://github.com/tauri-apps/plugins-workspace/pull/862)) Update to tauri beta.
+- [`d198c01`](https://github.com/tauri-apps/plugins-workspace/commit/d198c014863ee260cb0de88a14b7fc4356ef7474)([#862](https://github.com/tauri-apps/plugins-workspace/pull/862)) Add permissions.
+
+## \[2.0.0-alpha.6]
+
+- [`2cf8faa`](https://github.com/tauri-apps/plugins-workspace/commit/2cf8faa3e149af55eb86e5aba8ebfc54210ca703)([#839](https://github.com/tauri-apps/plugins-workspace/pull/839)) Update to tauri@alpha.20.
+
+## \[2.0.0-alpha.5]
+
+- [`387c2f9`](https://github.com/tauri-apps/plugins-workspace/commit/387c2f9e0ce4c75c07ffa3fd76391a25b58f5daf)([#802](https://github.com/tauri-apps/plugins-workspace/pull/802)) Update to tauri@alpha.18.
+
+## \[2.0.0-alpha.4]
+
+- [`e438e0a`](https://github.com/tauri-apps/plugins-workspace/commit/e438e0a62d4b430a5159f05f13ecd397dd891a0d)([#676](https://github.com/tauri-apps/plugins-workspace/pull/676)) Update to tauri@alpha.17.
+
+## \[2.0.0-alpha.3]
+
+- [`5c13736`](https://github.com/tauri-apps/plugins-workspace/commit/5c137365c60790e8d4037d449e8237aa3fffdab0)([#673](https://github.com/tauri-apps/plugins-workspace/pull/673)) Update MSRV to 1.75.
+
+## \[2.0.0-alpha.2]
+
+- [`4e2cef9`](https://github.com/tauri-apps/plugins-workspace/commit/4e2cef9b702bbbb9cf4ee17de50791cb21f1b2a4)([#593](https://github.com/tauri-apps/plugins-workspace/pull/593)) Update to alpha.12.
+
+## \[2.0.0-alpha.1]
+
+- [`d5a7c77`](https://github.com/tauri-apps/plugins-workspace/commit/d5a7c77a8d0e7912a6b07b22ed329004edd6e80b)([#545](https://github.com/tauri-apps/plugins-workspace/pull/545)) Fixes docs.rs build by enabling the `tauri/dox` feature flag.
+- [`d74fc0a`](https://github.com/tauri-apps/plugins-workspace/commit/d74fc0a097996e90a37be8f57d50b7d1f6ca616f)([#555](https://github.com/tauri-apps/plugins-workspace/pull/555)) Update to alpha.11.
+
+## \[2.0.0-alpha.0]
+
+- [`717ae67`](https://github.com/tauri-apps/plugins-workspace/commit/717ae670978feb4492fac1f295998b93f2b9347f)([#371](https://github.com/tauri-apps/plugins-workspace/pull/371)) First v2 alpha release!
--- a/plugins/single-instance/Cargo.toml
+++ b/plugins/single-instance/Cargo.toml
@@ -0,0 +1,46 @@
+[package]
+name = "tauri-plugin-single-instance"
+version = "2.4.5"
+description = "Ensure a single instance of your tauri app is running."
+authors = { workspace = true }
+license = { workspace = true }
+edition = { workspace = true }
+rust-version = { workspace = true }
+repository = { workspace = true }
+exclude = ["/banner.png", "/examples"]
+
+[package.metadata.platforms.support]
+windows = { level = "full", notes = "" }
+linux = { level = "full", notes = "" }
+macos = { level = "full", notes = "" }
+android = { level = "none", notes = "" }
+ios = { level = "none", notes = "" }
+
+[dependencies]
+serde = { workspace = true }
+serde_json = { workspace = true }
+tauri = { workspace = true }
+tracing = { workspace = true }
+thiserror = { workspace = true }
+tauri-plugin-deep-link = { path = "../deep-link", version = "2.4.10", optional = true }
+semver = { version = "1", optional = true }
+tokio = { version = "1", features = ["net"] }
+
+[target."cfg(target_os = \"windows\")".dependencies.windows-sys]
+version = "0.60"
+features = [
+  "Win32_System_Threading",
+  "Win32_System_DataExchange",
+  "Win32_Foundation",
+  "Win32_UI_WindowsAndMessaging",
+  "Win32_Security",
+  "Win32_System_LibraryLoader",
+  "Win32_Graphics_Gdi",
+]
+
+[target."cfg(target_os = \"linux\")".dependencies]
+zbus = { workspace = true }
+
+[features]
+semver = ["dep:semver"]
+deep-link = ["dep:tauri-plugin-deep-link"]
--- a/plugins/single-instance/LICENSE.spdx
+++ b/plugins/single-instance/LICENSE.spdx
@@ -0,0 +1,20 @@
+SPDXVersion: SPDX-2.1
+DataLicense: CC0-1.0
+PackageName: tauri
+DataFormat: SPDXRef-1
+PackageSupplier: Organization: The Tauri Programme in the Commons Conservancy
+PackageHomePage: https://tauri.app
+PackageLicenseDeclared: Apache-2.0
+PackageLicenseDeclared: MIT
+PackageCopyrightText: 2019-2022, The Tauri Programme in the Commons Conservancy
+PackageSummary: <text>Tauri is a rust project that enables developers to make secure
+and small desktop applications using a web frontend.
+                </text>
+PackageComment: <text>The package includes the following libraries; see
+Relationship information.
+                </text>
+Created: 2019-05-20T09:00:00Z
+PackageDownloadLocation: git://github.com/tauri-apps/tauri
+PackageDownloadLocation: git+https://github.com/tauri-apps/tauri.git
+PackageDownloadLocation: git+ssh://github.com/tauri-apps/tauri.git
+Creator: Person: Daniel Thompson-Yvetot
--- a/plugins/single-instance/LICENSE_APACHE-2.0
+++ b/plugins/single-instance/LICENSE_APACHE-2.0
@@ -0,0 +1,177 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
--- a/plugins/single-instance/LICENSE_MIT
+++ b/plugins/single-instance/LICENSE_MIT
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 - Present The Tauri Programme in the Commons Conservancy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
--- a/plugins/single-instance/README.md
+++ b/plugins/single-instance/README.md
@@ -0,0 +1,90 @@
+![tauri-plugin-single-instance](https://github.com/tauri-apps/plugins-workspace/raw/v2/plugins/single-instance/banner.png)
+
+Ensure a single instance of your tauri app is running.
+
+| Platform | Supported |
+| -------- | --------- |
+| Linux    | ✓         |
+| Windows  | ✓         |
+| macOS    | ✓         |
+| Android  | x         |
+| iOS      | x         |
+
+## Install
+
+_This plugin requires a Rust version of at least **1.77.2**_
+
+There are three general methods of installation that we can recommend.
+
+1. Use crates.io and npm (easiest, and requires you to trust that our publishing pipeline worked)
+2. Pull sources directly from Github using git tags / revision hashes (most secure)
+3. Git submodule install this repo in your tauri project and then use file protocol to ingest the source (most secure, but inconvenient to use)
+
+Install the Core plugin by adding the following to your `Cargo.toml` file:
+
+`src-tauri/Cargo.toml`
+
+```toml
+[dependencies]
+tauri-plugin-single-instance = "2.0.0"
+# alternatively with Git:
+tauri-plugin-single-instance = { git = "https://github.com/tauri-apps/plugins-workspace", branch = "v2" }
+```
+
+## Usage
+
+First you need to register the core plugin with Tauri:
+
+`src-tauri/src/lib.rs`
+
+```rust
+use tauri::{Manager};
+
+#[derive(Clone, serde::Serialize)]
+struct Payload {
+    args: Vec<String>,
+    cwd: String,
+}
+
+fn main() {
+    tauri::Builder::default()
+        .plugin(tauri_plugin_single_instance::init(|app, argv, cwd| {
+            println!("{}, {argv:?}, {cwd}", app.package_info().name);
+            app.emit("single-instance", Payload { args: argv, cwd }).unwrap();
+        }))
+        .run(tauri::generate_context!())
+        .expect("error while running tauri application");
+}
+```
+
+Note that currently, plugins run in the order they were added in to the builder, so make sure that this plugin is registered first.
+
+## Usage with Flatpak/Snap
+
+If you use Flatpak/Snap to publish your package and your Tauri identifier doesn't match the package id, set the `DBUS_ID` variable using the builder for the plugin, look at example.
+
+## Contributing
+
+PRs accepted. Please make sure to read the Contributing Guide before making a pull request.
+
+## Partners
+
+<table>
+  <tbody>
+    <tr>
+      <td align="center" valign="middle">
+        <a href="https://crabnebula.dev" target="_blank">
+          <img src="https://github.com/tauri-apps/plugins-workspace/raw/v2/.github/sponsors/crabnebula.svg" alt="CrabNebula" width="283">
+        </a>
+      </td>
+    </tr>
+  </tbody>
+</table>
+
+For the complete list of sponsors please visit our [website](https://tauri.app#sponsors) and [Open Collective](https://opencollective.com/tauri).
+
+## License
+
+Code: (c) 2015 - Present - The Tauri Programme within The Commons Conservancy.
+
+MIT or MIT/Apache 2.0 where applicable.
--- a/plugins/single-instance/SECURITY.md
+++ b/plugins/single-instance/SECURITY.md
@@ -0,0 +1,23 @@
+# Security Policy
+
+**Do not report security vulnerabilities through public GitHub issues.**
+
+**Please use the [Private Vulnerability Disclosure](https://docs.github.com/en/code-security/security-advisories/guidance-on-reporting-and-writing-information-about-vulnerabilities/privately-reporting-a-security-vulnerability#privately-reporting-a-security-vulnerability) feature of GitHub.**
+
+Include as much of the following information:
+
+- Type of issue (e.g. improper input parsing, privilege escalation, etc.)
+- The location of the affected source code (tag/branch/commit or direct URL)
+- Any special configuration required to reproduce the issue
+- The distribution affected or used to help us with reproduction of the issue
+- Step-by-step instructions to reproduce the issue
+- Ideally a reproduction repository
+- Impact of the issue, including how an attacker might exploit the issue
+
+We prefer to receive reports in English.
+
+## Contact
+
+Please disclose a vulnerability or security relevant issue here: [https://github.com/tauri-apps/plugins-workspace/security/advisories/new](https://github.com/tauri-apps/plugins-workspace/security/advisories/new).
+
+Alternatively, you can also contact us by email via [security@tauri.app](mailto:security@tauri.app).
--- a/plugins/single-instance/banner.png
+++ b/plugins/single-instance/banner.png
--- a/plugins/single-instance/examples/vanilla/.gitignore
+++ b/plugins/single-instance/examples/vanilla/.gitignore
@@ -0,0 +1,3 @@
+node_modules/
+dist/**
+!dist/.gitkeep
--- a/plugins/single-instance/examples/vanilla/package.json
+++ b/plugins/single-instance/examples/vanilla/package.json
@@ -0,0 +1,14 @@
+{
+  "name": "app",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "tauri": "tauri"
+  },
+  "author": "",
+  "license": "MIT",
+  "devDependencies": {
+    "@tauri-apps/cli": "2.11.4"
+  }
+}
--- a/plugins/single-instance/examples/vanilla/public/index.html
+++ b/plugins/single-instance/examples/vanilla/public/index.html
@@ -0,0 +1,5 @@
+<html>
+  <body>
+    <div>Plugin example</div>
+  </body>
+</html>
--- a/plugins/single-instance/examples/vanilla/src-tauri/.gitignore
+++ b/plugins/single-instance/examples/vanilla/src-tauri/.gitignore
@@ -0,0 +1,6 @@
+# Generated by Cargo
+# will have compiled files and executables
+/target/
+WixTools
+
+/gen/schemas
--- a/plugins/single-instance/examples/vanilla/src-tauri/Cargo.toml
+++ b/plugins/single-instance/examples/vanilla/src-tauri/Cargo.toml
@@ -0,0 +1,18 @@
+[package]
+name = "single-instance-example"
+version = "0.1.0"
+description = "A Tauri App"
+authors = ["You"]
+repository = ""
+edition = "2021"
+rust-version = "1.77.2"
+
+[dependencies]
+serde = { workspace = true }
+serde_json = { workspace = true }
+tauri = { workspace = true, features = ["wry", "common-controls-v6", "x11"] }
+tauri-plugin-single-instance = { path = "../../../" }
+tauri-plugin-cli = { path = "../../../../cli" }
+
+[build-dependencies]
+tauri-build = { workspace = true }
--- a/plugins/single-instance/examples/vanilla/src-tauri/build.rs
+++ b/plugins/single-instance/examples/vanilla/src-tauri/build.rs
@@ -0,0 +1,7 @@
+// Copyright 2019-2023 Tauri Programme within The Commons Conservancy
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: MIT
+
+fn main() {
+    tauri_build::build()
+}
--- a/plugins/single-instance/examples/vanilla/src-tauri/icons/128x128.png
+++ b/plugins/single-instance/examples/vanilla/src-tauri/icons/128x128.png
--- a/plugins/single-instance/examples/vanilla/src-tauri/icons/128x128@2x.png
+++ b/plugins/single-instance/examples/vanilla/src-tauri/icons/128x128@2x.png
--- a/plugins/single-instance/examples/vanilla/src-tauri/icons/32x32.png
+++ b/plugins/single-instance/examples/vanilla/src-tauri/icons/32x32.png
--- a/plugins/single-instance/examples/vanilla/src-tauri/icons/icon.ico
+++ b/plugins/single-instance/examples/vanilla/src-tauri/icons/icon.ico
--- a/plugins/single-instance/examples/vanilla/src-tauri/icons/icon.png
+++ b/plugins/single-instance/examples/vanilla/src-tauri/icons/icon.png
--- a/plugins/single-instance/examples/vanilla/src-tauri/src/main.rs
+++ b/plugins/single-instance/examples/vanilla/src-tauri/src/main.rs
@@ -0,0 +1,22 @@
+// Copyright 2019-2023 Tauri Programme within The Commons Conservancy
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: MIT
+
+#![cfg_attr(
+    all(not(debug_assertions), target_os = "windows"),
+    windows_subsystem = "windows"
+)]
+
+fn main() {
+    tauri::Builder::default()
+        .plugin(
+            tauri_plugin_single_instance::Builder::new()
+                .callback(move |app, argv, cwd| {
+                    println!("{}, {argv:?}, {cwd}", app.package_info().name);
+                })
+                .dbus_id("org.Tauri.SIExampleApp".to_owned())
+                .build(),
+        )
+        .run(tauri::generate_context!())
+        .expect("error while running tauri application");
+}
--- a/plugins/single-instance/examples/vanilla/src-tauri/tauri.conf.json
+++ b/plugins/single-instance/examples/vanilla/src-tauri/tauri.conf.json
@@ -0,0 +1,45 @@
+{
+  "productName": "app",
+  "version": "0.1.0",
+  "identifier": "com.tauri.single-instance",
+  "build": {
+    "frontendDist": "../public"
+  },
+  "app": {
+    "windows": [
+      {
+        "title": "app",
+        "width": 800,
+        "height": 600,
+        "resizable": true,
+        "fullscreen": false
+      }
+    ],
+    "security": {
+      "csp": "default-src blob: data: filesystem: ws: wss: http: https: tauri: http://tauri.localhost 'unsafe-eval' 'unsafe-inline' 'self' img-src: 'self'"
+    }
+  },
+  "bundle": {
+    "active": true,
+    "targets": "all",
+    "icon": [
+      "icons/32x32.png",
+      "icons/128x128.png",
+      "icons/128x128@2x.png",
+      "icons/icon.icns",
+      "icons/icon.ico"
+    ]
+  },
+  "plugins": {
+    "cli": {
+      "description": "Testing single-instance on MacOS",
+      "args": [
+        {
+          "name": "somearg",
+          "index": 1,
+          "takesValue": true
+        }
+      ]
+    }
+  }
+}
--- a/plugins/single-instance/src/lib.rs
+++ b/plugins/single-instance/src/lib.rs
@@ -0,0 +1,134 @@
+// Copyright 2019-2023 Tauri Programme within The Commons Conservancy
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: MIT
+
+//! Ensure a single instance of your tauri app is running.
+//!
+//! ## Cargo features
+//!
+//! - **semver**: Allows the app with SemVer incompatible versions to run alongside each other.
+//! - **deep-link**: Trigger [`tauri-plugin-deep-link`](https://crates.io/crates/tauri-plugin-deep-link) event before invoking the single-instance callback.
+
+#![doc(
+    html_logo_url = "https://github.com/tauri-apps/tauri/raw/dev/app-icon.png",
+    html_favicon_url = "https://github.com/tauri-apps/tauri/raw/dev/app-icon.png"
+)]
+#![cfg(not(any(target_os = "android", target_os = "ios")))]
+
+use tauri::{plugin::TauriPlugin, AppHandle, Manager, Runtime};
+
+#[cfg(target_os = "windows")]
+#[path = "platform_impl/windows.rs"]
+mod platform_impl;
+#[cfg(target_os = "linux")]
+#[path = "platform_impl/linux.rs"]
+mod platform_impl;
+#[cfg(target_os = "macos")]
+#[path = "platform_impl/macos.rs"]
+mod platform_impl;
+
+#[cfg(feature = "semver")]
+mod semver_compat;
+
+pub(crate) type SingleInstanceCallback<R> =
+    dyn FnMut(&AppHandle<R>, Vec<String>, String) + Send + Sync + 'static;
+
+/// Initializes the plugin, calling `f` whenever a second instance of the app is started.
+///
+/// This is a shortcut for [`Builder::new`] with [`Builder::callback`] set to `f`, then
+/// [`Builder::build`]. Use [`Builder`] directly if you need to set a custom [`Builder::dbus_id`].
+///
+/// `f` is called with the app handle, the second instance's command line arguments
+/// (as collected by [`std::env::args`], so the first element is the executable path) and its
+/// current working directory. If the `deep-link` feature is enabled, the arguments are first
+/// forwarded to [`tauri-plugin-deep-link`](https://crates.io/crates/tauri-plugin-deep-link)
+/// before `f` runs.
+///
+/// The second instance never reaches [`tauri::Builder::run`]: it hands its arguments and working
+/// directory off to the first instance and exits immediately.
+pub fn init<R: Runtime, F: FnMut(&AppHandle<R>, Vec<String>, String) + Send + Sync + 'static>(
+    f: F,
+) -> TauriPlugin<R> {
+    Builder::new().callback(f).build()
+}
+
+/// Releases the resources this plugin uses to detect other instances (the named mutex on
+/// Windows, the D-Bus name on Linux or the Unix socket on macOS).
+///
+/// The plugin calls this automatically on [`tauri::RunEvent::Exit`], so you normally don't need
+/// to call it yourself. Call it manually before terminating the process through means that skip
+/// that event, such as [`std::process::exit`], so a future instance of the app isn't mistaken
+/// for a still-running one.
+pub fn destroy<R: Runtime, M: Manager<R>>(manager: &M) {
+    platform_impl::destroy(manager)
+}
+
+/// Builds the single-instance plugin.
+///
+/// Created with [`Builder::new`] and consumed by [`Builder::build`].
+pub struct Builder<R: Runtime> {
+    callback: Box<SingleInstanceCallback<R>>,
+    dbus_id: Option<String>,
+}
+
+impl<R: Runtime> Default for Builder<R> {
+    fn default() -> Self {
+        Self {
+            callback: Box::new(move |_app, _args, _| {
+                #[cfg(feature = "deep-link")]
+                if let Some(deep_link) = _app.try_state::<tauri_plugin_deep_link::DeepLink<R>>() {
+                    deep_link.handle_cli_arguments(_args.iter());
+                }
+            }),
+            dbus_id: None,
+        }
+    }
+}
+
+impl<R: Runtime> Builder<R> {
+    /// Creates a new builder with a no-op callback (or, when the `deep-link` feature is enabled,
+    /// a callback that only forwards the arguments to the deep-link plugin) and no custom D-Bus
+    /// ID. Use [`Builder::callback`] and [`Builder::dbus_id`] to configure it, then
+    /// [`Builder::build`] to create the plugin.
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    /// Function to call when a secondary instance was opened by the user and killed by the plugin.
+    /// If the `deep-link` feature is enabled, the plugin triggers the deep-link plugin before executing the callback.
+    pub fn callback<F: FnMut(&AppHandle<R>, Vec<String>, String) + Send + Sync + 'static>(
+        mut self,
+        mut f: F,
+    ) -> Self {
+        self.callback = Box::new(move |app, args, cwd| {
+            #[cfg(feature = "deep-link")]
+            if let Some(deep_link) = app.try_state::<tauri_plugin_deep_link::DeepLink<R>>() {
+                deep_link.handle_cli_arguments(args.iter());
+            }
+            f(app, args, cwd)
+        });
+        self
+    }
+
+    /// Set a custom D-Bus ID, used on Linux. The plugin will append a `.SingleInstance` subname.
+    /// For example `com.mycompany.myapp` will result in the plugin registering its D-Bus service on `com.mycompany.myapp.SingleInstance`.
+    /// Usually you want the same base ID across all components in your app.
+    ///
+    /// Defaults to the app's bundle identifier set in tauri.conf.json.
+    pub fn dbus_id(mut self, dbus_id: impl Into<String>) -> Self {
+        self.dbus_id = Some(dbus_id.into());
+        self
+    }
+
+    /// Builds the single-instance [`TauriPlugin`].
+    ///
+    /// Register it first among your app's plugins, since the plugins run in the order they were
+    /// added and a second instance must be detected before the rest of your setup runs.
+    pub fn build(self) -> TauriPlugin<R> {
+        platform_impl::init(
+            self.callback,
+            #[cfg(target_os = "linux")]
+            self.dbus_id,
+        )
+    }
+}
--- a/plugins/single-instance/src/platform_impl/linux.rs
+++ b/plugins/single-instance/src/platform_impl/linux.rs
@@ -0,0 +1,112 @@
+// Copyright 2019-2023 Tauri Programme within The Commons Conservancy
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: MIT
+
+#[cfg(feature = "semver")]
+use crate::semver_compat::semver_compat_string;
+
+use crate::SingleInstanceCallback;
+use tauri::{
+    plugin::{self, TauriPlugin},
+    AppHandle, Manager, RunEvent, Runtime,
+};
+use zbus::{blocking::Connection, interface, names::WellKnownName};
+
+struct ConnectionHandle(Connection);
+
+struct SingleInstanceDBus<R: Runtime> {
+    callback: Box<SingleInstanceCallback<R>>,
+    app_handle: AppHandle<R>,
+}
+
+#[interface(name = "org.SingleInstance.DBus")]
+impl<R: Runtime> SingleInstanceDBus<R> {
+    fn execute_callback(&mut self, argv: Vec<String>, cwd: String) {
+        (self.callback)(&self.app_handle, argv, cwd);
+    }
+}
+
+struct DBusName(String);
+
+pub fn init<R: Runtime>(
+    callback: Box<SingleInstanceCallback<R>>,
+    dbus_id: Option<String>,
+) -> TauriPlugin<R> {
+    plugin::Builder::new("single-instance")
+        .setup(move |app, _api| {
+            let mut dbus_name = dbus_id.unwrap_or_else(|| app.config().identifier.clone());
+            dbus_name.push_str(".SingleInstance");
+
+            #[cfg(feature = "semver")]
+            {
+                dbus_name.push('_');
+                dbus_name.push_str(semver_compat_string(&app.package_info().version).as_str());
+            }
+
+            let mut dbus_path = dbus_name.replace('.', "/").replace('-', "_");
+            if !dbus_path.starts_with('/') {
+                dbus_path = format!("/{dbus_path}");
+            }
+
+            let single_instance_dbus = SingleInstanceDBus {
+                callback,
+                app_handle: app.clone(),
+            };
+
+            match zbus::blocking::connection::Builder::session()
+                .unwrap()
+                .name(dbus_name.as_str())
+                .unwrap()
+                .replace_existing_names(false)
+                .allow_name_replacements(false)
+                .serve_at(dbus_path.as_str(), single_instance_dbus)
+                .unwrap()
+                .build()
+            {
+                Ok(connection) => {
+                    app.manage(ConnectionHandle(connection));
+                }
+                Err(zbus::Error::NameTaken) => {
+                    if let Ok(connection) = Connection::session() {
+                        let _ = connection.call_method(
+                            Some(dbus_name.as_str()),
+                            dbus_path.as_str(),
+                            Some("org.SingleInstance.DBus"),
+                            "ExecuteCallback",
+                            &(
+                                std::env::args().collect::<Vec<String>>(),
+                                std::env::current_dir()
+                                    .unwrap_or_default()
+                                    .to_str()
+                                    .unwrap_or_default(),
+                            ),
+                        );
+                    }
+                    app.cleanup_before_exit();
+                    std::process::exit(0);
+                }
+                _ => {}
+            }
+
+            app.manage(DBusName(dbus_name));
+
+            Ok(())
+        })
+        .on_event(move |app, event| {
+            if let RunEvent::Exit = event {
+                destroy(app);
+            }
+        })
+        .build()
+}
+
+pub fn destroy<R: Runtime, M: Manager<R>>(manager: &M) {
+    if let Some(connection) = manager.try_state::<ConnectionHandle>() {
+        if let Some(dbus_name) = manager
+            .try_state::<DBusName>()
+            .and_then(|name| WellKnownName::try_from(name.0.clone()).ok())
+        {
+            let _ = connection.0.release_name(dbus_name);
+        }
+    }
+}
--- a/plugins/single-instance/src/platform_impl/macos.rs
+++ b/plugins/single-instance/src/platform_impl/macos.rs
@@ -0,0 +1,132 @@
+// Copyright 2019-2023 Tauri Programme within The Commons Conservancy
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: MIT
+
+use std::{
+    io::{BufWriter, Error, ErrorKind, Write},
+    os::unix::net::UnixStream,
+    path::PathBuf,
+};
+
+#[cfg(feature = "semver")]
+use crate::semver_compat::semver_compat_string;
+use crate::SingleInstanceCallback;
+use tauri::{
+    plugin::{self, TauriPlugin},
+    AppHandle, Config, Manager, RunEvent, Runtime,
+};
+use tokio::io::AsyncReadExt;
+
+pub fn init<R: Runtime>(cb: Box<SingleInstanceCallback<R>>) -> TauriPlugin<R> {
+    plugin::Builder::new("single-instance")
+        .setup(|app, _api| {
+            let socket = socket_path(app.config(), app.package_info());
+
+            // Notify the singleton which may or may not exist.
+            match notify_singleton(&socket) {
+                Ok(_) => {
+                    std::process::exit(0);
+                }
+                Err(e) => {
+                    match e.kind() {
+                        ErrorKind::NotFound | ErrorKind::ConnectionRefused => {
+                            // This process claims itself as singleton as likely none exists
+                            socket_cleanup(&socket);
+                            listen_for_other_instances(socket, app.clone(), cb);
+                        }
+                        _ => {
+                            tracing::debug!(
+                                "single_instance failed to notify - launching normally: {}",
+                                e
+                            );
+                        }
+                    }
+                }
+            }
+            Ok(())
+        })
+        .on_event(|app, event| {
+            if let RunEvent::Exit = event {
+                destroy(app);
+            }
+        })
+        .build()
+}
+
+pub fn destroy<R: Runtime, M: Manager<R>>(manager: &M) {
+    let socket = socket_path(manager.config(), manager.package_info());
+    socket_cleanup(&socket);
+}
+
+fn socket_path(config: &Config, _package_info: &tauri::PackageInfo) -> PathBuf {
+    let identifier = config.identifier.replace(['.', '-'].as_ref(), "_");
+
+    #[cfg(feature = "semver")]
+    let identifier = format!(
+        "{identifier}_{}",
+        semver_compat_string(&_package_info.version),
+    );
+
+    // Use /tmp as socket path must be shorter than 100 chars.
+    PathBuf::from(format!("/tmp/{}_si.sock", identifier))
+}
+
+fn socket_cleanup(socket: &PathBuf) {
+    let _ = std::fs::remove_file(socket);
+}
+
+fn notify_singleton(socket: &PathBuf) -> Result<(), Error> {
+    let stream = UnixStream::connect(socket)?;
+    let mut bf = BufWriter::new(&stream);
+    let cwd = std::env::current_dir()
+        .unwrap_or_default()
+        .to_str()
+        .unwrap_or_default()
+        .to_string();
+    bf.write_all(cwd.as_bytes())?;
+    bf.write_all(b"\0\0")?;
+    let args_joined = std::env::args().collect::<Vec<String>>().join("\0");
+    bf.write_all(args_joined.as_bytes())?;
+    bf.flush()?;
+    drop(bf);
+    Ok(())
+}
+
+fn listen_for_other_instances<A: Runtime>(
+    socket: PathBuf,
+    app: AppHandle<A>,
+    mut cb: Box<SingleInstanceCallback<A>>,
+) {
+    tauri::async_runtime::spawn(async move {
+        match tokio::net::UnixListener::bind(socket) {
+            Ok(listener) => loop {
+                match listener.accept().await {
+                    Ok((mut stream, _addr)) => {
+                        let mut s = String::new();
+                        match stream.read_to_string(&mut s).await {
+                            Ok(_) => {
+                                let (cwd, args) = s.split_once("\0\0").unwrap_or_default();
+                                let args: Vec<String> =
+                                    args.split('\0').map(String::from).collect();
+                                cb(app.app_handle(), args, cwd.to_string());
+                            }
+                            Err(e) => {
+                                tracing::debug!("single_instance failed to be notified: {e}")
+                            }
+                        }
+                    }
+                    Err(err) => {
+                        tracing::debug!("single_instance failed to be notified: {}", err);
+                        continue;
+                    }
+                }
+            },
+            Err(err) => {
+                tracing::error!(
+                    "single_instance failed to listen to other processes - launching normally: {}",
+                    err
+                );
+            }
+        }
+    });
+}
--- a/plugins/single-instance/src/platform_impl/windows.rs
+++ b/plugins/single-instance/src/platform_impl/windows.rs
@@ -0,0 +1,267 @@
+// Copyright 2019-2023 Tauri Programme within The Commons Conservancy
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: MIT
+
+#[cfg(feature = "semver")]
+use crate::semver_compat::semver_compat_string;
+
+use crate::SingleInstanceCallback;
+use std::ffi::CStr;
+use tauri::{
+    plugin::{self, TauriPlugin},
+    AppHandle, Manager, RunEvent, Runtime,
+};
+use windows_sys::Win32::{
+    Foundation::{CloseHandle, GetLastError, ERROR_ALREADY_EXISTS, HWND, LPARAM, LRESULT, WPARAM},
+    System::{
+        DataExchange::COPYDATASTRUCT,
+        LibraryLoader::GetModuleHandleW,
+        Threading::{CreateMutexW, ReleaseMutex},
+    },
+    UI::WindowsAndMessaging::{
+        self as w32wm, AllowSetForegroundWindow, CreateWindowExW, DefWindowProcW, DestroyWindow,
+        FindWindowW, GetWindowThreadProcessId, RegisterClassExW, SendMessageW, CREATESTRUCTW,
+        GWLP_USERDATA, GWL_STYLE, WINDOW_LONG_PTR_INDEX, WM_COPYDATA, WM_CREATE, WM_DESTROY,
+        WNDCLASSEXW, WS_EX_LAYERED, WS_EX_NOACTIVATE, WS_EX_TOOLWINDOW, WS_EX_TRANSPARENT,
+        WS_OVERLAPPED, WS_POPUP, WS_VISIBLE,
+    },
+};
+
+const WMCOPYDATA_SINGLE_INSTANCE_DATA: usize = 1542;
+
+struct MutexHandle(isize);
+
+struct TargetWindowHandle(isize);
+
+struct UserData<R: Runtime> {
+    app: AppHandle<R>,
+    callback: Box<SingleInstanceCallback<R>>,
+}
+
+impl<R: Runtime> UserData<R> {
+    unsafe fn from_hwnd_raw(hwnd: HWND) -> *mut Self {
+        GetWindowLongPtrW(hwnd, GWLP_USERDATA) as *mut Self
+    }
+
+    unsafe fn from_hwnd<'a>(hwnd: HWND) -> &'a mut Self {
+        &mut *Self::from_hwnd_raw(hwnd)
+    }
+
+    fn run_callback(&mut self, args: Vec<String>, cwd: String) {
+        (self.callback)(&self.app, args, cwd)
+    }
+}
+
+pub fn init<R: Runtime>(callback: Box<SingleInstanceCallback<R>>) -> TauriPlugin<R> {
+    plugin::Builder::new("single-instance")
+        .setup(|app, _api| {
+            #[allow(unused_mut)]
+            let mut id = app.config().identifier.clone();
+            #[cfg(feature = "semver")]
+            {
+                id.push('_');
+                id.push_str(semver_compat_string(&app.package_info().version).as_str());
+            }
+
+            let class_name = encode_wide(format!("{id}-sic"));
+            let window_name = encode_wide(format!("{id}-siw"));
+            let mutex_name = encode_wide(format!("{id}-sim"));
+
+            let hmutex =
+                unsafe { CreateMutexW(std::ptr::null(), true.into(), mutex_name.as_ptr()) };
+
+            if unsafe { GetLastError() } == ERROR_ALREADY_EXISTS {
+                unsafe {
+                    let hwnd = FindWindowW(class_name.as_ptr(), window_name.as_ptr());
+
+                    if !hwnd.is_null() {
+                        // Windows lets us bring a window to the front, but not the first
+                        // instance. Hand that right over before we exit, so focusing a window
+                        // from the callback works. Windows takes it back if the user switches
+                        // to another app in the meantime.
+                        let mut pid = 0;
+                        GetWindowThreadProcessId(hwnd, &mut pid);
+                        if pid != 0 {
+                            AllowSetForegroundWindow(pid);
+                        }
+
+                        let cwd = std::env::current_dir().unwrap_or_default();
+                        let cwd = cwd.to_str().unwrap_or_default();
+
+                        let args = std::env::args().collect::<Vec<String>>().join("|");
+
+                        let data = format!("{cwd}|{args}\0",);
+
+                        let bytes = data.as_bytes();
+                        let cds = COPYDATASTRUCT {
+                            dwData: WMCOPYDATA_SINGLE_INSTANCE_DATA,
+                            cbData: bytes.len() as _,
+                            lpData: bytes.as_ptr() as _,
+                        };
+
+                        SendMessageW(hwnd, WM_COPYDATA, 0, &cds as *const _ as _);
+
+                        app.cleanup_before_exit();
+                        std::process::exit(0);
+                    }
+                }
+            } else {
+                app.manage(MutexHandle(hmutex as _));
+
+                let userdata = UserData {
+                    app: app.clone(),
+                    callback,
+                };
+                let userdata = Box::into_raw(Box::new(userdata));
+                let hwnd = create_event_target_window::<R>(&class_name, &window_name, userdata);
+                app.manage(TargetWindowHandle(hwnd as _));
+            }
+
+            Ok(())
+        })
+        .on_event(|app, event| {
+            if let RunEvent::Exit = event {
+                destroy(app);
+            }
+        })
+        .build()
+}
+
+pub fn destroy<R: Runtime, M: Manager<R>>(manager: &M) {
+    if let Some(hmutex) = manager.try_state::<MutexHandle>() {
+        unsafe {
+            ReleaseMutex(hmutex.0 as _);
+            CloseHandle(hmutex.0 as _);
+        }
+    }
+    if let Some(hwnd) = manager.try_state::<TargetWindowHandle>() {
+        unsafe { DestroyWindow(hwnd.0 as _) };
+    }
+}
+
+unsafe extern "system" fn single_instance_window_proc<R: Runtime>(
+    hwnd: HWND,
+    msg: u32,
+    wparam: WPARAM,
+    lparam: LPARAM,
+) -> LRESULT {
+    match msg {
+        WM_CREATE => {
+            let create_struct = &*(lparam as *const CREATESTRUCTW);
+            let userdata = create_struct.lpCreateParams as *const UserData<R>;
+            SetWindowLongPtrW(hwnd, GWLP_USERDATA, userdata as _);
+            0
+        }
+
+        WM_COPYDATA => {
+            let cds_ptr = lparam as *const COPYDATASTRUCT;
+            if (*cds_ptr).dwData == WMCOPYDATA_SINGLE_INSTANCE_DATA {
+                let userdata = UserData::<R>::from_hwnd(hwnd);
+
+                let data = CStr::from_ptr((*cds_ptr).lpData as _).to_string_lossy();
+                let mut s = data.split('|');
+                let cwd = s.next().unwrap();
+                let args = s.map(|s| s.to_string()).collect();
+
+                userdata.run_callback(args, cwd.to_string());
+            }
+            1
+        }
+
+        WM_DESTROY => {
+            let userdata = UserData::<R>::from_hwnd_raw(hwnd);
+            drop(Box::from_raw(userdata));
+            0
+        }
+        _ => DefWindowProcW(hwnd, msg, wparam, lparam),
+    }
+}
+
+fn create_event_target_window<R: Runtime>(
+    class_name: &[u16],
+    window_name: &[u16],
+    userdata: *const UserData<R>,
+) -> HWND {
+    unsafe {
+        let class = WNDCLASSEXW {
+            cbSize: std::mem::size_of::<WNDCLASSEXW>() as u32,
+            style: 0,
+            lpfnWndProc: Some(single_instance_window_proc::<R>),
+            cbClsExtra: 0,
+            cbWndExtra: 0,
+            hInstance: GetModuleHandleW(std::ptr::null()),
+            hIcon: std::ptr::null_mut(),
+            hCursor: std::ptr::null_mut(),
+            hbrBackground: std::ptr::null_mut(),
+            lpszMenuName: std::ptr::null(),
+            lpszClassName: class_name.as_ptr(),
+            hIconSm: std::ptr::null_mut(),
+        };
+
+        RegisterClassExW(&class);
+
+        let hwnd = CreateWindowExW(
+            WS_EX_NOACTIVATE
+            | WS_EX_TRANSPARENT
+            | WS_EX_LAYERED
+            // WS_EX_TOOLWINDOW prevents this window from ever showing up in the taskbar, which
+            // we want to avoid. If you remove this style, this window won't show up in the
+            // taskbar *initially*, but it can show up at some later point. This can sometimes
+            // happen on its own after several hours have passed, although this has proven
+            // difficult to reproduce. Alternatively, it can be manually triggered by killing
+            // `explorer.exe` and then starting the process back up.
+            // It is unclear why the bug is triggered by waiting for several hours.
+            | WS_EX_TOOLWINDOW,
+            class_name.as_ptr(),
+            window_name.as_ptr(),
+            WS_OVERLAPPED,
+            0,
+            0,
+            0,
+            0,
+            std::ptr::null_mut(),
+            std::ptr::null_mut(),
+            GetModuleHandleW(std::ptr::null()),
+            userdata as _,
+        );
+        SetWindowLongPtrW(
+            hwnd,
+            GWL_STYLE,
+            // The window technically has to be visible to receive WM_PAINT messages (which are used
+            // for delivering events during resizes), but it isn't displayed to the user because of
+            // the LAYERED style.
+            (WS_VISIBLE | WS_POPUP) as isize,
+        );
+        hwnd
+    }
+}
+
+pub fn encode_wide(string: impl AsRef<std::ffi::OsStr>) -> Vec<u16> {
+    std::os::windows::prelude::OsStrExt::encode_wide(string.as_ref())
+        .chain(std::iter::once(0))
+        .collect()
+}
+
+#[cfg(target_pointer_width = "32")]
+#[allow(non_snake_case)]
+unsafe fn SetWindowLongPtrW(hwnd: HWND, index: WINDOW_LONG_PTR_INDEX, value: isize) -> isize {
+    w32wm::SetWindowLongW(hwnd, index, value as _) as _
+}
+
+#[cfg(target_pointer_width = "64")]
+#[allow(non_snake_case)]
+unsafe fn SetWindowLongPtrW(hwnd: HWND, index: WINDOW_LONG_PTR_INDEX, value: isize) -> isize {
+    w32wm::SetWindowLongPtrW(hwnd, index, value)
+}
+
+#[cfg(target_pointer_width = "32")]
+#[allow(non_snake_case)]
+unsafe fn GetWindowLongPtrW(hwnd: HWND, index: WINDOW_LONG_PTR_INDEX) -> isize {
+    w32wm::GetWindowLongW(hwnd, index) as _
+}
+
+#[cfg(target_pointer_width = "64")]
+#[allow(non_snake_case)]
+unsafe fn GetWindowLongPtrW(hwnd: HWND, index: WINDOW_LONG_PTR_INDEX) -> isize {
+    w32wm::GetWindowLongPtrW(hwnd, index)
+}
--- a/plugins/single-instance/src/semver_compat.rs
+++ b/plugins/single-instance/src/semver_compat.rs
@@ -0,0 +1,19 @@
+// Copyright 2019-2023 Tauri Programme within The Commons Conservancy
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: MIT
+
+/// Takes a version and spits out a String with trailing _x, thus only considering the digits
+/// relevant regarding semver compatibility
+pub fn semver_compat_string(version: &semver::Version) -> String {
+    // for pre-release always treat each version separately
+    if !version.pre.is_empty() {
+        return version.to_string().replace(['.', '-'], "_");
+    }
+    match version.major {
+        0 => match version.minor {
+            0 => format!("0_0_{}", version.patch),
+            _ => format!("0_{}_x", version.minor),
+        },
+        _ => format!("{}_x_x", version.major),
+    }
+}