I've seen a few revolutions in software development.
I think Rust and GPUI are the next big one, and AI will make this cycle much faster. https://x.com/i/article/2120544781201784832
The Next React Moment Is Coming and It's Written in Rust
I've been building software long enough to recognize when something big is about to change.
There's a particular feeling in the air. A technology starts gaining traction among developers, the tooling is still rough, and most of the industry hasn't quite caught on yet.
I've seen this happen several times.
I remember when Steve Jobs effectively sounded the death knell for Flash and championed HTML5. Then came the rise of single-page applications, Node.js, and eventually React, which fundamentally changed how we built for the web.
Then Ethereum and Solidity came along, introducing an entirely new programming model with smart contracts.
Each of these shifts felt experimental, even impractical, at first. And each went on to create an enormous ecosystem of developers, tools, companies, and applications.
I'm getting that same feeling again. This time, it's Rust and GPUI.
The browser was a brilliant shortcut
For the better part of the last decade, we've been building an extraordinary amount of software using web technologies.
React, Electron, and later Tauri made it remarkably easy to build and distribute applications across operating systems.
And they were the right tools for their time.
But somewhere along the way, we normalized the idea that a desktop application should essentially be a website running inside a window.
We accepted the overhead, the abstraction layers, and the occasional sluggishness because the productivity benefits were enormous.
What if we no longer had to make that compromise?
Enter Rust and GPUI
Rust gives us a foundation for building fast, reliable software with strong memory safety guarantees and fewer runtime surprises.
GPUI, the GPU-accelerated framework developed by the team behind Zed, gives us a way to build beautifully responsive desktop interfaces directly in Rust, without relying on a browser engine.
And GPUI Kit is beginning to provide the missing piece: a reusable ecosystem of components, styling, and interface primitives that makes building these applications substantially more practical.
Here's my prediction:
GPUI is the new React. GPUI Kit is the new Tailwind.
Not because they're technically identical, but because I think they'll play similarly important roles in making a new generation of application development accessible and productive.
And the code is surprisingly approachable.
Here's a tiny GPUI counter, showing both layout and interaction:
If you're familiar with React and Tailwind, much of this should already look familiar.
Except there's no DOM, no JavaScript runtime, and no webview sitting between your interface and your application logic.
The result is a genuinely GPU-rendered desktop application running on macOS, Windows, and Linux.
We've already seen what's possible with Zed. And now we're beginning to see some fascinating experiments elsewhere.
Just yesterday, Maciek Pękala, an engineer at Linear, shared an experiment where he had Claude Opus recreate Linear's interface in Rust using GPUI.
The result was an impressively convincing, remarkably fast clone. It wasn't production-ready, and he was candid about the many remaining issues, but that's almost beside the point.
A coding agent was already capable of recreating an extraordinarily sophisticated interface and much of its underlying functionality in a completely different programming stack.
And then there's Cap, the screen recording startup that recently moved its desktop application from Tauri to Rust and GPUI.
Unlike the Linear experiment, this was a production migration.
The results are hard to ignore.
During video editor playback, Cap reported 77% less CPU usage and 88% less memory compared with its previous Tauri implementation.
It went from roughly 3.7 GB of memory to just 440 MB, while maintaining smooth 60 FPS playback.
These are Cap's own measurements, comparing release builds on the same machine. Some of the improvement came from eliminating unnecessary transfers between the GPU, system memory, and browser, rather than simply changing UI frameworks.
But that's precisely the architectural opportunity.
Less machinery between the application and the hardware. Fewer abstractions to coordinate. More direct control over performance.
Here's Cap founder Richie McIlroy sharing the initial results:
The ecosystem is young. There are rough edges, missing capabilities, and plenty of work left to do.
But that's precisely what the beginning of a major shift usually looks like.
Here's why this cycle will be different
Historically, these transitions took years.
React didn't become ubiquitous overnight. Neither did Node.js, HTML5, or smart contracts.
Developers had to learn new programming models, build libraries, write documentation, establish conventions, and slowly convince organizations to adopt them.
This time we have something we didn't have before: LLM coding agents.
And the Linear experiment is a perfect illustration of why that matters.
The biggest obstacle to adopting a new framework used to be the cost of learning it and rebuilding everything the previous ecosystem had accumulated.
AI is rapidly reducing that cost.
An engineer familiar with React can now work with an AI agent to understand Rust's ownership model, translate interface patterns, navigate unfamiliar APIs, and build components that previously would have required weeks of learning.
And as agents improve, the speed at which entire ecosystems can mature should improve with them.
A framework no longer needs five years of Stack Overflow answers, tutorials, and boilerplate repositories before it becomes approachable to ordinary developers.
That's a profound change.
My 18-month prediction
I think we're about to see one of the fastest framework adoption cycles in software history.
What previously took five years could happen in 18 months.
I'm not suggesting that React will disappear or that every web application will suddenly be rewritten in Rust.
The web isn't going anywhere.
But I do think Rust and GPUI could become the default conversation for developers starting serious new desktop applications far sooner than most people expect.
And once that happens, the ecosystem will compound very quickly.
More applications bring more contributors. More contributors bring better libraries. Better libraries make adoption easier. AI agents accelerate every step of that feedback loop.
That's how a niche technology becomes an industry standard.
I've watched enough of these cycles to know that the interesting part isn't when everybody agrees a technology is the future.
It's when you can still see the future taking shape, but most people are busy building the old way.
I think we're at one of those moments right now.