Desktop software fails in boring, predictable ways, and most of those failures are decided the day you pick the implementation language, long before the first user ever files a bug: the crash reporter fills up with use-after-free in a callback nobody remembered to disconnect, the installer balloons because the runtime has to come along for the ride, the UI hitches because a background task was never actually background, and the Linux build rots because the one person who understood the makefiles left. We have shipped eight pieces of desktop software and supporting libraries whose cores are all Rust, and none of those failure modes is theoretical to us, because we paid for several of them in earlier stacks before moving, so this is the post about what changed between 2020 and now that made Rust the default answer for new desktop work, and the places where it still makes us pay.
The 2020 answer versus the 2026 answer
In 2020, choosing Rust for a desktop app was a bet, and the people making it knew it: the language was genuinely good, but the GUI story was a museum of half-finished bindings, async had only just stabilized and was still teaching everyone what Pin was, and the crates you actually needed for a real app, a competent tree view, a PDF renderer, a tray icon that behaved on all three platforms, were either missing or maintained by one person as a weekend project. You picked Rust then because you believed in where it was going, and you budgeted for the gap between the promise and the shelf.
The shelf caught up, and it did it quietly, the way infrastructure always does. Tauri grew from a clever idea into a toolkit we ship a real product on, because Kanoprii, our PDF editor, is a Tauri 2 app whose editing and signing pipeline is Rust, with PDFium doing the rendering under it, and the whole thing ships as installable packages around 14 MB on Linux, macOS, and Windows. cxx-qt turned the Qt question from “rewrite everything in C++” into “write your QObjects in Rust and let QML consume them,” which is exactly how LinSight, LinSync, and Grexa ended up with Rust cores under Kirigami interfaces. Arte-Ogre, our image editor, is Rust through and through, the Realistic Mouse Jiggler is a small Rust tray app with signed Windows artifacts, underskrift is a pure-Rust PAdES signature library with no C in sight, and even Grex, the Windows file-search tool, keeps its search engine in Rust behind the XAML glass. None of those were stunt ports; each one was the path of least resistance at the time, which is the actual headline.
What actually changed
The tempting explanation is “the borrow checker” or “memory safety,” and those are real, but they were real in 2020 too, so they explain nothing about the timing. What changed is the boring middle layer that decides whether a language is a product tool or a research project. Cargo’s registry filled in the unglamorous gaps, the packaging story on Linux stopped being an apology, the compiler’s error messages went from infamous to genuinely the best in the industry, and the edition mechanism let the language modernize, 2021 and then 2024, without a Python-3-style schism, so the codebase you wrote three years ago still builds and still matters.
The other change is that the failure modes inverted. The old desktop bargain was C or C++ for the core and something gentler on top, and the bill for that bargain arrived as CVEs, as crashes in the field that you could not reproduce, and as the slow accumulation of “we don’t touch that file anymore.” With Rust the bill arrives up front instead, as compile times, as a learning curve that is genuinely steep for the first month, and as the occasional fistfight with a lifetime in callback-heavy GUI code, and we have come to prefer a bill we can see and pay on our own schedule over one that arrives in a user’s crash dump at 2 AM, because the first kind is an engineering cost and the second kind is a trust cost, and trust costs compound.
Where it still hurts
Honesty requires the other column, because anyone who tells you Rust is free is selling something. Compile times on a clean build of a workspace like Grexa’s seven crates are measured in minutes, not seconds, and while incremental builds and sccache take most of the sting out, the first build of the day is still a coffee event in a way that Go developers find hilarious. The GUI story, for all its progress, still has no canonical answer, which means your choice of Tauri or cxx-qt or egui or Slint is a real architectural commitment with different failure modes on each platform, and we have the scars from Tauri’s webview quirks across GNOME, KDE, and XFCE to prove it. And the dependency tree invites a kind of discipline problem, because cargo add is frictionless, so the review habit has to be deliberate or you wake up one day with four hundred transitive crates and a supply chain you have never read.
None of those are disqualifying, but all of them are real, and the reason the tradeoff still lands in Rust’s favor is that every one of them is visible on your own machine, in your own CI, on your own schedule, which is the same point as before restated from the other side: we would rather fight the compiler at our desks than the segfault at the user’s.
The old bargain and the modern equivalent
Those of us who shipped desktop software in the 2000s remember the actual shape of the old bargain, which was MFC or raw Win32 or Qt if you were lucky, reference counting by convention, IUnknown if you were cursed, and a crash reporter as a core piece of product infrastructure rather than an embarrassment, and the honest part is that we shipped good software that way, the same way spaghetti PHP shipped good websites, because working code has value regardless of how it smells. The modern equivalent of that bargain is not “Rust because it is fashionable,” it is Rust because the ecosystem finally finished the sentence the language started in 2015, and the result is that a two-person team can ship a signed Windows tray app, a three-platform PDF editor, and a Kirigami monitoring dashboard off one language and one dependency graph, and spend its engineering budget on the product instead of on the plumbing. We picked Rust because the alternatives’ bills arrive later and larger, we kept it because eight apps in it has never made us regret it, and the places it still hurts are the places we can see, which is the whole review.