Tauri: Desktop and Mobile Apps with a Rust Backend and System Webview
Build smaller, faster, and more secure desktop and mobile applications with a web frontend.
At a glance
- What is it?
- Tauri is a framework for building desktop and mobile applications using a web frontend (HTML, CSS, JavaScript) with a Rust-compiled backend. It targets smaller binaries than Electron by using the operating system's own webview instead of bundling Chromium.
- Who is it for?
- Rust developers or web frontend engineers who need to ship a desktop or mobile application without the 100-300 MB bundle that Electron requires are the primary fit for Tauri. The trade-off is webview inconsistencies across platforms: macOS uses WKWebView, Windows uses WebView2, and Linux uses WebKitGTK, so the same HTML and CSS can render differently on each.
- Can I use it commercially?
- Yes. Apache-2.0 is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 2 days ago.
- What is it written in?
- Mainly Rust, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on September 27, 2026, and from our analysis. They are not legal advice.
DEEP OPEN-SOURCE ANALYSIS
What Tauri Solves: Native Distribution Without a Bundled Browser
Electron made it possible to ship a web frontend as a desktop application, but it does so by bundling a full copy of Chromium into every install. A simple Electron application routinely ships as a 100-300 MB download because Chromium travels with it. Tauri targets the same goal, distributing a web UI as a desktop app, while replacing the bundled browser with the operating system's own webview.
The README describes Tauri as a framework for building tiny, blazingly fast binaries for all major operating systems. The web-based user interface connects to a Rust-compiled backend binary through a defined API. The frontend can be any HTML, JS, and CSS, built by any web framework. The backend is a Rust binary that exposes commands the frontend can call.
The project supports Windows 7 and above, macOS 10.15 and above, Linux (webkit2gtk 4.1 for Tauri v2), iOS 9 and above, and Android 7 and above (currently 8 and above for v2). This makes Tauri one of the few open-source frameworks that targets both desktop and mobile from the same codebase.
How Tauri Works: WRY, tao, and the System Webview
Tauri's rendering layer rests on two internal crates. The tao crate handles window creation and event loops on macOS, Windows, Linux, Android, and iOS. The WRY crate provides a unified API to the platform's native webview: WKWebView on macOS and iOS, WebView2 on Windows, WebKitGTK on Linux, and Android System WebView on Android. The README points to an ARCHITECTURE.md file in the repository for the full picture of how these pieces fit together.
A notable design choice visible in the README is that Tauri does not create a localhost HTTP server to serve the webview contents. Instead, it uses a native WebView Protocol. This means the application does not listen on a network port, which changes the security surface compared to Electron apps that run a local HTTP server.
The backend is a Rust binary. The frontend communicates with it by invoking Tauri commands, which are Rust functions annotated with a macro and exposed to the JavaScript side. The API for this is in the @tauri-apps/api npm package, visible in the workspace build scripts in package.json. The Rust MSRV is 1.90 as documented in Cargo.toml.
Creating a Tauri App from Scratch
The README's Getting Started section points to the documentation website at tauri.app, and recommends installing prerequisites for your system before scaffolding. The quickest way to create a new project is:
npm create tauri-app@latestThis command scaffolds a new Tauri project. The examples/ directory in the repository contains several reference projects: helloworld, api, commands, multiwindow, multiwebview, splashscreen, state, streaming, drag, and others. These are useful for understanding how specific features are implemented.
The repository builds with pnpm 12.4.2 (recorded in package.json as the package manager). For contributors working on Tauri itself rather than using it, the build process targets the Rust crates and the @tauri-apps/api npm package separately. The VS Code extension and GitHub Action mentioned in the README reduce setup friction for common workflows.
After creating a project, the CLI compiles the Rust backend and bundles the web assets together. The output format depends on the platform: .app and .dmg on macOS, .deb, .rpm, and .AppImage on Linux, and .exe (via NSIS) or .msi (via WiX) on Windows.
Bundling, Distribution, and Built-in Features
Tauri includes a built-in app bundler that produces platform-native distribution formats without requiring separate build tools for each platform. The README lists the supported formats: .app, .dmg, .deb, .rpm, .AppImage, and Windows installers (.exe via NSIS, .msi via WiX).
A built-in self-updater is available for desktop targets. System tray icons and native notifications are supported on desktop platforms. These features are integrated into the framework rather than requiring separate plugins, which reduces configuration overhead for applications that need them.
The Cargo.toml workspace lists several crates: tauri, tauri-runtime, tauri-runtime-wry, tauri-macros, tauri-utils, tauri-build, tauri-codegen, tauri-plugin, tauri-bundler, tauri-macos-sign, tauri-driver, and others. The tauri-driver crate supports integration testing of Tauri applications. The tauri-bundler crate handles the packaging step. Each crate has its own version, and the workspace.dependencies section pins the versions used across the workspace.
Where Tauri Falls Short
The system webview dependency is the most significant operational risk. On Windows, WebView2 is included by default from Windows 10 and later and ships with Windows 11, but older or minimally installed Windows 10 machines may not have it. The README notes that Windows 7 and above are supported, but WebView2 availability on those systems is not guaranteed.
On Linux, WebKitGTK 4.1 is required for Tauri v2. The README specifies Ubuntu 22.04 as an example. Distributions that do not package WebKitGTK 4.1 in their default repositories require additional steps to install it, adding friction for Linux desktop distribution.
The three platform webviews behave differently. WKWebView, WebView2, and WebKitGTK each implement web standards to different degrees and on different schedules. A web feature that works on macOS may not work on Linux. A CSS layout that renders correctly in WebView2 may look different in WKWebView. Testing across all three is mandatory for reliable cross-platform applications.
Tauri v3 is in alpha (3.0.0-alpha.3 as of September 2026). Developers on v2 should treat v3 as a separate target and not expect a migration path until the stable release is closer.
Tauri Versus Electron
Electron is the most common alternative for web-to-desktop frameworks. The fundamental difference is that Electron bundles Chromium with every application, giving all users the same browser engine regardless of what the OS provides. This guarantees rendering consistency across platforms but produces large install sizes.
Tauri uses the OS webview. The binary size is far smaller because Chromium is not shipped. The README describes Tauri as producing tiny binaries. The trade-off is that macOS users get WKWebView, Windows users get WebView2, and Linux users get WebKitGTK. Each has its own CSS and JavaScript compatibility profile.
For applications where rendering consistency across platforms is critical, and where install size is acceptable, Electron remains the safer choice. For applications where install size matters, offline distribution is important, or the team is comfortable with the Rust toolchain, Tauri reduces the deployment footprint at the cost of cross-platform webview testing.
Maintenance, Licensing, and Organizational Structure
The last push to the repository was on 2026-09-27. Version 2.12.0 was released on 2026-09-26, and version 3.0.0-alpha.3 was released the same day. The repository is not archived and has an active release cadence.
The code is licensed under Apache-2.0 OR MIT, as recorded in Cargo.toml. This dual license is permissive and compatible with both commercial and open-source downstream use. The repository also includes FOSSA integration for license scanning, visible in the README's badge section.
The README notes that Tauri has become a Programme within the Commons Conservancy, a Dutch non-profit foundation for free and open source software communities. Financial contributions go through Open Collective. CrabNebula is listed as a partner in the README.
Editorial conclusion
Rust developers or web frontend engineers who need to ship a desktop or mobile application without the 100-300 MB bundle that Electron requires are the primary fit for Tauri. The trade-off is webview inconsistencies across platforms: macOS uses WKWebView, Windows uses WebView2, and Linux uses WebKitGTK, so the same HTML and CSS can render differently on each. Before choosing Tauri for a production app, test the UI on all target platforms and verify that WebView2 is available or installable on target Windows machines. Version 2.12.0 is the current stable release; version 3.0.0-alpha.3 is in active development as of September 2026.
Frequently asked questions
Is Tauri a backend framework?
Tauri is not a backend web framework in the traditional sense. The Rust binary it compiles acts as the application backend, handling system calls and providing commands that the web frontend can invoke. It does not serve HTTP requests from external clients.
Is Tauri free to use?
Yes. Tauri is open source and licensed under Apache-2.0 OR MIT, both of which permit free commercial and non-commercial use with minimal restrictions.
How do I install Tauri?
First install the prerequisites documented at v2.tauri.app/start/prerequisites/, which include Rust and platform-specific system dependencies. Then run npm create tauri-app@latest to scaffold a new project. The Tauri CLI is available through the @tauri-apps/cli npm package.
What is Tauri?
Tauri is a Rust framework for building desktop and mobile applications with a web-based user interface. It compiles a Rust binary as the application backend and uses the operating system's native webview to render HTML, CSS, and JavaScript, producing smaller application bundles than Electron.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/tauri-apps-tauri)
Community notes