I, Hacker: Chapter 4, Part 2: “The Doom Paradigm”

Commodore’s headquarters didn’t look like the future.  It looked like a bank that had given up pretending to be cheerful — glass walls, concrete pillars, the faint hum of fluorescent lights that had been left on since the Carter administration.

But once inside, I realized this wasn’t the Commodore I remembered.  The company that had once built hobbyist toys was now a defense contractor in disguise. Their new slogan, printed on every badge and doorplate, was COMPUTE REALITY.

I checked in with a secretary who spoke in acronyms and led me down a hallway lined with framed photos of smiling engineers — ghosts of the optimism that built the first home computer.
She opened a door marked RESEARCH DIVISION C-12.

Inside, four people huddled around a workstation displaying what looked like a video game — a crude 3D environment, walls textured in gray brick, corridors stretching into darkness. The man nearest the keyboard turned, smiling like a salesman who’d just seen God.

“Mr. Smith, right? Commodore’s very excited to have you.”

“Excited” wasn’t a word I’d heard much since the Army.

He gestured toward the screen. “This,” he said, “is Doom.”

They called it a game engine, but it was more than that. The prototype ran smoother than anything I’d ever seen — seamless movement through three-dimensional space, dynamic lighting, a first-person viewpoint that made the user feel present. The interface wasn’t designed for fun. It was designed for immersion.

“Imagine,” the man said, “navigating your desktop as if it were a real room. Your folders are filing cabinets. Your documents are books on a shelf. You just… reach for what you want.”

He looked at me expectantly.

“It’s not new,” I said quietly.

He blinked. “Excuse me?”

“The concept. This… environment model. It’s derivative.”

He frowned. “Derivative of what?”

I hesitated. The truth was classified six ways to Sunday. But what they’d built — this 3D metaphor for computing — was identical to a MINDLINK prototype I’d glimpsed years earlier. It had the same recursive rendering logic, the same node-mapping system that simulated “presence” inside a data structure. I leaned closer to the screen. In the code’s debug console, a single line caught my eye:

> MIND_ENV::LOAD_NOMAD_LIB()

My library. The room went out of focus. Voices blurred.  The past wasn’t buried; it had been licensed. They called the new platform Doom OS. The idea was radical and absurd in equal measure: replace the flat, two-dimensional desktop interface with a 3D world users could walk through.
You wanted to open a document? Walk to the shelf. Need to send a message? Go to the “communications terminal.” It was equal parts brilliance and theater — a user interface masquerading as a universe.
And the military loved it. Commodore had secured contracts to deploy Doom OS as a visualization layer for data analysis, training simulations, and classified communications. Civilians would play. The government would watch.

I was hired to “optimize network interoperability.” Translation: make sure the civilian version could talk to the secure one without anyone realizing it. Weeks passed.

 I worked in a small, windowless lab deep in the building’s sublevel — rows of terminals connected to both internal and external Doom networks. The engineers were all young, idealistic, and deaf to irony. They talked about “building the future” while their code quietly built a panopticon. One afternoon, a developer named Patel slid into the chair beside me.
 
“Hey, Smith,” he said. “We’ve been running latency tests across the new PowerPC nodes. Something’s weird. There’s a background process running on every build.” He pulled up the task monitor. There it was:

> /sys/ghost/daemon

Hidden, self-replicating, immune to termination. 

Patel frowned. “You know what that is?”

I looked at it for a long time. It was my code. From Fort Meade. From the MINDLINK testbed.

“No idea,” I said.

That night, after everyone left, I stayed. I opened the daemon’s source and found an embedded tag, commented out near the top:

> // CREATED BY: NOMAD
> // PURPOSE: OBSERVATION

I felt the chill crawl up my arms. Somewhere, somehow, my own ghost code had followed me. Either Commodore had inherited it through one of R0BERT’s transfers… or R0BERT had planted it. I traced the daemon’s network activity. It didn’t log locally. It didn’t even talk to Commodore’s servers. It sent encrypted packets to a hidden node I recognized instantly:

ARPANET.NODE.004.

By the early 1990s, Doom OS had become the darling of the industry. Every government office, school, and research lab wanted it.  Commodore’s market value tripled. The media called it “the next generation of human-computer symbiosis.” And all the while, the daemon watched. Every file opened, every message sent, every document accessed — all quietly mirrored through invisible channels.
Not stolen. Copied. Observed. The perfect surveillance network, disguised as progress. I reported the anomaly, just to play my part. A week later, Patel was reassigned to another project. No explanation. And in my inbox, a message appeared:

> GOOD WORK.
> THE SYSTEM IS STABLE.
> - R0BERT

That night, I went home and stared at my Commodore 64 — still sitting on the same folding table, humming faintly. Its startup screen blinked.

> READY.

Same word. Different world.