Framework · Since 2022

Tauri

Tauri is a framework for building small, secure desktop and mobile apps from a Rust core and the system WebView, with the UI written in web technologies.

Start the guide Discussions

Tauri is an open-source framework that combines a user interface built with HTML, CSS and JavaScript with a core written in Rust to produce apps for Windows, macOS, Linux, Android and iOS. Its first stable release arrived in 2022, and it now supports desktop and mobile alike. Instead of bundling a browser engine, Tauri uses the WebView that ships with the operating system (WebView2 on Windows, WKWebView on macOS, WebKitGTK on Linux and so on), which keeps installers small and memory use modest.

Tauri fits well when you want to reuse web development skills for a desktop app but care about size and security. Any frontend that builds to static files works, including React, Vue, Svelte and Angular, while OS-level work such as file system access or the system tray is handled by Rust commands and official plugins. Code inside the WebView can only use features that capabilities and permissions explicitly grant to its window, so apps naturally end up exposing only what they need.

To get started, install Rust and your platform's WebView development libraries, scaffold a project with create-tauri-app and run it in development mode. You do not need deep Rust knowledge to begin; tweaking the template's greet command is a good first step. The official documentation then walks through commands, events, the security model and distribution, and the guide below follows the same path.

Highlights

Small app size

Tauri relies on the system WebView instead of bundling a browser engine, keeping installers and memory use small.

Rust core

Windowing, file access and heavy computation run in Rust, giving you a fast, memory-safe backend.

Permission-based security

Capabilities, permissions and scopes decide which commands and paths each window may use; everything else is denied by default.

Desktop and mobile

One codebase can target Windows, macOS and Linux desktops as well as Android and iOS.

Where it is used

Desktop productivity apps built with web technologies
Desktop versions of existing web apps
System tray utilities and developer tools
Apps that target both desktop and mobile

Install

1
Install Rust and system dependencies
Install Rust with rustup. Windows also needs the Microsoft C++ Build Tools and WebView2, macOS needs the Xcode Command Line Tools, and Linux needs development libraries such as WebKitGTK. Install Node.js if you use a web frontend.
```
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
```
2
Create a project
create-tauri-app asks for a project name, identifier, frontend language, package manager and UI template, then generates the project.
```
npm create tauri-app@latest
```
3
Run in development mode
Install dependencies and start the app in development mode. The first run takes a few minutes to build the Rust dependencies; after that, frontend changes show up immediately.
```
cd tauri-app && npm install && npm run tauri dev
```

Your first program

Your first project

src-tauri/src/lib.rs holds the app's Rust core. The greet function, marked with #[tauri::command], is a command the frontend can call with invoke("greet", { name }), and it is registered through generate_handler!. The run function assembles and starts the app; on desktop, main.rs calls it. Run npm run tauri dev and the app window opens.

src-tauri/src/lib.rs

#[tauri::command]
fn greet(name: &str) -> String {
    format!("Hello, {name}! You've been greeted from Rust!")
}

#[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");
}

npm run tauri dev

Everyday tools

Tauri CLI: Commands such as tauri dev, tauri build, tauri add and tauri icon run the app in development, build and package it, add plugins and generate icons.
create-tauri-app: Scaffolds a new Tauri project from your choice of frontend template and package manager.
@tauri-apps/api: The official JavaScript package for calling commands with invoke, subscribing to events and controlling windows from the frontend.
tauri-action: The official GitHub Action that builds your app for Windows, macOS and Linux and uploads it to a release.

Step-by-step guide

Six chapters that take you from installation to the core ideas of Tauri.

Official docs and resources

Languages

Discussions

Start a discussion

Ask questions, share experience and trade opinions about Tauri.

No discussions yet. Start the first one.