Why Tauri Is the Next Big Thing for Cross‑Platform Desktop Apps

Desktop Application Development Overview

Although the mobile internet dominates today, desktop applications still play a crucial role in daily work and life, with tools like Lark and VSCode being indispensable.

Native Technology Stack

Native development uses OS‑specific APIs or SDKs provided by vendors such as Apple or Microsoft, delivering small binary size, good performance, easy system API calls, strong compatibility, and deep integration with OS UI components.

Advantages

Disadvantages

Windows Platform

The GUI development on Windows evolved from Win32 API → MFC → Windows Forms → WPF → UWP, each adding higher abstraction, componentization, and cross‑platform capabilities.

Win32 API era: function calls, imperative style.

MFC era: object‑oriented wrappers for Win32.

Windows Forms era: component‑based development.

WPF era: XAML for UI description, data‑driven UI.

UWP era: cross‑platform, multi‑language support.

macOS Platform

macOS native apps are mainly built on the Cocoa framework, which originated from NeXTSTEP/OPENSTEP. In 2020 Apple introduced SwiftUI, a declarative UI framework that also supports multiple Apple platforms.

Linux Platform

Linux distributions provide desktop environments (KDE, GNOME) and libraries such as GTK that serve as the "native" stack for GUI development.

Cross‑Platform Technology Stacks

Web Stack

Web technologies remain the most popular choice for cross‑platform development due to low development cost and a massive JavaScript ecosystem.

Advantages

Disadvantages

Electron

Electron combines Node.js (backend) and Chromium (frontend) to create cross‑platform desktop apps. Notable apps include VSCode, Figma, Discord, etc.

Advantages: development-friendly for front‑end engineers.

Disadvantages: large bundle size, high memory consumption.

CEF (Chromium Embedded Framework)

CEF embeds a lightweight Chromium without the full Node.js runtime, allowing custom C++ APIs and JS bridges for native capabilities.

Representative apps: NetEase Cloud Music, Spotify, Feishu.

Self‑Rendering Stacks

Frameworks like Qt, Flutter, and Swing implement their own rendering pipelines using OpenGL/Vulkan/Metal, offering better performance and smaller bundles compared to web‑based stacks.

Qt (C++)

Qt is a mature C++ cross‑platform GUI framework used in WPS Office, Jianying Desktop, AutoDesk, etc.

Advantages: native‑level performance, rich OS support.

Disadvantages: high C++ development cost, GPL licensing for commercial use.

Flutter (Dart)

Flutter, originally for mobile, added stable desktop support in 2022, aiming for 120 FPS rendering.

Advantages: good performance, easy‑to‑learn Dart language.

Disadvantages: desktop ecosystem still immature.

Swing (Java)

Swing provides a pure‑Java GUI framework with write‑once‑run‑anywhere capability, used by JetBrains IDEs.

Advantages: cross‑platform consistency.

Disadvantages: requires bundling a JRE, leading to large binaries.

Tauri Introduction

Tauri aims to balance performance, bundle size, and development convenience by using Rust for the backend and system webviews for the frontend.

Rust

Implemented in Rust, Tauri benefits from high performance comparable to C/C++, strong memory safety, and easy FFI for other languages.

WRY (Webview Render Library)

WRY wraps the native webview on each platform: WebKit.WKWebView on macOS, WebView2 on Windows, and WebKitGTK on Linux, avoiding the need to bundle Chromium.

API Interface

Tauri provides a rich set of APIs (cli, clipboard, dialog, event, fs, globalShortcut, http, notification, os, path, process, shell) that can be called from JavaScript. All APIs are disabled by default and must be explicitly enabled.

Process Model

Tauri uses a multi‑process architecture similar to Electron: a main process with full OS access and one or more webview processes that render the UI. This isolates crashes and follows the principle of least privilege.

IPC Modes

Brownfield (default)

Directly runs existing front‑end projects without modification.

Isolated Mode

Injects a sandboxed iframe between the webview and the main process, encrypting IPC messages with SubtleCrypto. The sandbox uses <iframe> to enforce isolation.

Security

Dynamic AOT compilation and function ASLR for address randomization.

Self‑destructing function injection to lock APIs after use.

Event Bridge ensures messages go through a controlled proxy.

API allow‑list with fine‑grained permission controls.

Content Security Policy (CSP) with hashed local scripts.

Binary packaging makes reverse engineering harder.

One‑time tokens and OTP hashing protect sensitive data.

Tauri‑egui

The Tauri‑egui library wraps the Rust egui crate, allowing developers to write UI in Rust for scenarios where front‑end code must be immutable (e.g., password entry).

Advantages

Benchmark

Memory usage and binary size are significantly lower than Electron, as shown in the following charts.

Disadvantages

Compatibility: relies on system webview, requiring polyfills and runtime installation (WebView2) on older Windows versions.

References

[1] WRY: https://github.com/tauri-apps/wry

[2] WebKit.WKWebView: https://developer.apple.com/documentation/webkit

[3] WebView2: https://developer.microsoft.com/zh-cn/microsoft-edge/webview2/

[4] WebKitGTK: https://webkitgtk.org/

[5] SubtleCrypto API: https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto

[6] Tauri‑egui: https://github.com/tauri-apps/tauri-egui