Stop choosing Convenience

For years, I've been frustrated by the number of desktop apps companies ship using Electron. I understand why Electron became popular. It gave us a simple way to build cross-platform desktop applications, let frontend developers reuse their existing React skills, and kept the development experience familiar.

But we're in a different era now. We're in the AI era.

Companies are encouraging developers to use AI coding agents, and that's changing the tradeoffs around software development.

I've noticed this trend outside of desktop development too. On Twitter, I've seen developers moving away from clever abstractions and compact libraries in favor of more explicit code because AI models are simply better at working with it.

Take React as an example. We used Redux everywhere for years. Then the industry moved away from it because it was considered too verbose, replacing it with Zustand, custom hooks, and countless homegrown state management solutions. Every company seemed to reinvent the wheel a little differently.

Today, Redux doesn't seem quite so unreasonable anymore.

Its patterns are well established, predictable, and explicit. Those are exactly the kinds of codebases AI thrives in. AI is effectively averaging millions of public GitHub repositories. If we write software using patterns that are consistent across companies and skill levels, AI has a much better chance of producing the correct result.

I think desktop development is in a similar position.

If we're already relying on AI to generate large portions of our applications, why are we still optimizing for Electron's biggest advantage? The original selling point was that frontend developers didn't have to learn native desktop development. But if AI is doing most of the implementation work, that advantage becomes much less important.

Instead, why not build better desktop applications?

The framework I've become most interested in is GPUI from the Zed team. Yes, it's Rust, and Rust isn't an easy language. But GPUI's architecture feels surprisingly familiar to anyone who's written React before. Combined with modern AI models, it's much more approachable than I expected.

I've one-shotted several GPUI applications using DeepSeek V4 Pro, which is hardly the most expensive model available. The framework is surprisingly productive because it gives you a solid foundation without requiring a massive amount of code.

The biggest thing holding GPUI back isn't developer experience. It's the ecosystem.

For example, video support is still fairly immature. There isn't a widely adopted package that solves it cleanly, so many developers end up building their own solutions. Elliott from Dreams of Code implemented an entire video pipeline for Kiru. There are plenty of similar examples on GitHub using GPUI alongside wgpu or other Rust multimedia libraries.

That's normal for a young ecosystem. It will improve over time.

When it does, I think we'll have a compelling alternative to Electron.

Electron has become the default answer for desktop applications because it's convenient. But convenience comes with a cost. Every Electron application ships its own browser runtime, consumes more memory than it needs to, and contributes to the growing feeling that modern desktop software is becoming heavier every year.

If more of these applications were built with frameworks like GPUI, we'd end up with software that's faster, lighter, and makes much better use of system resources.

The thing that finally pushed me to write this was installing Whisper Flow.

Overall, I like it. The self-correction is genuinely impressive. I haven't used another voice-to-text system that cleans up spoken mistakes nearly as well.

For comparison, I currently use FUTO Keyboard on Android. It's good, but it's nowhere near Whisper Flow's quality. If I stumble over my words, FUTO faithfully transcribes the mistake. Whisper Flow often understands what I meant and quietly fixes it. That's a fantastic user experience.

But then I looked at the application itself.

It's an Electron app.

Why?

At its core, it's a push-to-talk application with speech processing. The heavy lifting is already happening inside Whisper. The UI is mostly a small settings window. It doesn't feel like an application that needs an embedded Chromium instance.

If anything, the performance-sensitive parts would benefit from being written in a lower-level language.

This feels like the perfect kind of application for GPUI or another lightweight native framework. Keep the interface simple, run Whisper locally, work completely offline, and ship something that's fast by default instead of carrying around an entire browser just to display a settings panel.

That's what made me realize something.

Electron solved a very real problem for the industry. But AI is changing what that problem looks like.

Maybe it's time to stop assuming Electron is the default choice and start building native desktop applications again.