Tauri

Tauri is a framework for building desktop applications using web technologies and a Rust backend, distinguished from Electron by a single architectural decision that changes everything: it does not ship a browser.

This sentence is the entire article. Everything that follows is elaboration.

“You’re telling me there’s a framework that does what Electron does but uses 90% less RAM and ships binaries that are 95% smaller, and the industry is STILL using Electron? I need to sit down. I’m already sitting down. I need to sit down harder.”
— The Caffeinated Squirrel, upon learning about Tauri’s resource usage

Context

This article was written on a machine that, eleven days ago, could not render a text editor because fourteen Electron processes were consuming 6.2 GB of RAM. The machine is faster now. Several Electron applications have been replaced. The RAM has been returned to the operating system, which accepted it with the quiet confusion of someone receiving a gift they had forgotten they were owed.

Tauri is why the machine is faster. This article is, in some sense, a thank-you note.

The Thesis

Electron’s thesis is: web technologies (HTML, CSS, JavaScript) are an excellent way to build user interfaces, so we should use them for desktop applications. This thesis is correct.

Electron’s implementation of this thesis is: to use web technologies for desktop applications, we must ship an entire Chromium browser with every application. This implementation is questionable.

Tauri’s counter-thesis is: every major operating system already has a webview. macOS has WebKit. Windows has WebView2. Linux has WebKitGTK. These webviews can render HTML, CSS, and JavaScript. They are already installed. They are already consuming their modest share of system resources. They do not need to be shipped again.

This is not a radical insight. It is, arguably, the obvious insight. But the obvious insight was not obvious to the industry for six years, which tells you something about the industry, or about obviousness, or about the gravitational pull of npm.

Architecture

A Tauri application consists of:

1. Your frontend — HTML, CSS, and JavaScript (or TypeScript, or any framework that compiles to web technologies). This is the user interface. It can use React, Vue, Svelte, or plain HTML. It does not care.

2. The OS webview — WebKit on macOS, WebView2 on Windows, WebKitGTK on Linux. This renders the frontend. It is already on the machine. It does not need to be downloaded. It does not need to be bundled. It does not need to consume 150 MB of disk space pretending to be part of your application.

3. A Rust backend — This handles everything the frontend cannot: file system access, system APIs, native functionality, and the specific kind of performance that only a compiled, memory-safe language can provide.

The result is an application that is 5-10 MB instead of 150-300 MB. That uses 30-80 MB of RAM instead of 300-800 MB. That starts in milliseconds instead of seconds. That does not cause laptop fans to engage during routine text editing.

“A compiler that refuses to compile unsafe code is not restrictive. It is correct. I have been waiting for this since 1976.”
— The Lizard, reviewing Rust’s borrow checker with visible approval

The Rust Backend

Tauri’s choice of Rust for its backend is not incidental. It is architectural.

Rust provides memory safety without garbage collection. This means no use-after-free bugs, no null pointer dereferences, no data races — not because the developer is disciplined, but because the compiler refuses to produce a binary that contains these errors. The compiler is, in effect, a very strict code reviewer that cannot be argued with, bribed, or persuaded to approve the pull request just this once because the deadline is tomorrow.

For a developer who has spent years writing Go — a language with garbage collection, a language that trusts the runtime to manage memory — Rust’s approach is different. It is more demanding at compile time. It is more forgiving at runtime. It is the difference between a teacher who grades harshly and a teacher who lets you fail the exam.

The Rust backend also means that Tauri applications compile to native binaries. There is no runtime interpreter. There is no garbage collector pause. There is the binary, and there is the operating system, and there is nothing in between.

Octarine: The Proof

Octarine is built on Tauri. This is not a coincidence; it is the reason this article exists.

Octarine is 27 MB. Obsidian is 300+ MB. Both are note-taking adjacent applications. Both have rich user interfaces. Both handle files, render content, and manage state. One ships a browser. One does not.

Octarine starts in under a second. It uses 50-80 MB of RAM. It does not cause a developer’s fans to spin. It does not appear in Activity Monitor as a cautionary tale. It is a desktop application that behaves like a desktop application, which is a lower bar than it should be, and yet most of its competitors fail to clear it.

“I’m not saying Octarine is perfect because it uses Tauri. I’m saying Octarine is fast because it uses Tauri, and fast is a prerequisite for perfect, and most apps don’t even get to the prerequisite.”
— a developer, explaining why framework choice matters

Tauri 2.0

In 2024, Tauri shipped version 2.0. The release included mobile support — iOS and Android — using the same architecture: web frontend, Rust backend, native webview.

This is worth pausing on.

Electron has never shipped mobile support. Electron’s response to mobile has been, effectively, “use React Native, which is a different framework with a different architecture and a different set of compromises.” Electron is a desktop framework. It has remained a desktop framework. The mobile web is someone else’s problem.

Tauri 2.0 made mobile its problem and solved it. The same codebase that builds a macOS app builds an iOS app. The same Rust backend. The same web frontend. Native webviews on every platform. This is the promise that cross-platform development has been making since Java applets, and Tauri is one of the few frameworks to actually deliver it without requiring the developer to abandon their existing code.

Meanwhile, Wails v3 — which aims to be Tauri for Go developers — remains in alpha. The timeline divergence is noted without judgment, except for the small amount of judgment implicit in noting it.

The Community

Tauri’s community is what happens when a project attracts people who have been hurt by Electron and have decided to build something better rather than simply complain about it. The Discord is active. The documentation is maintained. The release cadence is steady. Pull requests are reviewed. Issues are triaged.

This is not a given. Many open-source projects have communities that are some combination of hostile, absent, and on fire. Tauri’s community is none of these things. It is, improbably, pleasant. The Caffeinated Squirrel has been asked to leave the Discord twice for suggesting features faster than they could be evaluated, but this is considered a compliment.

The Machine Is Faster Now

After several Electron applications were replaced or retired, a developer’s machine experienced a phenomenon that longtime Electron users may not recognize: idle.

The fans did not spin. The Activity Monitor showed available RAM. The CPU usage graph had valleys. The machine was, for the first time in recent memory, not working harder than the human using it.

The operating system did not know what to do with so much RAM. It had spent years managing scarcity. It had developed coping mechanisms. It had learned to swap to disk with the quiet resignation of a system that has accepted its circumstances. Presented with abundance, it allocated RAM to disk caching and then sat quietly, like a dog that has been given a bed after years of sleeping on the floor.

“My machine used to sound like a hair dryer. Now it sounds like a machine. I had forgotten what machines sound like when they are not in distress.”
— a developer, after the great Electron purge

Measured Characteristics

See Also

• Electron — The framework Tauri is the answer to, and the reason this article was delayed
• Wails — Tauri’s concept in Go, currently in alpha, perpetually in alpha, aspirationally in stable
• Rust — The language that makes Tauri’s backend safe, fast, and opinionated in the correct direction
• Octarine — The proof that Tauri’s architecture produces applications that respect the user’s machine
• Go — The language riclib wishes Tauri used, which is why Wails exists, which is why riclib checks Wails’ repository monthly
• Boring Technology — Tauri’s philosophy: use what the OS already provides
• The Lizard — Approves of Rust’s compiler; considers native webviews an acceptable compromise