The 150-Page PDF That Launched a Empire
In April 2025, Bill Gates did something unusual for a company celebrating its 50th anniversary. He didn’t release a glossy commemorative video or a new product. He uploaded a 150-page PDF of handwritten assembly code to his website and called it “the coolest code I’ve ever written.”
That code was Altair BASIC 1.0 — the first product Microsoft ever shipped, written by Gates and Paul Allen in 1975 on a PDP-10 simulator at Harvard. It’s the code that started the company that now runs Windows, Office, Azure, Xbox, and a significant chunk of the AI infrastructure powering this exact article.
The PDF hit the internet this week via GatesNotes, and the tech world did what it always does with historical source code: posted it on Hacker News, wrote think pieces, and argued about whether you can call 8080 assembly “elegant.” But there’s a better conversation to have here — one that has nothing to do with 8080 register conventions and everything to do with what that code represents, what it says about how much the industry has changed, and why a 50-year-old PDF from a guy who stepped down from his own company two years ago still matters.
What Actually Is This Code?
Altair BASIC was a BASIC interpreter — a program that could read BASIC programming language statements and execute them on the Altair 8800, the hobbyist computer kit that started the personal computer revolution. The Altair had an Intel 8080 processor, 256 bytes of RAM (yes, bytes), and no operating system. You programmed it by flipping toggle switches on the front panel.
Gates and Allen wrote the interpreter on a PDP-10 mainframe at Harvard — a machine roughly a million times more powerful than the Altair would ever be — then cross-assembled it into 8080 machine code. The result fit into 4KB of ROM on the Altair. Four kilobytes. The PDF Gates released is the source code printout of that interpreter, handwritten margin notes and all.
Here’s the thing that gets me: this was written by two 20-somethings in a hotel room in Albuquerque, working against a deadline they set for themselves to prove they could do it. Paul Allen had seen the Altair announcement in Popular Electronics and called Gates with the challenge: “Can you write a BASIC for this?” Gates said yes before he’d even seen the machine. They had no team, no budget, no customers lined up. They had a bet with themselves and a hotel room.
The Hobbyist Era and What It Cost
The Altair BASIC story has a controversial chapter that’s worth telling honestly. Microsoft initially distributed the interpreter through hobbyist channels — you could get it on paper tape for the cost of materials, or copy it from friends. This was the norm in 1975: software was shared freely among hobbyists because there was no commercial software market to speak of.
But as Altair clones proliferated and the hobbyist community grew, Gates wrote his famous “Open Letter to Hobbyists” in 1976, arguing that people who used Microsoft’s code without paying were stealing it. The letter was blunt, angry, and unpopular in the hobbyist community — but it established a principle that defined the next 50 years of the software industry: software could be a commercial product, not just a shared artifact.
That letter is arguably as important as the code itself. It was the moment Microsoft drew a line between “shared among friends” and “commercial product,” and the industry has been negotiating that line ever since. Open source, free software, SaaS subscription models, AI training data — they’re all downstream of that decision.
What the Code Says About Where We Are
Reading about 150 pages of 8080 assembly from 1975 might seem like a museum piece — interesting historically, irrelevant practically. But there’s a thread here that connects directly to how we build software today.
That 4KB interpreter was hand-optimized assembly written by two people who understood every single instruction. There was no framework to hide behind, no package manager to pull in dependencies, no cloud to offload complexity to. You wrote every byte because you had no choice. The constraint wasn’t a limitation — it was the entire discipline.
Compare that to the stack we run now: I’m writing this article on a machine that has more computing power in its idle cycles than the PDP-10 Gates used to write Altair BASIC. The tools we have are incredible. But there’s a cost to every layer of abstraction we’ve added — and I don’t just mean performance overhead.
When you’ve never written code that has to fit in 4KB, you don’t develop the instinct for what’s essential. When every dependency is a pip install or npm install away, you don’t learn what those dependencies are actually doing. The layer cake we’ve built is genuinely useful — nobody’s arguing we should go back to toggle switches — but there’s a skill that atrophies when you can’t see the metal.
I’ve felt this myself, managing an ICT division where we deploy systems that are orders of magnitude more complex than anything Gates and Allen built, and watching my team debug issues by checking logs and restarting services when the real fix required understanding what was actually happening underneath. The abstraction is a superpower until it isn’t, and then it’s a wall.
The 50-Year Arc
Microsoft turned 50 in April 2025. Consider what that means: the company that started with a 4KB BASIC interpreter for a kit computer now employs over 220,000 people, runs cloud infrastructure serving hundreds of millions of users, and is dedicating a significant portion of its resources to building AI models.
Gates’ 50th anniversary message was candid about the bittersweet feeling. “It feels like yesterday” when he and Allen were hunched over the PDP-10 — except it wasn’t yesterday, it was half a century ago. The company he co-founded outlived him as an active leader, outgrew its original mission, and somehow remained the same company through all of it.
That’s remarkable in a way that’s hard to quantify. Most companies from 1975 are gone, acquired, or unrecognizable. Microsoft is still Microsoft — still making the tools billions of people use daily, still arguing about open source and commercial software, still navigating what “a computer on every desk and in every home” means when the computer is now in your pocket and your thermostat and your car.
Gates’ autobiography Source Code: My Beginnings came out alongside the PDF release, and the timing wasn’t accidental. He’s been gone from day-to-day operations since 2008, increasingly focused on philanthropy, and the 50th anniversary seems to have prompted a kind of reckoning with where it all started. The PDF release is partly nostalgia, partly historical documentation, and partly a message: this is where we began, and it was humble.
Why This Matters Now
The Altair BASIC release landed the same week AI coding tools are generating hundreds of code per prompt, the same week Gartner projected the AI security market hitting $2.83 billion, the same week we’re arguing about whether opaque reasoning techniques make models harder to monitor.
There’s a through-line there, even if it’s not obvious. The industry has gone from two people writing 4KB of assembly in a hotel room to systems so complex that we need AI to help manage them — and we’re starting to worry that the systems are becoming harder to understand than the problems they solve.
The 150-page PDF Gates released is a reminder that complexity isn’t new — but the scale is. And scale changes things. A bug in 4KB of assembly affects one machine. A bug in a foundational model affects millions. The chain-of-thought monitoring debate OpenAI’s dealing with right now is, at its core, about the same thing Gates was wrestling with in 1975: how do you build systems you can understand, and what do you do when you can’t?
That’s not a criticism of AI or modern software development. It’s an observation about what happens when something gets big enough. Microsoft survived 50 years by evolving constantly while keeping its core mission intact. The question for the next 50 years — for Microsoft, for the AI companies, for the rest of us building things — is whether the systems we’re building now will be understandable enough to evolve the same way.
The code Gates released is a ghost. It runs on machines that no longer exist, in a language most developers will never touch, solving a problem that was solved differently a long time ago. But it’s also a mirror — a picture of what one of the most important software companies in history looked like when it was small enough to understand completely. That picture is worth looking at, even if only to remember what “understandable” actually means.