Your phone has more processing power than a 2015 supercomputer. Yet apps still lag, websites still stutter, and your brand-new laptop still takes 30 seconds to open Slack. Welcome to Wirth’s Law: software gets slower faster than hardware gets faster. In 2026, this decades-old observation is more relevant than ever.
What Wirth’s Law States
Computer scientist Niklaus Wirth articulated the principle in 1995: hardware advances are consistently eaten up by software bloat. Every generation of chips delivers more performance, and every generation of software consumes that performance (and then some) with additional abstraction layers, features, and complexity.
The law has held true since mainframes. A 1985 spreadsheet loaded instantly on hardware thousands of times slower than modern machines, while a 2026 spreadsheet with equivalent features takes several seconds on a flagship processor.
Where You Feel It Today
Electron apps are the most visible example. Applications like Slack, Discord, VS Code, and Figma run inside embedded web browsers, consuming 500MB-2GB of RAM each. Running five Electron apps simultaneously can use more memory than the entire Apollo 11 guidance computer had storage. The convenience for developers (write once, run everywhere) comes at a direct performance cost for users.
Web applications have the same problem. The average website in 2026 loads 4.5MB of JavaScript before displaying content. A decade ago, that figure was under 400KB. Page load times have barely improved despite network speeds increasing tenfold.
Why Developers Ship Bloated Software
The incentives are misaligned. Developer time costs more than user hardware. Writing highly optimized native code takes longer than using frameworks that abstract away performance concerns. Companies ship features faster by accepting performance overhead, because users blame their hardware rather than the software.
Cloud computing amplifies this. When backend processing runs on scalable infrastructure, developers optimize for throughput (serving many users) rather than latency (serving each user fast). The individual user’s experience degrades while the system handles more total load. This is visible in timeout errors and slow API responses across major platforms.
The AI Layer Makes It Worse
AI features integrated into consumer software add significant computational overhead. On-device AI processing for features like live photo enhancement, voice transcription, and predictive text consumes CPU/GPU cycles that previously went toward core application performance. Your phone runs hotter and drains battery faster partly because it is constantly running inference models for features you may not even use.
The irony is sharp: we build faster chips to run AI that makes software feel slower without AI.
Are There Solutions?
Some developers are pushing back. The “performance-first” movement advocates for native applications, minimal dependencies, and rigorous profiling. Tools like Rust enable memory-safe code that runs at near-C speeds. Some startups market speed as a feature, building lightweight alternatives to bloated incumbents.
On the hardware side, Apple’s custom silicon strategy partly compensates for software bloat by tightly integrating hardware and software optimization. Android devices with Qualcomm Snapdragon chips are following a similar path with more aggressive power management.
But Wirth’s Law predicts the trend with uncomfortable accuracy: whatever hardware gains the next five years deliver, software will find a way to consume them. The question is whether users will eventually demand better, or continue accepting slower as the new normal.
