Somewhere in the source code of Windows 95 — one of the most widely used pieces of software ever released — there is a small block of code whose only job is to ask a single, oddly specific question.
Is the user currently running SimCity?
If the answer is yes, Windows 95 quietly changes how it behaves. It switches its memory handling into a special mode. It does this for one reason: to accommodate a bug. Not a bug in Windows — a bug in SimCity, accidentally left there years earlier by the game’s own programmer.
It is one of the strangest and most revealing decisions in the history of personal computing. And it explains something important about why Windows came to dominate the world.
The bug that wasn’t supposed to matter
The story comes from Joel Spolsky — a former Microsoft programmer, co-founder of Stack Overflow, and one of the most respected writers in software — who heard it directly from the man responsible.
Jon Ross wrote the original Windows version of SimCity, the wildly successful city-building game. And while writing it, Ross made a small mistake. His code, at one point, freed up a chunk of computer memory — handed it back to the system as no longer needed — and then, a moment later, read from that same chunk of memory again.
This is a genuine programming error. It has a name: a “use-after-free” bug. You are not supposed to use memory you’ve already given back. It’s the software equivalent of checking out of a hotel room and then walking back in to use the bathroom.
But here’s the thing. On Windows 3.x — the operating system SimCity was built for — the bug didn’t matter. When SimCity freed that memory, Windows 3.x simply left it sitting there, untouched. So when SimCity mistakenly read it again, the data was still there, exactly as before. The bug was real, but the operating system’s behaviour happened to render it harmless. SimCity shipped, sold over five million copies, and nobody ever knew.
The bug sat quietly inside one of the most popular games in the world, completely invisible, for years.
Then Microsoft built a new operating system.
When SimCity stopped working
Windows 95 was a major leap. It merged the worlds of MS-DOS and Windows, moved from 16-bit to 32-bit software, and overhauled enormous amounts of how the system worked under the hood — including how it managed memory.
And during beta testing, Microsoft’s engineers hit a problem. SimCity — one of the best-selling, most beloved PC games in existence — didn’t work on Windows 95. It crashed.
When they tracked down the cause, they found Jon Ross’s old use-after-free bug. Windows 95 handled freed memory differently from Windows 3.x. When SimCity freed that chunk of memory, Windows 95 was liable to actually reclaim it and reuse it for something else. So when SimCity read from it again, the data was gone or scrambled, and the game fell over.
This put Microsoft in front of a genuine decision. And the decision they made is the interesting part.
Why Microsoft fixed someone else’s bug
The obvious move would have been to pick up the phone, call Maxis — the studio behind SimCity — and tell them to fix their bug and ship an update.
Microsoft didn’t do that. Instead, the company’s engineers added code directly into Windows 95 — code that specifically detects when SimCity is running. When it sees the game, Windows 95 switches its memory allocator into a special mode that doesn’t immediately reclaim freed memory. In effect, Windows 95 deliberately recreates the old, “wrong” behaviour of Windows 3.x — but only for SimCity, and only because SimCity needs it.
Microsoft, in other words, chose to bend its brand-new operating system around a years-old mistake in someone else’s product. They made the OS accommodate the bug.
Why? Because of a brutal piece of business logic that Spolsky lays out clearly.
When a person buys a new operating system and their favourite software stops working, they do not blame the software. They blame the operating system. The customer doesn’t think SimCity has a bug. The customer thinks Windows 95 broke my game — and tells their friends not to upgrade.
For Microsoft, every popular program that broke on Windows 95 was a reason for millions of people not to buy Windows 95. SimCity had sold over five million copies. That’s five million potential customers whose first experience of the new OS could have been their favourite game crashing. The cost of writing a small block of special-case code was almost nothing. The cost of SimCity not working was potentially enormous.
So Microsoft did the unglamorous, invisible, expensive thing. They made it work.
The hidden museum inside Windows
Here’s what most people don’t realise. The SimCity fix is not unique. It is one example of something Windows has done, quietly, for decades.
Buried inside Windows are hundreds of these special cases — little blocks of code that detect specific old programs and games and quietly adjust the system’s behaviour to keep them running. Engineers call them “shims.” Other games have been detected and accommodated. Some are told they’re running on an older version of Windows than they actually are, because they would panic otherwise. Some are quietly fed slightly wrong information, or have specific features disabled around them, purely so they keep working.
Windows, in a real sense, carries a hidden museum of compatibility — a vast, mostly invisible layer of code whose entire job is to keep the software of the past alive on the machines of the present.
It’s why a program written in the 1990s will often still run on a modern Windows PC. That isn’t an accident. It’s the accumulated result of decades of Microsoft engineers making exactly the choice they made for SimCity: accommodate the old software, even its mistakes, rather than break it.
Why this small story matters
It would be easy to read this as a quirky bit of trivia. It’s more than that.
The SimCity fix captures the single most important — and least visible — reason Windows became as dominant as it did. It was never only about features or marketing. It was about a near-obsessive, deeply unglamorous commitment to backward compatibility: the promise, kept across decades, that the things you already own will keep working.
Jon Ross made a small mistake in the early 1990s. Because of a decision by Microsoft’s engineers, that mistake never broke anything for anyone. It was simply absorbed, quietly, into the operating system itself — and a version of that same obsession is still at work in Windows today.
The bug is still there. So is the code that forgives it.
