cloudparts

Tauri

A framework for desktop and mobile apps with a web front end shown in the operating system’s own web view and a Rust core that holds the app’s logic and its access to the system.

What it is
Cross-platform desktop apps
Used for
Cross-platform mobile apps
Type
Open source
Made by
The Tauri Programme within The Commons Conservancy
License
MIT or Apache 2.0 (your choice)
Facts checked
24 October 2026
Website Source code

What it is

A Tauri app has two halves. The front end is any web project that builds to HTML, CSS and JavaScript, including Rust compiled to WebAssembly with Leptos. Tauri doesn’t bundle a browser to show it. Its WRY library opens the web view the platform already has: WebView2 on Windows, WKWebView on macOS and iOS, WebKitGTK on Linux and the Android System WebView, while its TAO library creates the windows. The web view is linked at run time rather than shipped, which is why a minimal Tauri app can be smaller than 600 KB. Tauri serves the page through its own protocol, without starting a localhost web server.

The other half is the core process, a Rust binary and the only part with full access to the operating system. It owns windows, tray menus, notifications and global state such as database connections. The page calls Rust through commands: a function marked #[tauri::command] is registered with generate_handler! and called from JavaScript with invoke(), with arguments sent as JSON; async commands run off the UI thread. All messages pass through the core, and Tauri 2’s capabilities decide which windows may use which permissions, such as core:window:allow-set-title. Tauri 2.0 (October 2024) added iOS and Android, with native Swift and Kotlin plugins, and moved most features into official plugins. The current line is 2.12 (September 2026); Tauri 3 is in alpha. The bundler produces .app and .dmg, .deb, .rpm and AppImage, and .msi or NSIS .exe installers.

Why teams pick it

  • Small apps: no bundled browser, so installers are a few megabytes; Firezone’s clients are 8 MB on Windows and 12 MB on Linux, against about 100 MB for a default Electron app
  • Any web front end, plus a Rust back end for the work a browser can’t do, with commands that call async Rust and serialize arguments with serde
  • A guarded boundary: the web view reaches the system only through the core, and capabilities grant each window just the permissions it needs
  • Tray icons, notifications, deep links and self-updates come as built-in features or official plugins, and one project builds desktop and mobile apps

Watch out for

  • Three rendering engines: the same HTML runs in WebView2, WKWebView and WebKitGTK, whose versions and features depend on the user’s system, so each platform needs testing
  • Linux packaging follows WebKitGTK: Tauri 2 needs webkit2gtk 4.1, and Firezone found no WebKitGTK version shared by Ubuntu 20.04, 22.04 and 24.04, so one .deb couldn’t cover all three
  • The web view still costs memory: Firezone’s GUI idles at about 100 MB of RAM with every window hidden
  • Back-end work beyond the provided plugins means writing Rust, and on mobile, Swift or Kotlin

Alternatives

What all cross-platform desktop apps have in common →Compare side by side →
ElectronOpen sourceA framework for Windows, macOS and Linux apps written in HTML, CSS and JavaScript, which ships its own copy of Chromium and Node.js inside every app; Visual Studio Code runs on it.DioxusOpen sourceA React-like Rust UI framework for web, desktop and mobile from one codebase: Rust runs natively on desktop and phones and as WebAssembly in the browser, with a system web view or its own GPU renderer drawing the HTML and CSS.

How it fits with other technologies

A Rust command, and the JavaScript that calls it · rust

// src-tauri/src/lib.rs
#[tauri::command]
async fn greet(name: String) -> Result<String, String> {
    // runs natively in the core process, off the UI thread
    Ok(format!("Hello, {name}!"))
}

#[cfg_attr(mobile, tauri::mobile_entry_point)]
pub fn run() {
    tauri::Builder::default()
        .invoke_handler(tauri::generate_handler![greet])
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

// in the web front end:
//   import { invoke } from '@tauri-apps/api/core';
//   const text = await invoke('greet', { name: 'Ada' }); // "Hello, Ada!"

See it in a real stack

No architecture uses Tauri yet. Drop it into the playground and wire it up yourself.Open playground →
Where it came from2019–2026

Electron made desktop apps out of web apps by shipping Chromium and Node.js inside each one, which made even small apps large downloads. Tauri, begun in 2019, took the opposite approach: reuse the web view every operating system already has, and write the native side in Rust. Tauri 1.0 shipped on 19 June 2022, after nine months of betas and four of release candidates. The whole project had been audited by an independent firm, and the team placed the code under the Commons Conservancy so it couldn’t be taken away or locked behind paid features. The announcement argued for small apps in energy terms: 1,000 downloads of a 200 MB app move 200 GB, against 3 GB for a 3 MB one.

Tauri 2.0, after more than two years of work, became stable on 2 October 2024. It added iOS and Android, moved much of the core into plugins, replaced 1.x’s allowlist with permissions, scopes and capabilities, and rewrote the IPC layer to send raw payloads; Radically Open Security audited it during the beta. In March 2025 the team showed an experimental back end based on Verso, a browser built on Servo, with the long-term aim of a shared, evergreen engine apps wouldn’t have to bundle. In 2026 the 2.x line reached 2.12 and dropped Windows 7, and Tauri 3 entered alpha.

Why it’s built this way

The system web view instead of a bundled browser
Shipping a browser with every app costs download size, disk and energy. Linking WebView2, WKWebView or WebKitGTK at run time keeps a minimal app under 600 KB, at the price of platform differences.
A Rust core that owns all system access
Rust’s ownership model gives memory and thread safety, and making the core the only process with full operating-system access lets it inspect and filter every message from the web view.
Capabilities instead of an allowlist
Tauri 2 needed finer control for plugins and mobile, so capability files grant named permissions to specific windows or web views, following the principle of least privilege.
Code owned by a foundation
Putting the code under the Commons Conservancy means it can’t be taken away or turned into paid open-core features.

Timeline

  1. 2019

    The tauri-apps/tauri repository is created in July

  2. 2022

    Tauri 1.0 released on 19 June

  3. 2024

    Tauri 2.0 stable on 2 October, with iOS and Android support

  4. 2025

    Experimental Verso (Servo-based) web view integration in March

  5. 2026

    Tauri 2.12 in September drops Windows 7; Tauri 3 in alpha

Sources11 · facts checked 24 October 2026

Improve this page on GitHub