Perry vs Tauri
Tauri is a framework for building cross-platform desktop (and increasingly mobile) apps with a Rust backend and a frontend that runs inside the operating system's built-in webview — WebView2 on Windows, WKWebView on macOS, WebKitGTK on Linux. Tauri apps are dramatically smaller than Electron because the OS webview isn't bundled. Perry takes a different path: no webview at all, no HTML rendering, just TypeScript compiled to native machine code that drives real platform widgets.
What is Tauri?
Tauri is an open-source framework written in Rust that lets you build cross-platform applications with a web frontend (any framework — React, Vue, Svelte, etc.) and a Rust backend. Instead of bundling Chromium, Tauri uses the system's built-in webview, which keeps app installers in the single-digit MB range on Linux/Windows/macOS. Tauri 2 added mobile (iOS and Android) support. The frontend is rendered as HTML/CSS/JS by the system webview; communication with the Rust backend goes over an IPC bridge.
What is Perry?
Perry compiles TypeScript directly to native machine code via LLVM. The UI layer (perry/ui) is a declarative SwiftUI-style API that maps to native platform widgets — not HTML rendered by a webview. Apps written in Perry don't carry a JavaScript engine, don't run inside WebKit/WebView2, and don't need an IPC bridge between UI and logic. Perry targets 10 platforms including mobile, watch, and TV.
Side by side
| Feature | Perry | Tauri |
|---|---|---|
| UI rendering | Native platform widgets (AppKit, UIKit, GTK4, Win32, JNI) | System webview (WKWebView, WebView2, WebKitGTK) — HTML/CSS/JS |
| Frontend language | TypeScript (declarative widget API) | HTML/CSS/JS via any web framework (React, Vue, etc.) |
| Backend language | TypeScript | Rust |
| IPC between UI and logic | None — single process, direct calls | Required (UI in webview, logic in Rust process) |
| Hello-world installer | ~330 KB | ~3–10 MB (webview is OS-provided) |
| Mobile (iOS, Android) | Yes — native UI | Yes — webview-based (Tauri 2) |
| Watch / TV | watchOS, tvOS, Wear OS | No |
| WebAssembly target | Yes (perry/ui via DOM bridge) | N/A (Tauri itself uses webview natively) |
| Maturity | Pre-1.0 | Stable (1.x / 2.x) |
Where Perry wins
- +Truly native UI — Perry doesn't render HTML; it drives real platform widgets, so apps inherit native scroll physics, focus, accessibility, IME, and OS theming for free.
- +Smaller hello-world (~330 KB vs Tauri's single-digit MB), and no system webview dependency at runtime.
- +Single language, single process. The whole app — UI and logic — is TypeScript, with no IPC bridge to design or debug.
- +watchOS, tvOS, Wear OS, and a full Web/JS target with real native compilation pipelines, not bundled webviews.
- +No webview behavior differences between platforms. Tauri inherits the quirks of WKWebView vs WebView2 vs WebKitGTK; Perry picks the native widget path on each OS.
- +Compute performance is AOT-native, not webview-JIT. Perry leads compute microbenches under matched conditions on M1 Max (perry/benchmarks).
Where Tauri wins
- +Mature, stable framework with active 2.x line and a large community.
- +Frontend flexibility — use any web framework (React, Vue, Svelte, Solid, etc.) you already know.
- +Smaller installers than Electron because Tauri leans on the OS-provided webview rather than bundling Chromium.
- +Rust backend is ideal if you have system-level work to do (filesystem, native APIs) and want compile-time guarantees there.
- +Webview rendering means CSS/HTML iteration speed and devtools work as you'd expect from web development.
- +Established packaging, code signing, and updater pipeline.
When to choose Perry
Choose Perry if you want truly native UI (not HTML rendered in a webview), small native binaries with no webview dependency, a single TypeScript codebase across desktop + mobile + watch + TV, or compile-time-validated cross-platform widget code.
When to choose Tauri
Choose Tauri if you have an existing or planned web frontend, want a small-installer Rust-backed desktop app, are happy with HTML/CSS for UI, or want the broad ecosystem of web frameworks and tools.
Verdict
Tauri is a much better Electron — same web-tech approach, dramatically smaller installer because the OS webview isn't bundled. But it's still a webview-based architecture, which means HTML/CSS/JS rendering and an IPC bridge. Perry takes a different position: no webview at all, native platform widgets, single process. If you want to keep the web stack with smaller binaries than Electron, Tauri is the right answer. If you want to leave the web stack behind for native widgets in TypeScript, Perry is.