Agents UI
When we set out to build Agents UI, a native macOS terminal application for AI coding agent workflows, one of our first architectural decisions was choosing between Electron and Tauri. This choice would fundamentally shape our development experience, runtime performance, and the user experience we could deliver.
This isn't a definitive answer to "which framework is better" — both are excellent tools with different tradeoffs. But for a terminal-heavy developer tool with specific performance requirements, the decision became clear. Here's why we chose Tauri, and when you might make the same choice (or choose differently).
The Desktop Developer Tools Landscape
The desktop application ecosystem for developer tools is overwhelmingly dominated by Electron. Visual Studio Code, Slack, Discord, GitHub Desktop, Postman — the list of successful Electron applications is impressive. These aren't just "good enough" apps; VS Code in particular has become the gold standard for modern code editors, proving that Electron can deliver world-class developer experiences.
Electron's dominance makes sense. It enables web developers to build desktop applications using the same technologies they already know: JavaScript, HTML, and CSS. The ecosystem is mature, the patterns are well-documented, and when you encounter a problem, there's usually a Stack Overflow answer or npm package ready to help.
But over the past few years, alternatives have emerged. Tauri, built on Rust and system-native webviews, represents a different philosophy: leverage the platform's native capabilities rather than bundling your own runtime. For certain classes of applications, this approach offers compelling advantages.
Electron's Strengths: Battle-Tested and Proven
Before diving into why we chose Tauri, it's worth acknowledging what makes Electron so successful. These aren't minor points — they're significant advantages that make Electron the right choice for many projects.
Ecosystem maturity is Electron's most significant strength. When you need to integrate with native OS features, someone has likely already written a package for it. Need system notifications? Menu bar integration? Auto-updating? There are well-maintained libraries with years of production testing behind them. The Electron ecosystem has had a decade to mature, and it shows.
Community size matters more than many developers realize. When you hit an obscure bug at 2 AM, finding someone who's solved it before can save hours or days. The Electron community is large enough that most problems have documented solutions. The Discord channels are active, the GitHub issues are searchable, and the collective knowledge base is substantial.
Consistent cross-platform behavior is another major advantage. Electron bundles Chromium, which means your UI renders identically on macOS, Windows, and Linux. There are no "works on my machine" issues related to webview differences. You write once and get pixel-perfect consistency everywhere.
Familiar web technologies lower the barrier to entry. If you can build a web app, you can build an Electron app. This dramatically expands your potential contributor base for open source projects and makes hiring easier for commercial products.
Electron's Tradeoffs: Size, Memory, and Performance
Electron's architecture comes with inherent tradeoffs. By bundling an entire Chromium instance with every application, you're shipping a complete web browser along with your code. For many applications, this cost is entirely justified by the benefits. But for resource-intensive developer tools, especially those running alongside AI models and agents, these tradeoffs become more pronounced.
Binary size is the most visible cost. A minimal Electron app typically starts around 120-150 MB compressed. VS Code, one of the most optimized Electron applications, ships at approximately 90 MB for macOS. This isn't catastrophic — disk space is relatively cheap — but it's worth noting that the entire macOS Terminal.app is under 5 MB.
Memory consumption is more significant. Electron applications typically use 150-300 MB of RAM at idle, before your application code does anything. Running multiple Electron apps means multiple Chromium instances, each with its own memory overhead. For a single application, this is manageable. But developers often run VS Code, Slack, Discord, and other Electron apps simultaneously, leading to the "Electron tax" on available system resources.
Runtime performance varies. Electron itself is quite performant for UI rendering — Chromium's rendering engine is world-class. But the V8 JavaScript engine, while fast, introduces overhead compared to native code. For most UI interactions, this overhead is imperceptible. But for high-frequency operations like terminal I/O, file system watching, or SSH protocol handling, the difference becomes measurable.
Tauri's Different Approach
Tauri takes a fundamentally different architectural approach. Instead of bundling Chromium, it uses the operating system's native webview (WebKit on macOS, WebView2 on Windows, WebKitGTK on Linux). Instead of a Node.js backend, it uses Rust. This changes the performance characteristics dramatically.
Binary size drops significantly. A minimal Tauri application on macOS can be under 5 MB. Agents UI, with a full Monaco editor integration, terminal emulator, SSH client, and substantial feature set, comes in around 15-20 MB. This isn't just about saving disk space — smaller binaries mean faster downloads, quicker updates, and less data transfer for users with limited bandwidth.
Memory consumption is substantially lower. Tauri applications typically use 30-60 MB of RAM at idle, roughly one-fifth of a comparable Electron app. The system webview is already loaded for other applications, so there's significant memory sharing. When running Agents UI alongside other development tools, this reduced footprint is meaningful, especially when users are also running local AI models that consume several gigabytes of RAM.
Native performance for backend operations is where Rust really shines. Terminal I/O, PTY management, file system operations, and SSH protocol handling all run at native speed. There's no JavaScript garbage collection pauses, no V8 optimization warmup time, just compiled native code running directly on the CPU.
Why Tauri Made Sense for a Terminal Application
For Agents UI specifically, the choice became clearer when we considered what a terminal application actually does. Terminal emulation is surprisingly demanding. Modern terminal emulators need to:
- Parse and render ANSI escape sequences at high speed
- Handle PTY I/O with minimal latency
- Manage multiple concurrent sessions
- Stream SSH connections efficiently
- Handle file transfer operations in the background
- Integrate with system tools like zellij for session persistence
These operations happen constantly and need to be fast. The difference between 1ms and 5ms of latency per terminal operation is imperceptible in isolation, but accumulated over thousands of operations per second, it affects the perceived responsiveness of the application.
In our benchmarks, Rust-based PTY handling showed approximately 40% lower latency compared to Node.js-based implementations under load. For terminal operations where users expect instantaneous response, this matters. When developers are running AI agents that generate rapid command sequences, that performance advantage compounds.
Memory efficiency matters specifically because our users are running AI coding agents. Tools like Claude Code, Aider, and Cursor agents already consume 1-4 GB of RAM when active. Developers often run multiple agent sessions simultaneously. In this context, saving 150-200 MB per terminal window adds up. Users have reported running 8-10 concurrent Agents UI sessions alongside their AI workflows without performance degradation.
Real-World Numbers
Let's look at concrete measurements. These numbers are from Agents UI v0.2 compared to a similar terminal application built with Electron:
Binary size:
- Agents UI (Tauri): 18 MB
- Electron equivalent: 142 MB
Memory usage (single session, idle):
- Agents UI: 52 MB
- Electron equivalent: 184 MB
Startup time (cold start):
- Agents UI: 0.8 seconds
- Electron equivalent: 2.1 seconds
Terminal latency (average input-to-render):
- Agents UI: 12ms
- Electron equivalent: 18ms
These aren't scientific benchmarks — they're practical measurements in typical usage. Your mileage will vary based on implementation details, but the directional differences are consistent.
The Challenges of Choosing Tauri
We should be honest about the costs of choosing Tauri. This wasn't a free performance upgrade — it came with real development challenges.
The ecosystem is smaller. When we needed to implement system menu bar integration, we had to write more code from scratch than we would have with Electron. Common patterns that are one npm install away in Electron require more custom implementation in Tauri.
Rust has a learning curve. For teams primarily experienced with web technologies, adding Rust to the stack means longer ramp-up time. Rust's ownership and borrowing concepts are powerful but require investment to learn. We spent weeks on architecture decisions that would have been straightforward in Node.js.
Documentation and examples are thinner. When implementing SSH file transfer with progress tracking, we found few existing examples in the Tauri ecosystem. We ended up combining several Rust crates and figuring out the integration ourselves. This is improving rapidly, but it's a real consideration.
Cross-platform differences are more visible. Because Tauri uses native webviews, you can encounter subtle rendering differences between macOS, Windows, and Linux. Chromium's consistency is genuinely valuable for cross-platform applications. For Agents UI, we initially focused on macOS exclusively, which sidestepped this concern, but it's a real issue for broadly cross-platform tools.
When Electron Is Still the Better Choice
Tauri isn't universally superior. There are many scenarios where Electron remains the better choice.
Rapid prototyping favors Electron. If you're validating a product idea and need to ship quickly, Electron's mature ecosystem and familiar technologies enable faster iteration. The performance tradeoffs don't matter if you never reach product-market fit.
Large teams with web expertise can move faster with Electron. If your team is already expert in React, Node.js, and web technologies, adding Rust creates friction. The productivity cost might outweigh the performance benefits, especially for UI-heavy applications where native performance matters less.
Cross-platform parity is easier with Electron. If you need identical behavior across macOS, Windows, and Linux, Chromium's consistency is valuable. Tauri is improving here, but Electron has the edge.
Complex integrations might have existing Electron solutions. If your app needs to integrate with services that have well-maintained Electron packages, rewriting those integrations for Tauri might not be worth it.
How This Plays Out in Agents UI's Architecture
In Agents UI, the Tauri architecture manifests in specific ways. Our Rust backend handles all the performance-critical operations: PTY management, SSH protocol handling, zellij integration for session persistence, and file system operations. The frontend, built with React and Monaco editor, handles the UI rendering in the WebKit webview.
This separation means that even when users have complex terminal sessions with rapid output, the core terminal logic runs at native speed in Rust. When agents are transferring files over SSH, that happens in Rust with minimal memory overhead. When users open the integrated Monaco editor, the syntax highlighting and text manipulation run in the webview, but saving files and Git operations run in Rust.
The result is a terminal application that feels snappy even under load, uses less memory than alternatives, and downloads in seconds rather than minutes.
Conclusion
For Agents UI, Tauri was the right choice. The performance characteristics align well with our use case: a terminal-heavy developer tool used alongside resource-intensive AI agents. The smaller binary size, lower memory consumption, and native terminal I/O performance deliver meaningful benefits for our users.
But this doesn't make Tauri universally "better" than Electron. Electron powers some of the best developer tools ever built, and its ecosystem maturity remains unmatched. The decision depends on your specific requirements, team expertise, and performance priorities.
If you're building a terminal application, a system monitoring tool, or any developer tool where native performance matters and users will run it alongside other resource-intensive processes, Tauri deserves serious consideration. If you're building a UI-heavy application where ecosystem maturity and rapid development matter more than resource efficiency, Electron might still be the better choice.
The good news is that both options are excellent, and the desktop application ecosystem is healthier for having real competition driving innovation in both projects.
Agents UI is open source and built with Tauri and Rust. If you're curious about how this architecture works in practice, check out the code on GitHub or try the app yourself.