DocsPluginsShowcaseReleases
npmStar us on GitHub

Getting Started

IntroductionInstallationProject StructureLayouts and PagesLinking and Navigating

Routing

Folder-Based RoutingFile-Based RoutingDynamic RoutesParallel RoutesIntercepting RoutesCatch-All RoutesMDX & Markdown Pages

Special Files

Loading UIError BoundariesTemplateDefaultNot Found

Data Fetching

LoadersActionsAccessing Route Data

Metadata

Metadata & SEOOpen Graph & TwitterIcons & Favicons

API Routes

API Routes OverviewPlain Function HandlersHono IntegrationDynamic API Routes

Environment Variables

OverviewPrefixes & Client ExposureUsing in API Routes

Styling

CSS OverviewTailwind CSSCSS Modules

Platforms

WebWindowsmacOSLinuxAndroidiOS

Deployment

Deployment OverviewProduction ServerStatic ExportHosting Providers

A native React framework for building cross-platform applications from a single codebase.

Resources

  • Documentation
  • Plugins
  • Showcase
  • Releases

Community

  • GitHub Discussions
  • Reddit
  • Discord
  • LinkedIn

More

  • npm
  • GitHub
  • Issues
  • License

© 2026 Bini Cooperation.

Windows

Build native Windows desktop applications with Bini.js.

Windows Overview

Bini.js builds native Windows desktop applications using Tauri v2. Your React app is wrapped in a WebView2 binary, providing a native experience with full system access. The desktop target covers Windows, macOS and Linux from one src-tauri/.

Native Binary

Windows executable (.exe) with Authenticode signing

Code Signing

Authenticode signing support for trusted distribution

Native APIs

Full access to Windows APIs via Tauri

Windows desktop apps are built using Tauri's WebView2 backend. Your app runs in a native window with full system access.

Requirements

Building Windows desktop apps requires different tools depending on your operating system. See the section for your OS below.

  • On Windows: Node.js, Rust, Microsoft C++ Build Tools and the WebView2 Runtime - everything runs locally.
  • On macOS or Linux: Node.js, Git, a GitHub account, and the ability to push a repo. The Windows build itself runs on GitHub Actions.
You cannot produce a native Windows .exe directly from macOS or Linux. Tauri v2 has no supported local cross-compilation path for Windows. The recommended way is GitHub Actions on a windows-latest runner, described in each section below.

Windows

On Windows you can scaffold, develop, and build the app entirely on your own machine - no CI required.

Step 1: Install the tools

  • Node.js 20.19.0 or higher
  • Rust (stable toolchain via rustup) with the MSVC toolchain as default - Tauri compiles a native Rust binary
  • Microsoft C++ Build Tools - Download (install the "Desktop development with C++" workload)
  • Microsoft Edge WebView2 Runtime - Download (the CLI checks for it during the preflight and stops if it is missing)

Step 2: Create the project

Create the Project

Create a new Bini.js project targeting desktop (Windows, macOS and Linux share one src-tauri/) and install its dependencies:

>_Terminal
$ npx create-bini-app@latest my-app --platform desktop
$ cd my-app
$ npm install

Or run the interactive prompt and select Desktop (Windows, macOS, Linux):

>_Terminal
$ npx create-bini-app@latest
>_Terminal
◆
Platforms?
◻ Web Application
◼ Desktop (Windows, macOS, Linux)
◻ Android
↑/↓ to navigate • Space: select • Enter: confirm
Tip: Pass --app-name "My App" and --org com.acme to skip the native naming prompts, and --sign / --nosign to control code-signing setup.

Step 3: Develop and build

Run tauri:dev to open your app in a native window, then tauri:build to produce the executable and installer:

>_Terminal
$ npm run tauri:dev
>_Terminal
$ npm run tauri:build
Tip: Run npm run doctor to check your toolchain, and create-bini-app add desktop to add the desktop target to an existing project.

macOS

A native Windows .exe cannot be produced on macOS - Tauri relies on Windows-only toolchains (MSVC, WebView2, WiX/NSIS), and bundles are not cross-compiled. The Tauri team's recommendation is to build Windows apps on a windows-latest runner in CI.

Your macOS machinenpm run deployGitHub Actions (desktop.yml)windows installer

Step 1: Install the tools

Install Node.js 20.19.0 or higher and Git. Git comes with the Xcode command line tools - run xcode-select --install if you do not have it yet.

Step 2: Create the project

Create the Project

Create a new Bini.js project targeting desktop (Windows, macOS and Linux share one src-tauri/) and install its dependencies:

>_Terminal
$ npx create-bini-app@latest my-app --platform desktop
$ cd my-app
$ npm install

Or run the interactive prompt and select Desktop (Windows, macOS, Linux):

>_Terminal
$ npx create-bini-app@latest
>_Terminal
◆
Platforms?
◻ Web Application
◼ Desktop (Windows, macOS, Linux)
◻ Android
◻ iOS
↑/↓ to navigate • Space: select • Enter: confirm
Tip: Pass --app-name "My App" and --org com.acme to skip the native naming prompts, and --sign / --nosign to control code-signing setup.

Push and build in CI

Run npm run deploy and choose Desktop. bini-deploy writes .github/workflows/desktop.yml — a matrix job that builds Windows, macOS and Linux on their own GitHub runners — stages everything, and pushes to your repository:

>_Terminal
$ npm run deploy
>_Terminal
◇
Platforms?
◻ Web Application
◼ Desktop (Windows, macOS, Linux)
◻ Android
◻ iOS
↑/↓ to navigate • Space: select • Enter: confirm
◇
GitHub repository URL?
https://github.com/you/my-app
◇
Branch to push to?
● main (default)
○ + New branch...
◇
No .env.signing found. Run create-bini-app sign now?
●Yes/○No
◇
Sign Windows for GitHub Actions?
●Yes/○No
◇
Generate deployment files and push to GitHub?
●Yes/○No
◆
Commit message (press Enter for the default):
chore: add deployment configuration

Once pushed, the workflow runs on real windows-latest, macos-latest and ubuntu-latest runners and uploads the installers as run artifacts.

Download the Installer

  1. Open your repository on GitHub and go to the Actions tab.
  2. Open the latest Desktop workflow run.
  3. Under Artifacts, download the Windows bundle (or, if a release was created, download the .exe / .msi from the Releases page).
Why not build locally? Tauri's Windows build needs MSVC and WebView2, which do not exist on macOS. Cross-compiling from macOS to Windows is technically possible but experimental and unreliable. GitHub Actions on windows-latest is the supported path.

Linux

A native Windows .exe cannot be produced on Linux - Tauri relies on Windows-only toolchains (MSVC, WebView2, WiX/NSIS), and bundles are not cross-compiled. The Tauri team's recommendation is to build Windows apps on a windows-latest runner in CI.

Your Linux machinenpm run deployGitHub Actions (desktop.yml)windows installer

Step 1: Install the tools

Install Node.js 20.19.0 or higher and Git with your package manager, for example sudo apt install git on Debian and Ubuntu.

Step 2: Create the project

Create the Project

Create a new Bini.js project targeting desktop (Windows, macOS and Linux share one src-tauri/) and install its dependencies:

>_Terminal
$ npx create-bini-app@latest my-app --platform desktop
$ cd my-app
$ npm install

Or run the interactive prompt and select Desktop (Windows, macOS, Linux):

>_Terminal
$ npx create-bini-app@latest
>_Terminal
◆
Platforms?
◻ Web Application
◼ Desktop (Windows, macOS, Linux)
◻ Android
↑/↓ to navigate • Space: select • Enter: confirm
Tip: Pass --app-name "My App" and --org com.acme to skip the native naming prompts, and --sign / --nosign to control code-signing setup.

Push and build in CI

Run npm run deploy and choose Desktop. bini-deploy writes .github/workflows/desktop.yml — a matrix job that builds Windows, macOS and Linux on their own GitHub runners — stages everything, and pushes to your repository:

>_Terminal
$ npm run deploy
>_Terminal
◇
Platforms?
◻ Web Application
◼ Desktop (Windows, macOS, Linux)
◻ Android
◻ iOS
↑/↓ to navigate • Space: select • Enter: confirm
◇
GitHub repository URL?
https://github.com/you/my-app
◇
Branch to push to?
● main (default)
○ + New branch...
◇
No .env.signing found. Run create-bini-app sign now?
●Yes/○No
◇
Sign Windows for GitHub Actions?
●Yes/○No
◇
Generate deployment files and push to GitHub?
●Yes/○No
◆
Commit message (press Enter for the default):
chore: add deployment configuration

Once pushed, the workflow runs on real windows-latest, macos-latest and ubuntu-latest runners and uploads the installers as run artifacts.

Download the Installer

  1. Open your repository on GitHub and go to the Actions tab.
  2. Open the latest Desktop workflow run.
  3. Under Artifacts, download the Windows bundle (or, if a release was created, download the .exe / .msi from the Releases page).
Why not build locally? Tauri's Windows build needs MSVC and WebView2, which do not exist on Linux. Cross-compiling from Linux to Windows is technically possible but experimental and unreliable. GitHub Actions on windows-latest is the supported path.

Development

Running tauri:dev opens your app in a native desktop window for the OS you are on. To develop the Windows app in a native window, run it on a Windows machine with the requirements installed (see the Windows section):

>_Terminal
$ npm run tauri:dev

This launches your app in a native window with:

  • Hot reload for frontend changes
  • Native window with system tray support
  • Access to Windows APIs
  • Devtools for debugging
On macOS or Linux, tauri:dev runs the macOS/Linux desktop app, not the Windows one. Use web development while iterating, and let CI build the Windows binary.

Building

Build a distributable desktop executable with tauri:build. On Windows this runs locally; on macOS and Linux, Windows builds run in GitHub Actions (see those sections).

>_Terminal
$ npm run tauri:build

The build outputs land in src-tauri/target/release/bundle/:

Output Files

src-tauri
target
release
bundle
nsis
my-app_0.1.0_x64-setup.exe
msi
my-app_0.1.0_x64_en-US.msi
  • nsis/*.exe - NSIS installer (recommended for distribution)
  • msi/*.msi - WiX MSI installer
  • release/my-app.exe - The raw executable (before bundling)
The build output is a native Windows binary that runs without any additional dependencies.

Code Signing

Bini.js supports Authenticode code signing for Windows binaries. Set it up or redo it at any time with create-bini-app sign - either interactively or with a single command. If you only need signing for GitHub Actions, use the --ci-only flag.

Prerequisites

Signing requires an Authenticode certificate. If you do not have one, purchase it from a trusted Certificate Authority (CA).

  • A .pfx code signing certificate from a trusted CA such as DigiCert, Sectigo, or GlobalSign.
  • The password for the certificate file.

Local Signing

To sign the .exe locally on your Windows machine, import your .pfx certificate into your local certificate store:

>_Terminal
$ npx create-bini-app sign desktop ./cert.pfx "pw"

GitHub Actions Signing

If you want the GitHub Action runner to sign the .exe automatically, you must provide the certificate via GitHub Secrets. Use the --ci-only flag to configure it without setting up local signing:

>_Terminal
$ npx create-bini-app sign windows --ci-only

Signing values go into the git-ignored src-tauri/tauri.windows.conf.json, which Tauri merges automatically on Windows only, so the committed tauri.conf.json never points at a certificate that only exists on your machine:

{}src-tauri/tauri.windows.conf.json
{
  "bundle": {
    "windows": {
      "certificateThumbprint": "YOUR_CERT_THUMBPRINT",
      "digestAlgorithm": "sha256",
      "timestampUrl": "http://timestamp.digicert.com"
    }
  }
}

Adding Secrets Manually

To sign the Windows build in GitHub Actions, you must add your certificate as a repository secret. bini-deploy does not upload secrets automatically. You must add them manually:

  1. Go to your repository on GitHub and navigate to Settings → Secrets and variables → Actions.
  2. Click New repository secret.
  3. Add WINDOWS_CERTIFICATE with the base64-encoded string of your .pfx file.
  4. Add WINDOWS_CERTIFICATE_PASSWORD with the password for your certificate.
For production distribution, Authenticode signing is recommended to establish trust with Windows users. Never commit .env.signing, the .pfx, or tauri.windows.conf.json.

Store Submission

Once you have a signed installer (.exe or .msi), you can distribute it. Depending on your goals, you have three options:

  • Direct Download: Host the .msi or .exe on your website or GitHub Releases. This is the most common option for desktop apps.
  • Microsoft Store: Submit your app to the Microsoft Store using a Microsoft Partner Center account.
  • Package Managers: Distribute via Winget or Chocolatey for command-line installs.

Microsoft Store

To publish on the Microsoft Store, you need an MSIX package and a Partner Center account. See the Microsoft Store publishing guide for the specific steps.

Direct Download

If you are distributing directly, upload the signed .exe or .msi from src-tauri/target/release/bundle/ to your website or GitHub Releases. Users can then download and install the app manually.

Package Managers

For command-line installs, you can submit your installer to Winget (Microsoft's package manager) or Chocolatey (a community package manager). Users install your app with a command like winget install MyApp or choco install my-app.

  • Winget: Submit a YAML manifest to the microsoft/winget-pkgs repository.
  • Chocolatey: Create a package and push it to the Chocolatey community repository.
Tip: For direct download, always sign your installer with Authenticode. Unsigned installers trigger Windows SmartScreen warnings, which deter users from installing your app.

macOS

Build a native macOS app with Developer ID signing and notarization.

Linux

Build a native Linux app with AppImage, .deb, and .rpm bundles.

Android

Build a native Android app with keystore signing and Play Store support.

iOS

Build a native iOS app with App Store distribution and TestFlight.

Was this helpful?
PreviousWeb
NextmacOS

On this page

  • Windows Overview
  • Requirements
  • Windows
  • macOS
  • Linux
  • Development
  • Building
  • Code Signing
  • Store Submission
Edit this page on GitHub

Windows

Build native Windows desktop applications with Bini.js.

Windows Overview

Bini.js builds native Windows desktop applications using Tauri v2. Your React app is wrapped in a WebView2 binary, providing a native experience with full system access. The desktop target covers Windows, macOS and Linux from one src-tauri/.

Native Binary

Windows executable (.exe) with Authenticode signing

Code Signing

Authenticode signing support for trusted distribution

Native APIs

Full access to Windows APIs via Tauri

Windows desktop apps are built using Tauri's WebView2 backend. Your app runs in a native window with full system access.

Requirements

Building Windows desktop apps requires different tools depending on your operating system. See the section for your OS below.

  • On Windows: Node.js, Rust, Microsoft C++ Build Tools and the WebView2 Runtime - everything runs locally.
  • On macOS or Linux: Node.js, Git, a GitHub account, and the ability to push a repo. The Windows build itself runs on GitHub Actions.
You cannot produce a native Windows .exe directly from macOS or Linux. Tauri v2 has no supported local cross-compilation path for Windows. The recommended way is GitHub Actions on a windows-latest runner, described in each section below.

Windows

On Windows you can scaffold, develop, and build the app entirely on your own machine - no CI required.

Step 1: Install the tools

  • Node.js 20.19.0 or higher
  • Rust (stable toolchain via rustup) with the MSVC toolchain as default - Tauri compiles a native Rust binary
  • Microsoft C++ Build Tools - Download (install the "Desktop development with C++" workload)
  • Microsoft Edge WebView2 Runtime - Download (the CLI checks for it during the preflight and stops if it is missing)

Step 2: Create the project

Create the Project

Create a new Bini.js project targeting desktop (Windows, macOS and Linux share one src-tauri/) and install its dependencies:

>_Terminal
$ npx create-bini-app@latest my-app --platform desktop
$ cd my-app
$ npm install

Or run the interactive prompt and select Desktop (Windows, macOS, Linux):

>_Terminal
$ npx create-bini-app@latest
>_Terminal
◆
Platforms?
◻ Web Application
◼ Desktop (Windows, macOS, Linux)
◻ Android
↑/↓ to navigate • Space: select • Enter: confirm
Tip: Pass --app-name "My App" and --org com.acme to skip the native naming prompts, and --sign / --nosign to control code-signing setup.

Step 3: Develop and build

Run tauri:dev to open your app in a native window, then tauri:build to produce the executable and installer:

>_Terminal
$ npm run tauri:dev
>_Terminal
$ npm run tauri:build
Tip: Run npm run doctor to check your toolchain, and create-bini-app add desktop to add the desktop target to an existing project.

macOS

A native Windows .exe cannot be produced on macOS - Tauri relies on Windows-only toolchains (MSVC, WebView2, WiX/NSIS), and bundles are not cross-compiled. The Tauri team's recommendation is to build Windows apps on a windows-latest runner in CI.

Your macOS machinenpm run deployGitHub Actions (desktop.yml)windows installer

Step 1: Install the tools

Install Node.js 20.19.0 or higher and Git. Git comes with the Xcode command line tools - run xcode-select --install if you do not have it yet.

Step 2: Create the project

Create the Project

Create a new Bini.js project targeting desktop (Windows, macOS and Linux share one src-tauri/) and install its dependencies:

>_Terminal
$ npx create-bini-app@latest my-app --platform desktop
$ cd my-app
$ npm install

Or run the interactive prompt and select Desktop (Windows, macOS, Linux):

>_Terminal
$ npx create-bini-app@latest
>_Terminal
◆
Platforms?
◻ Web Application
◼ Desktop (Windows, macOS, Linux)
◻ Android
◻ iOS
↑/↓ to navigate • Space: select • Enter: confirm
Tip: Pass --app-name "My App" and --org com.acme to skip the native naming prompts, and --sign / --nosign to control code-signing setup.

Push and build in CI

Run npm run deploy and choose Desktop. bini-deploy writes .github/workflows/desktop.yml — a matrix job that builds Windows, macOS and Linux on their own GitHub runners — stages everything, and pushes to your repository:

>_Terminal
$ npm run deploy
>_Terminal
◇
Platforms?
◻ Web Application
◼ Desktop (Windows, macOS, Linux)
◻ Android
◻ iOS
↑/↓ to navigate • Space: select • Enter: confirm
◇
GitHub repository URL?
https://github.com/you/my-app
◇
Branch to push to?
● main (default)
○ + New branch...
◇
No .env.signing found. Run create-bini-app sign now?
●Yes/○No
◇
Sign Windows for GitHub Actions?
●Yes/○No
◇
Generate deployment files and push to GitHub?
●Yes/○No
◆
Commit message (press Enter for the default):
chore: add deployment configuration

Once pushed, the workflow runs on real windows-latest, macos-latest and ubuntu-latest runners and uploads the installers as run artifacts.

Download the Installer

  1. Open your repository on GitHub and go to the Actions tab.
  2. Open the latest Desktop workflow run.
  3. Under Artifacts, download the Windows bundle (or, if a release was created, download the .exe / .msi from the Releases page).
Why not build locally? Tauri's Windows build needs MSVC and WebView2, which do not exist on macOS. Cross-compiling from macOS to Windows is technically possible but experimental and unreliable. GitHub Actions on windows-latest is the supported path.

Linux

A native Windows .exe cannot be produced on Linux - Tauri relies on Windows-only toolchains (MSVC, WebView2, WiX/NSIS), and bundles are not cross-compiled. The Tauri team's recommendation is to build Windows apps on a windows-latest runner in CI.

Your Linux machinenpm run deployGitHub Actions (desktop.yml)windows installer

Step 1: Install the tools

Install Node.js 20.19.0 or higher and Git with your package manager, for example sudo apt install git on Debian and Ubuntu.

Step 2: Create the project

Create the Project

Create a new Bini.js project targeting desktop (Windows, macOS and Linux share one src-tauri/) and install its dependencies:

>_Terminal
$ npx create-bini-app@latest my-app --platform desktop
$ cd my-app
$ npm install

Or run the interactive prompt and select Desktop (Windows, macOS, Linux):

>_Terminal
$ npx create-bini-app@latest
>_Terminal
◆
Platforms?
◻ Web Application
◼ Desktop (Windows, macOS, Linux)
◻ Android
↑/↓ to navigate • Space: select • Enter: confirm
Tip: Pass --app-name "My App" and --org com.acme to skip the native naming prompts, and --sign / --nosign to control code-signing setup.

Push and build in CI

Run npm run deploy and choose Desktop. bini-deploy writes .github/workflows/desktop.yml — a matrix job that builds Windows, macOS and Linux on their own GitHub runners — stages everything, and pushes to your repository:

>_Terminal
$ npm run deploy
>_Terminal
◇
Platforms?
◻ Web Application
◼ Desktop (Windows, macOS, Linux)
◻ Android
◻ iOS
↑/↓ to navigate • Space: select • Enter: confirm
◇
GitHub repository URL?
https://github.com/you/my-app
◇
Branch to push to?
● main (default)
○ + New branch...
◇
No .env.signing found. Run create-bini-app sign now?
●Yes/○No
◇
Sign Windows for GitHub Actions?
●Yes/○No
◇
Generate deployment files and push to GitHub?
●Yes/○No
◆
Commit message (press Enter for the default):
chore: add deployment configuration

Once pushed, the workflow runs on real windows-latest, macos-latest and ubuntu-latest runners and uploads the installers as run artifacts.

Download the Installer

  1. Open your repository on GitHub and go to the Actions tab.
  2. Open the latest Desktop workflow run.
  3. Under Artifacts, download the Windows bundle (or, if a release was created, download the .exe / .msi from the Releases page).
Why not build locally? Tauri's Windows build needs MSVC and WebView2, which do not exist on Linux. Cross-compiling from Linux to Windows is technically possible but experimental and unreliable. GitHub Actions on windows-latest is the supported path.

Development

Running tauri:dev opens your app in a native desktop window for the OS you are on. To develop the Windows app in a native window, run it on a Windows machine with the requirements installed (see the Windows section):

>_Terminal
$ npm run tauri:dev

This launches your app in a native window with:

  • Hot reload for frontend changes
  • Native window with system tray support
  • Access to Windows APIs
  • Devtools for debugging
On macOS or Linux, tauri:dev runs the macOS/Linux desktop app, not the Windows one. Use web development while iterating, and let CI build the Windows binary.

Building

Build a distributable desktop executable with tauri:build. On Windows this runs locally; on macOS and Linux, Windows builds run in GitHub Actions (see those sections).

>_Terminal
$ npm run tauri:build

The build outputs land in src-tauri/target/release/bundle/:

Output Files

src-tauri
target
release
bundle
nsis
my-app_0.1.0_x64-setup.exe
msi
my-app_0.1.0_x64_en-US.msi
  • nsis/*.exe - NSIS installer (recommended for distribution)
  • msi/*.msi - WiX MSI installer
  • release/my-app.exe - The raw executable (before bundling)
The build output is a native Windows binary that runs without any additional dependencies.

Code Signing

Bini.js supports Authenticode code signing for Windows binaries. Set it up or redo it at any time with create-bini-app sign - either interactively or with a single command. If you only need signing for GitHub Actions, use the --ci-only flag.

Prerequisites

Signing requires an Authenticode certificate. If you do not have one, purchase it from a trusted Certificate Authority (CA).

  • A .pfx code signing certificate from a trusted CA such as DigiCert, Sectigo, or GlobalSign.
  • The password for the certificate file.

Local Signing

To sign the .exe locally on your Windows machine, import your .pfx certificate into your local certificate store:

>_Terminal
$ npx create-bini-app sign desktop ./cert.pfx "pw"

GitHub Actions Signing

If you want the GitHub Action runner to sign the .exe automatically, you must provide the certificate via GitHub Secrets. Use the --ci-only flag to configure it without setting up local signing:

>_Terminal
$ npx create-bini-app sign windows --ci-only

Signing values go into the git-ignored src-tauri/tauri.windows.conf.json, which Tauri merges automatically on Windows only, so the committed tauri.conf.json never points at a certificate that only exists on your machine:

{}src-tauri/tauri.windows.conf.json
{
  "bundle": {
    "windows": {
      "certificateThumbprint": "YOUR_CERT_THUMBPRINT",
      "digestAlgorithm": "sha256",
      "timestampUrl": "http://timestamp.digicert.com"
    }
  }
}

Adding Secrets Manually

To sign the Windows build in GitHub Actions, you must add your certificate as a repository secret. bini-deploy does not upload secrets automatically. You must add them manually:

  1. Go to your repository on GitHub and navigate to Settings → Secrets and variables → Actions.
  2. Click New repository secret.
  3. Add WINDOWS_CERTIFICATE with the base64-encoded string of your .pfx file.
  4. Add WINDOWS_CERTIFICATE_PASSWORD with the password for your certificate.
For production distribution, Authenticode signing is recommended to establish trust with Windows users. Never commit .env.signing, the .pfx, or tauri.windows.conf.json.

Store Submission

Once you have a signed installer (.exe or .msi), you can distribute it. Depending on your goals, you have three options:

  • Direct Download: Host the .msi or .exe on your website or GitHub Releases. This is the most common option for desktop apps.
  • Microsoft Store: Submit your app to the Microsoft Store using a Microsoft Partner Center account.
  • Package Managers: Distribute via Winget or Chocolatey for command-line installs.

Microsoft Store

To publish on the Microsoft Store, you need an MSIX package and a Partner Center account. See the Microsoft Store publishing guide for the specific steps.

Direct Download

If you are distributing directly, upload the signed .exe or .msi from src-tauri/target/release/bundle/ to your website or GitHub Releases. Users can then download and install the app manually.

Package Managers

For command-line installs, you can submit your installer to Winget (Microsoft's package manager) or Chocolatey (a community package manager). Users install your app with a command like winget install MyApp or choco install my-app.

  • Winget: Submit a YAML manifest to the microsoft/winget-pkgs repository.
  • Chocolatey: Create a package and push it to the Chocolatey community repository.
Tip: For direct download, always sign your installer with Authenticode. Unsigned installers trigger Windows SmartScreen warnings, which deter users from installing your app.

macOS

Build a native macOS app with Developer ID signing and notarization.

Linux

Build a native Linux app with AppImage, .deb, and .rpm bundles.

Android

Build a native Android app with keystore signing and Play Store support.

iOS

Build a native iOS app with App Store distribution and TestFlight.

Was this helpful?
PreviousWeb
NextmacOS

On this page

  • Windows Overview
  • Requirements
  • Windows
  • macOS
  • Linux
  • Development
  • Building
  • Code Signing
  • Store Submission
Edit this page on GitHub