A good programmer is careful to add comments and clarification to their code. From the sound of things, legendary games industry programmer Randy Linden extends this practice to conversations.

“Does that make sense?” Linden frequently asks this question while recounting his 40-year career. He offers this question kindly, thick with a native Toronto accent, from his home office in the Seattle area, and he saves the question for the thickest technical breakdowns—the ones that arguably changed the game industry forever.

There was the time he built his first emulation software suite, and quite possibly the first commercial emulator ever sold, to run Commodore 64 software on the newer Amiga. (Linden would later become famous for Bleem, another emulation suite which raised Sony’s legal eyebrows.)

There was the time he somehow pushed the underpowered Super Nintendo to natively render the id Software classic DOOM, all without referencing that game’s source code. And there was the time he not only ported an astonishing Quake proof-of-concept to the anemic Game Boy Advance (again, without any source code from id Software) but also made his own Quake-like shooter entirely in Assembly language, entirely by himself, which he ported to equally ill-fitting platforms: the Nokia Symbian, the Amazon Fire TV, even the iPod Video (whose screen real estate was crowded out by a click wheel, remember those?).

By the end of a two-hour conversation, Linden lists enough experience, and politely checks in enough times, to fill multiple chapters of a book on a golden age of computer programming—one where the Assembly programming language reigned and Linden swam deftly through its seas. Modern game design doesn’t necessarily require the level of writing-to-the-metal that Linden mastered so many decades ago. But a chance return to the game spotlight has convinced Linden to become a member of Limited Run Games’ “Carbon Engine” team—which, in other words, is a declaration from Limited Run that it has more ambitious retro-emulation projects in the works.

Linden says he’s back to preserve the industry’s history. Yet even he admits that the job wouldn’t have gotten his attention if it didn’t somehow include his favorite form of coding exercise.

“There’s a common thread in all of my past projects,” Linden says. “The majority of engagement and drive on my part is the thrill of accomplishing something on a technical level that the average person doesn't realize how complex and difficult it is to achieve.”

Source code in lockdown

During the depths of the 2020 lockdown, Linden skipped the sourdough-baking trend and dug into a different series of classic recipes: source code. In July of that year, he unearthed and released the original code and tools used in the development of “DOOM-FX” for the Super Nintendo. His reason? To fill a gap in the public coding consciousness.

DOOM FX courtesy Digital Foundry

“There was no sample source code [on the Internet] for an entire Super NES game, or one that used the SuperFX [chip], and I felt it was important to help other programmers learn and grow,” Linden says.

Talk about an educational document. Fans have long described DOOM-FX as an “impossible” port of the id Software first-person shooter, and for good reason: the SNES, even with the help of a Super FX2 co-processor, fell well short of the PC classic’s minimum spec of a 66 MHz CPU and 8 MB of RAM. On the eve of the SNES port’s 25th anniversary, this compromised-but-playable build was finally laid bare to fans.

Shortly after its release, popular YouTube tech analysts like Dimitris Giannakis (Modern Vintage Gamer) and John Linneman (Digital Foundry) championed the source code while also raising Linden’s profile to a wider audience. YouTube viewers soon learned what the industry’s savviest programmers had known for years: that Linden was a programmer beyond compare, backed by decades of experience.

As a child, Linden got his computing start in the late 1970s with Commodore PET 2001 machines available at his school’s library, which could only be used if students reserved time. He was so hooked on a self-taught programming regimen that his mother bought his family a Commodore 64, which he used to code his first game: Bubbles, a shameless Centipede clone. The fearless 13-year-old Linden then flipped through a computer magazine until he found an advertisement with a Toronto mailing address—down the road from his school.

Centipede, courtesy Atari

“I called them up and said, ‘I've got this game, are you interested in in seeing it?’” Linden says. The publisher, Syntax Software, was a husband-and-wife operation based out of an apartment, and they only learned Linden’s age once he walked over after a school day to drop off a disk. “They were kind of shocked that I was as young as I was, but they said, ‘absolutely.’”

The 64 Emulator

Before Linden was old enough to drive a car, he’d already been “poached” from a Toronto-area programming apprenticeship. He’d been connected to a software firm as part of a high school program, only to meet disgruntled staffers who wanted to splinter off and start their own firm. His first job was to develop a Commodore 64 office and productivity suite, which, like most other software at the time, was written entirely in machine language and Assembly. “That was the only way to get the program to be fast enough, responsive enough, and have enough memory left over on the Commodore 64,” Linden says.

Pocket Office sold well and consistently enough for the company to run into a problem: the Amiga had no backwards compatibility with C64 and C128 machines, which left libraries of Pocket Commodore 64 software and files in the dust. “Also, what about [our customers’] games?” Linden says. “Wouldn’t it be cool if they could use their software on the Amiga?”

With that, the 64 Emulator was born, and it was possibly the first of its kind. As an interpretive emulator, Linden’s creation favored compatibility over speed, and he clarifies that his software ran original C64 routines as accurately as possible in order to not break any on-disk copy protection baked into games and software. The program also required a homemade parallel port cable that would connect an older Commodore 1541 disk drive to an Amiga. Linden outsourced the peripherals’ production to fellow hobbyists: “They were all handmade in a basement in Toronto,” he says.

This level of porting and emulation fearlessness persisted through Linden’s career. Upon seeing the Laserdisc arcade game Dragon’s Lair at an arcade, Linden immediately imagined a version that would work on a lowly Amiga. (He made it happen, and he clinched the deal with Dragon’s Lair’s licensors before turning 18.) After attending a developer-only reveal of Nintendo’s SuperFX chip, Linden convinced himself that he could one-up the version of Star Fox he saw with a port of the even more computationally expensive DOOM. (He made it happen, largely inspired by the office DOOM LAN parties that had taken over his game-studio workplace.) And the first time he placed a Sony PlayStation 1 disc into a PC and discovered an unencrypted file system, he began plotting an emulator, eventually named Bleem, that would expand PlayStation game access to the complete Windows 95 ecosystem. (This, too, he made happen.)

During each of these eras, the common programming assumption was that Linden was attempting the impossible. But his emphasis on writing his own engines, using the lowest-level machine languages, came with a savvy that the otherwise-humble Linden freely admits to: “I have a good gut instinct on whether or not something is technically feasible,” he says. “Since I started [my career] on much less capable systems, I'm pretty good at knowing when we're approaching the limits of the given target hardware’s capabilities.”

In the years since, Linden has talked openly about each of these monumental programming efforts, though on the eve of his latest venture, he has one more surprise claim to share: “Bleem was the original demo used to pitch the Xbox concept to Bill Gates.”

As Linden tells it, a Microsoft contact contracted Linden and his team to build a special version of Bleem, which natively and nimbly ran nearly all PS1 games on Windows PCs. This version would not have additional features; instead, it had all splash screen mentions of “Bleem” removed. Details were mum, beyond the fact that the demo would be shown to “some important people at Microsoft.” Linden quietly hoped this demo would lead to Microsoft buying or licensing Bleem’s functionality.

“We found out a few years later that they used [our build] to pitch the Xbox project as a whole,” Linden says. “To show, ‘Hey, this can be done on a PC. We're going to base the kernel and the operating system of the Xbox on basically PC technology.” Gates watched a Windows-compatible PC “natively” and instantly run PlayStation games in this meeting, and he was reportedly sold.

Linden claims that he’d heard a rumor at the time about Microsoft’s then-secret console: the “X” in “Xbox” may have originally meant “cross.” “You’d stick discs from different consoles into it, and it would play them,” he says. The rumor has never been corroborated, but that possibility, combined with Bleem’s quick-and-dirty Microsoft collaboration, was enough to make Linden wonder if his programming future might continue as part of a major Microsoft project.

Cross play and emulation

As it turns out, that’s exactly what happened... one console generation later.

In the wake of Bleem and Bleemcast winding down, Linden worked on an aforementioned Quake-for-GBA project on his own dime in hopes of courting a publisher. That didn’t pan out, but soon after, two different teams at Microsoft reached out with hopes of hiring Linden, and he opted to join a team responsible for developer outreach and tools. (The other team was interested in Linden’s expertise in copy protection and DRM, which he’d been honing since his C64 days.) “I’ve always been a tools guy,” Linden says, “and the tools that developers use make or break a platform.”

That meant fewer flashy ports over the next ten years, and more fascinating tools that made developers’ lives easier through the lifespan of the Xbox 360. He argues that his team’s work on Kinect saved that Wii-like peripheral by helping devs parse the data spewing out of its myriad sensors; without his team’s tools, Linden says, “Kinect’s adoption would be very, very low.” And he takes partial credit for reinforcing a “forwards and backwards-compatible” directive within the Xbox Development Kit (XDK), so that developers on large, multi-year projects could trust that whatever they were coding wouldn’t be broken by something Microsoft did halfway through development.

Though Linden remains fond of his Microsoft tenure, and suggests he could have seen himself remaining at the company to this day, he makes no bones about his new job: he’s back to the porting business.

“I have been tapped because of my background and expertise in emulations, in games, in technology, and in making the impossible happen,” Linden says. He is unable to confirm exactly what he’s working on, beyond suggesting that retro game fans will be “pleasantly surprised” by the projects. He points to his expertise in reducing input lag and applying modern-day effects to older games, including higher resolutions and retro-styled visual filters. He also mentions, unprompted, that Limited Run releases projects not only on current-gen platforms but also classic platforms, including cartridges from as far back as the Atari 2600.

While describing his new job in relatively vague terms, Linden repeatedly mentions his interest in game history. He compares the modern emulation ecosystem to art preservation, then insists that Bleem’s legal victories over Sony set a number of emulation-in-retail precedents that all three major console manufacturers benefit from to this day. But while he’s excited about translating and updating old games for new platforms, his fervor for the industry also recognizes an important bridge built from one generation of developers and programmers to the next.

“Every good programmer recognizes that they stand on the shoulders of the giants that came before them,” Linden says. I interrupt to ask what it’s like to be one of those giants, at which point he corrects an earlier assumption I’d made. Linden’s earliest programming efforts were not entirely self-taught.

When Linden first experimented with programming at his middle school library, he noticed a name attached to a Space Invaders clone that he’d been playing. Its creator, Jim Butterfield, happened to live in Toronto. The 13-year-old Linden picked up a phone book, flipped to the Bs, and made a phone call. As it turns out, part of his current outreach isn’t just to promote a new job. It’s to fulfill a lifelong principle that he learned from Butterfield picking up his phone that day.

“Jim was very happy to spend time and answer all the questions I had, and I never forgot that,” Linden says. “When people ask me questions... I’ve generally kept a low social media profile. I don’t have many followers or do a lot of posting. But if somebody contacts me, I always answer them. That’s something I was brought up with. You’ve got to reach down and help pull up the other people. That’s what Jim did for me. I’m just paying it back.”