1. Tauri - The Rust-Powered Alternative
Been fucking around with Tauri on and off for months. Yeah it's fast but holy shit the learning curve is brutal if you don't know Rust. Like, I've been a JavaScript dev for years and Rust makes me feel like an idiot.
First time I tried compiling anything I got this error:
error[E0597]: `config` does not live long enough
--> src/main.rs:23:42
|
23 | let window = tauri::Builder::default().setup(|app| {
| ^^^^^^^ borrowed value does not live long enough
Took me 3 hours to figure out it was a lifetime issue. The borrow checker is like having a really pedantic coworker who catches every mistake but explains it in the most confusing way possible.
But once stuff actually compiles? Performance is immediately obvious. My shitty Electron app that was like 180MB became maybe 15-20MB. Can't remember exact numbers but it's way smaller. Launches instantly instead of that 2-3 second startup lag.
What works when it works:
- Bundle sizes drop massively - exact numbers depend on your app but it's dramatic
- Uses whatever browser is already installed instead of shipping Chrome
- Memory leaks become compile-time errors which is actually pretty nice once you get used to fighting the compiler
- Tauri 2.0 is supposed to support mobile but I haven't tried it yet
Who's actually using it: Honestly not sure about big companies. Zed editor is built with Rust but they wrote their own framework, not Tauri. It's crazy fast though - fastest editor I've used. Whether that's because of Rust or just good engineering, who knows.
2. Wails - Go's Answer to Desktop Development
Wails is definitely easier than Tauri if you don't know systems programming. Go syntax doesn't make you feel stupid like Rust does. But it's got its own weird shit.
First gotcha: the build process is finicky. You need specific Go versions and if your PATH isn't set up exactly right, builds just fail silently. Spent half a day figuring out why wails build wasn't generating anything. Turns out I had Go 1.19 installed but Wails wanted 1.20+ and the error message was useless.
The dev experience is decent once it works. Hot reload mostly functions, though sometimes CSS changes don't update and you have to restart. Go compiles fast so rebuilds aren't painful.
What doesn't suck about Wails:
- Build times are fast compared to Rust (seconds vs minutes)
- You get one executable that just works - no installer nonsense
- Memory usage is way better than Electron but not as good as Tauri
- You can use whatever frontend framework you want - the Go backend is separate
Performance: Can't give you exact benchmarks because I didn't measure carefully, but my test app definitely starts faster than the Electron version. Memory usage dropped a lot - maybe from 350MB to 150MB? Don't quote me on those numbers.
Flutter Desktop is mind-bending if you're used to HTML/CSS. Everything is widgets nested inside other widgets. No divs, no spans, just Container(child: Column(children: [Row(...)])) forever.
Dart syntax is fine but the widget tree gets deep fast. Sometimes I'm 8 levels deep just to make a button with an icon. Coming from React where you can at least pretend it's HTML, this feels like programming with Lego blocks.
Hot reload works great when it works. When it doesn't, you get weird state issues where your app looks wrong until you restart. Happens maybe 10-20% of the time, usually when changing widget types.
The performance is legit though. Animations don't stutter like they do in Electron. Scrolling feels native. Whatever they're doing with GPU rendering works.
What Flutter gets right:
- Smooth animations without the CSS transition hell
- Actually compiles to native code instead of being interpreted
- Direct pixel control so no browser layout weirdness
- Hot reload is addictive when it works properly
Who uses it: Canonical used it for the Ubuntu installer which is pretty ballsy for OS-level stuff. If they trust it for that, it's probably stable enough. Still feels beta-ish compared to web frameworks though.
.NET MAUI is Microsoft's latest attempt after they killed Xamarin. If you know C# it's not bad, but the tooling is still rough around the edges.
Had issues getting the Android emulator to work with MAUI projects - kept getting build errors about missing SDK versions even though everything was installed. Visual Studio's error messages are usually good but for MAUI they're often useless. "Build failed" with no details.
The hot reload barely works on desktop. Change your XAML and sometimes it updates, sometimes it doesn't. Way less reliable than web development where you just refresh the page.
But when it works, the apps feel properly native. Buttons look like Windows buttons on Windows, Mac buttons on Mac. No fake CSS styling trying to mimic platform controls.
What doesn't completely suck:
- Uses actual native UI controls instead of fake ones
- C# is a decent language if you already know it
- Visual Studio debugging is solid when it works
- Integrates with Azure stuff if you're in that ecosystem
Performance: It's compiled C# so definitely faster than JavaScript. Not as fast as Rust/Go but way better than Electron's V8 interpreter.
5. Progressive Web Apps (PWAs) - The Web-Native Approach
Progressive Web Apps are basically websites with an install button. It's the "fuck it, we're already web developers" solution. No Rust, no Go, no new frameworks - just make your site installable.
The install experience is weird though. Some browsers show the install prompt, some don't. Users have to know to look for it in the browser menu. Not exactly intuitive.
Service workers for offline support are finicky. They cache everything until they don't, and debugging why your app isn't updating properly is a nightmare. Clear cache, hard refresh, sacrifice a goat - maybe it works.
File system access exists but it's limited. You can't just read/write anywhere like a real desktop app. Users have to pick files through browser dialogs. Fine for some apps, useless for others.
What PWAs don't suck at:
- No new languages to learn - it's just web development
- Users get updates automatically when you deploy
- Works on mobile without separate app store approval
- Offline support exists even if it's temperamental
Real examples: Twitter's PWA works okay. Starbucks made one that lets you order coffee offline which is actually useful. But they still feel like websites, not real apps. Performance is browser-dependent.
