Kefong Studio 科奉工作室

Introducing Tauri: A Framework for Building Cross-Platform Desktop Apps with the System WebView

·4 min read

This article was written in October 2026 and covers Tauri's design philosophy, capabilities and limits, and the current state of its releases.

In one sentence: Tauri is a framework for building desktop (and mobile) apps with a "web frontend + Rust backend." It doesn't bundle a browser engine; instead it uses the WebView built into the operating system, so installers are typically just a few MB.

What Problem It Solves

Electron made "writing desktop apps with web technologies" mainstream, at the cost of bundling a copy of Chromium and Node.js with every app — installers easily reach 100–200 MB, and even an empty window eats up hundreds of MB of RAM. For users, that's disk space and memory; for developers, it's distribution size.

Tauri takes a different approach: the UI is still HTML / CSS / JS, but rendering is handed off to the operating system's built-in WebView, and the backend is a native binary compiled from Rust.

Architecture

Frontend (any framework: React / Vue / Svelte / even plain HTML+JS)
      ↕  IPC (message passing)
Rust backend (#[tauri::command] / invoke)
      ↕
  WRY —— WebView abstraction layer
  TAO —— Windows / menus / tray (a fork of winit)
      ↓
Windows: WebView2 ｜ macOS: WKWebView ｜ Linux: WebKitGTK

A few implementation details worth remembering:

  • tauri.conf.json is read at compile time, and frontend assets are embedded, hashed and compressed into the final binary;
  • No runtime is shipped; the output is just the compiled Rust binary, which also raises the cost of reverse engineering;
  • The frontend and backend communicate via message passing (invoke / commands / events). You can write just a Rust backend plus any frontend — you can get started without installing Node at all;
  • There's no need for a Node-side proxy layer; the backend is genuine native code that can call system APIs directly, connect to local databases and spawn child processes.

How It Differs from Electron

Electron Tauri
Rendering engine Every app ships its own copy of Chromium Uses the system WebView (WebView2 / WKWebView / WebKitGTK)
Backend language Node.js Rust
Installer size On the order of 100–200 MB On the order of a few MB (the official example: 3 MB vs. 200 MB / 600 MB)
Memory usage One engine per app; relatively high Shares the system engine; relatively low
Rendering consistency Identical across all platforms Depends on the system WebView version; there will be differences
Mobile No official solution Official iOS / Android support since 2.0
Ecosystem Huge (the full npm ecosystem) Smaller, but plugins exist for common needs

What It Can Do

  • Windows and desktop integration: multiple windows, frameless windows, system tray, menus, global shortcuts, file drag-and-drop;
  • System capabilities (as plugins): notifications, clipboard, file dialogs, HTTP requests, running external commands, autostart, logging, single instance…;
  • Built-in distribution pipeline: the bundler outputs msi / nsis / dmg / AppImage / deb and other formats directly, with code signing and a built-in updater;
  • One codebase, multiple platforms: since 2.0, the same frontend can run on desktop and iOS / Android at the same time;
  • Plugin system: a full set of official tauri-plugin-* packages, plus the community-maintained awesome-tauri list.

Security Model

2.x uses capabilities / permissions: you can be as precise as "which window can use which command," rather than broadly opening up a large swath of system permissions (the 1.x allowlist has been superseded). Before 1.0, Tauri underwent an independent third-party security audit (Radically Open Security), and there's also the Isolation Pattern, which isolates the frontend from the core. For risks like "the frontend page might be hit by XSS," it makes it easier to contain the blast radius than solutions that bundle their own engine.

Version History

Version Date Key changes
1.0 2022-06 First stable release, desktop only (Windows / macOS / Linux)
2.0 2024-10 "The mobile update": + iOS/Android, APIs moved to plugins, fine-grained permissions
2.12 2026-09 The largest 2.x update so far: officially drops Windows 7, raises MSRV to 1.90

The current mainline is 2.12.x, and 1.x is in maintenance mode; don't start new projects on 1.0.

Getting Started

npm create tauri-app@latest   # or cargo create-tauri-app
cd my-app
npm run tauri dev             # development mode
npm run tauri build           # build the installer

Prerequisites: the Rust toolchain; on Windows, the WebView2 Runtime (built into Win11, must be installed on Win10); on Linux, system dependencies such as webkit2gtk.

When to Use It, and When Not To

Good fit: utility apps where installer size and memory usage matter; covering Windows / macOS / Linux (and even mobile) at once with limited manpower; teams willing to adopt Rust.

Poor fit: when rendering behavior must be identical across all platforms (system WebView differences will bite you); when you must bundle your own engine for ultimate control over rendering (Electron / CEF is a better fit there); when the team has no Rust experience at all and the delivery timeline is tight.

References