In the autumn of 2009, Patrick McKenzie—known to many in the software circles as patio11—penned a manifesto that would signal the death knell for a specific era of indie software development. His post, titled “I’m done making desktop applications,” wasn’t just a personal pivot; it was a prophetic analysis of the friction inherent in local software. At the time, McKenzie was running Bingo Card Creator, a niche product that faced the quintessential “Windows problem”: installation hurdles, versioning nightmares, and a disconnect between the purchase intent and the actual user experience. Fast forward to 2026, and as this topic resurfaces on high-signal forums like Hacker News, the industry is forced to reconcile McKenzie’s 15-year-old grievances with our modern reality of Electron wrappers, Progressive Web Apps (PWAs), and the resurgence of high-performance local computing.
The Distribution Death Trap: Why Local Binaries Failed the Business Test
In 2009, the technical overhead of shipping a desktop application was a primary driver for McKenzie’s declaration. Developers weren’t just writing logic; they were managing installer shields, registry keys, and “DLL Hell.” For a small developer, the “time to value” for a customer was often measured in minutes of frustration rather than seconds of utility. If a user had to download a 20MB executable, bypass a Windows Vista security warning, and then run a three-step installer just to see a demo, the conversion funnel wasn’t just leaking—it was a sieve.
McKenzie correctly identified that the web offered a frictionless “Try it Now” experience that desktop software could never match. This friction is a significant part of why we saw the industry shift toward the SaaS (Software as a Service) model. When the software lives on a server, the developer controls the environment. There is no “it works on my machine” because the developer’s machine *is* the user’s machine. This control allowed for rapid iteration and A/B testing that was physically impossible with distributed binaries. Today, we see this evolution reaching its logical conclusion with specialized tools. For instance, the way modern developers handle complex assets is shifting; look at the innovation in Mounting Tar Archives as a Filesystem in WebAssembly: Optimizing Wasm Storage, which brings the efficiency of local file handling directly into the browser environment, bridging the gap McKenzie lamented.
Furthermore, the business implications of “one and done” desktop sales were disastrous compared to the recurring revenue of the web. McKenzie noted that supporting a desktop user was exponentially more expensive. A bug in a desktop app required a patch, a re-download, and a re-installation by the user. A bug in a web app required a server-side hotfix that was transparent to the entire user base within seconds. “According to a 2024 report by Forrester, the SaaS market is projected to reach $317 billion by the end of 2025, driven largely by the operational efficiencies of centralized deployment” [https://www.forrester.com].
The Customer Lifecycle and the SaaS Revolution
The second pillar of the “I’m done making desktop applications” argument focused on the feedback loop. In the desktop era, a developer was often “flying blind.” Unless a user took the manual step of emailing a log file or a crash report, the developer had no idea how the software was being used—or where it was failing. The web changed this by making telemetry a native feature. Every click, every page load, and every error could be logged in real-time.
This data-driven approach allowed developers to optimize the “Law of Diminishing Returns” often found in software bloat. Instead of adding features that only 1% of the user base wanted (a common pitfall of desktop “pro” software), web developers could see exactly which features were driving value. This leaner approach to development is explored in our analysis of The Law of Diminishing Returns and the Software Sweet Spot, which argues that the most successful software today focuses on core utility rather than exhaustive feature lists that overwhelm aging hardware.
From a business perspective, the web also solved the “piracy” problem that plagued indie desktop developers in the 2000s. If the value of the software is tied to a server-side account or a database, a serial-key crack becomes irrelevant. This shifted the developer’s focus from “how do I protect my code” to “how do I provide enough ongoing value that the subscription is worth it.” It turned software from a commodity into a service, fundamentally changing the economics of the industry.
The Modern Counter-Revolution: Why I’m Done Making Desktop Applications (Again?)
It would be a mistake, however, to assume that the web “won” entirely. As we look at the tech landscape in 2026, we are seeing a strange synthesis. Many of the most popular “desktop” apps today—Discord, VS Code, Slack—are actually web applications wrapped in Electron. They provide the distribution ease of the web with the OS integration of the desktop. But this has led to a new set of problems: memory bloat and performance degradation. “GitHub’s Octoverse 2023 report indicates that TypeScript and JavaScript remain the most used languages, underscoring the web-first developer ecosystem, even as it expands into desktop environments” [https://github.blog/2023-11-08-the-state-of-open-source-and-ai-github-octoverse-2023/].
We are now seeing a movement of “lean” agents and browsers that seek to strip away the overhead of the traditional browser while maintaining the web’s agility. A prime example is Kuri: A Lean, Mean Agent-Browser Alternative Built with Zig, which represents a new frontier for developers who want the best of both worlds. These tools suggest that while McKenzie was right about the *business* of desktop apps, the *performance* requirements of 2026 are pushing us back toward the metal, albeit with modern deployment strategies.
The rise of AI has also complicated the “web is king” narrative. Local execution of Large Language Models (LLMs) requires the kind of GPU access that browsers are only just beginning to provide via WebGPU. For privacy-conscious or performance-heavy AI tasks, the desktop application is making a comeback, but it looks very different from the C++ binaries of 2009. It is now a containerized, self-updating, telemetry-rich environment that behaves like a web app but runs with local power.
Why This Matters for Developers/Engineers
For the modern engineer, the “desktop vs. web” debate is no longer about which platform is “better,” but about where the friction should live. If you choose the web, you accept the friction of network latency and browser sandboxing. If you choose the desktop (even via Electron), you accept the friction of multi-platform builds and larger distribution footprints. McKenzie’s insight was that for 90% of business use cases, the friction of the desktop was a dealbreaker for the customer, not just the developer.
Engineers today must be “platform agnostic” but “architecture aware.” The decision to build a local client should be driven by a specific technical necessity—low-latency hardware access, offline-first capabilities, or massive local data processing—rather than a default preference. The “web-first” mindset has become so dominant that building a desktop app is now a contrarian move that requires a strong justification. Understanding the historical context of why the industry fled the desktop is crucial for avoiding the mistakes of the past.
Furthermore, the security landscape has shifted. In 2009, we worried about viruses in executables. In 2026, we worry about supply chain attacks in NPM packages. The “centralized control” of the web that McKenzie praised also created centralized targets. Engineers must now balance the ease of deployment with the massive responsibility of protecting user data in the cloud, a trade-off that was less pronounced in the era of local-only data storage.
Conclusion
When Patrick McKenzie said, “I’m done making desktop applications,” he was identifying a fundamental shift in how value is delivered. He recognized that software is not just code; it is an experience that includes discovery, installation, and support. While the technologies have evolved—WebAssembly has replaced Flash, and Zig is challenging C++—the core principle remains: the platform with the least friction for the user will eventually win the market. As we move further into the era of AI agents and decentralized computing, we would do well to remember the lessons of 2009. The “desktop” may be returning in spirit, but it must never return to the high-friction, low-visibility silos that nearly killed the indie software movement fifteen years ago.
Key Takeaways
- Minimize Installation Friction: The “time to value” for a new user is the most critical metric for conversion; any barrier to entry is a lost customer.
- Control the Environment: SaaS models succeed because they eliminate the “works on my machine” support nightmare by centralizing the execution environment.
- Data-Driven Iteration: Real-time telemetry is the developer’s greatest tool for fighting feature bloat and focusing on the “software sweet spot.”
- Performance vs. Portability: Choose desktop binaries only when local hardware access or privacy requirements outweigh the distribution benefits of the web.
- Architecture Over Platform: Modern development is about choosing where state and logic live, whether in a browser sandbox, a local container, or a remote server.