Perry vs Tauri
Tauri è un framework per costruire app desktop (e sempre più mobile) multipiattaforma con un backend Rust e un frontend che gira all'interno del webview integrato del sistema operativo — WebView2 su Windows, WKWebView su macOS, WebKitGTK su Linux. Le app Tauri sono drasticamente più piccole di Electron perché il webview dell'OS non è raggruppato. Perry sceglie un percorso diverso: nessun webview, nessun rendering HTML, solo TypeScript compilato in codice macchina nativo che pilota widget reali della piattaforma.
Cos'è Tauri?
Tauri è un framework open-source scritto in Rust che permette di costruire applicazioni multipiattaforma con un frontend web (qualunque framework — React, Vue, Svelte, ecc.) e un backend Rust. Invece di raggruppare Chromium, Tauri usa il webview integrato del sistema, il che mantiene gli installer delle app nell'intervallo di MB a singola cifra su Linux/Windows/macOS. Tauri 2 ha aggiunto il supporto mobile (iOS e Android). Il frontend è renderizzato come HTML/CSS/JS dal webview di sistema; la comunicazione con il backend Rust avviene su un bridge IPC.
Cos'è Perry?
Perry compila TypeScript direttamente in codice macchina nativo tramite LLVM. Il layer UI (perry/ui) è un'API dichiarativa in stile SwiftUI che mappa su widget nativi della piattaforma — non HTML renderizzato da un webview. Le app scritte in Perry non trasportano un motore JavaScript, non girano dentro WebKit/WebView2 e non hanno bisogno di un bridge IPC tra UI e logica. Perry supporta 10 piattaforme tra cui mobile, watch e TV.
Fianco a fianco
| Caratteristica | Perry | Tauri |
|---|---|---|
| Rendering UI | Widget nativi della piattaforma (AppKit, UIKit, GTK4, Win32, JNI) | Webview di sistema (WKWebView, WebView2, WebKitGTK) — HTML/CSS/JS |
| Linguaggio frontend | TypeScript (API dichiarativa per widget) | HTML/CSS/JS via qualunque framework web (React, Vue, ecc.) |
| Linguaggio backend | TypeScript | Rust |
| IPC tra UI e logica | Nessuno — singolo processo, chiamate dirette | Richiesto (UI nel webview, logica nel processo Rust) |
| Installer hello-world | ~330 KB | ~3–10 MB (il webview è fornito dall'OS) |
| Mobile (iOS, Android) | Sì — UI nativa | Sì — basato su webview (Tauri 2) |
| Watch / TV | watchOS, tvOS, Wear OS | No |
| Target WebAssembly | Sì (perry/ui via bridge DOM) | N/A (Tauri stesso usa il webview nativamente) |
| Maturità | Pre-1.0 | Stabile (1.x / 2.x) |
Dove vince Perry
- +UI veramente nativa — Perry non renderizza HTML; pilota widget reali della piattaforma, quindi le app ereditano gratis fisica dello scrolling, focus, accessibilità, IME e theming dell'OS nativi.
- +Hello-world più piccolo (~330 KB vs MB a singola cifra di Tauri), e nessuna dipendenza dal webview di sistema a runtime.
- +Singolo linguaggio, singolo processo. L'intera app — UI e logica — è TypeScript, senza bridge IPC da progettare o debuggare.
- +watchOS, tvOS, Wear OS e un target Web/JS completo con vere pipeline di compilazione native, non webview raggruppati.
- +Nessuna differenza di comportamento dei webview tra piattaforme. Tauri eredita le stranezze di WKWebView vs WebView2 vs WebKitGTK; Perry sceglie il percorso del widget nativo su ogni OS.
- +Le prestazioni di calcolo sono AOT-native, non webview-JIT. Perry guida i microbenchmark di calcolo in condizioni paragonabili su M1 Max (perry/benchmarks).
Dove vince Tauri
- +Framework maturo e stabile con linea 2.x attiva e una grande community.
- +Flessibilità del frontend — usa qualunque framework web (React, Vue, Svelte, Solid, ecc.) tu già conosca.
- +Installer più piccoli di Electron perché Tauri si appoggia al webview fornito dall'OS invece di raggruppare Chromium.
- +Il backend Rust è ideale se hai lavoro a livello di sistema da fare (filesystem, API native) e vuoi garanzie compile-time lì.
- +Il rendering tramite webview significa che la velocità di iterazione su CSS/HTML e i devtools funzionano come ti aspetti dallo sviluppo web.
- +Pipeline consolidata di pacchettizzazione, firma del codice e updater.
Quando scegliere Perry
Scegli Perry se vuoi UI veramente nativa (non HTML renderizzato in un webview), piccoli binari nativi senza dipendenza dal webview, un unico codice TypeScript su desktop + mobile + watch + TV, o codice di widget multipiattaforma validato a compile-time.
Quando scegliere Tauri
Scegli Tauri se hai un frontend web esistente o pianificato, vuoi un'app desktop con backend Rust e installer piccolo, sei contento con HTML/CSS per l'UI, o vuoi l'ampio ecosistema di framework e strumenti web.
Verdetto
Tauri è un Electron molto migliore — stesso approccio web-tech, installer drasticamente più piccolo perché il webview dell'OS non è raggruppato. Ma è ancora un'architettura basata su webview, il che significa rendering HTML/CSS/JS e un bridge IPC. Perry prende una posizione diversa: nessun webview, widget nativi della piattaforma, singolo processo. Se vuoi mantenere lo stack web con binari più piccoli di Electron, Tauri è la risposta giusta. Se vuoi lasciarti alle spalle lo stack web per widget nativi in TypeScript, è Perry.