Demaking the Undemakable: How a Veteran Developer is Bringing Doom to the Commodore 64

The phrase "Can it run Doom?" has evolved from a practical hardware inquiry into one of the internet’s most enduring tech memes. Over the past three decades, id Software’s seminal 1993 first-person shooter has been ported to an absurdly diverse array of non-traditional devices: digital cameras, pregnancy tests, oscilloscopes, office printers, vaporizers, automated teller machines (ATMs), and even within Doom itself.

Yet, one of the most elusive frontiers for the legendary shooter has always been the retro hardware of its own contemporary era. Specifically, the Commodore 64—the legendary 8-bit home computer that dominated the 1980s but was already entering retirement by the time Doom revolutionized the PC gaming landscape.

Now, veteran game programmer and engineer Steve McCrea is attempting to turn what was once deemed a technical impossibility into a reality. By adapting techniques from his past retro projects and employing ingenious programming workarounds, McCrea is successfully building a highly functional, visually recognizable port of Doom for the Commodore 64.

Main Facts: The C64 Doom Project

At the heart of this technical feat is Steve McCrea, a seasoned software engineer whose professional portfolio includes high-profile contributions to several titles in Nintendo’s Metroid franchise and the virtual reality port of Capcom’s Resident Evil 4. His latest endeavor, however, is a passion project focused on the 8-bit Commodore 64 (C64).

+-------------------------------------------------------------------+
|                          PROJECT OVERVIEW                         |
+----------------------+--------------------------------------------+
| Lead Developer       | Steve McCrea ("Kweepa")                    |
| Target Platform      | Commodore 64 (MOS 6510 CPU, 64KB RAM)      |
| Core Engine Tech     | Tile-grid ray casting (adapted from VIC-20)|
| Current Map Progress | E1M1 through E1M8 fully implemented        |
| Key Features         | Variable heights, dynamic lighting, skybox |
+----------------------+--------------------------------------------+

Technical Architecture

The C64 version of Doom is not a direct port of the original 1993 PC source code, which relied on complex binary space partitioning (BSP) trees to render true 3D environments. Instead, McCrea’s project is a highly optimized, pseudo-3D "demake."

• The Foundation: The project utilizes code originally written for The Keep, a first-person dungeon crawler McCrea developed for the Commodore VIC-20—the C64’s direct predecessor.
• Ray Casting Engine: The game calculates 3D perspective using a customized ray casting technique mapped onto a two-dimensional tile grid, similar to the rendering pipeline of Wolfenstein 3D.
• Overcoming 2D Limitations: Unlike traditional flat-grid ray casters, McCrea’s engine supports advanced geometry features that mimic Doom‘s variable elevation:
  • Variable floor and ceiling heights.
  • Functional vertical elevators and lifts.
  • Interactive, sliding doors.
  • Visible weapon sprites overlaying the viewport.
  • Dynamic, variable lighting sectors that shift based on player position or environment events.
  • A simulated skybox background.

Currently, McCrea has successfully built and rendered the geometry for the first eight levels of the original shareware episode of Doom (Knee-Deep in the Dead), spanning maps E1M1 through E1M8.

Chronology: The Parallel Histories of Commodore and id Software

To understand why a C64 port of Doom is such a monumental achievement, one must examine the timeline of home computing and the rapid, cutthroat evolution of 3D graphics during the late 20th century.

[1982] Commodore 64 launches, dominating the 8-bit home computer market.
  │
[1992] (May) id Software releases Wolfenstein 3D. Apogee begs for a C64 port; id declines.
  │
[1993] (December) id Software releases Doom on PC, setting a new standard for 3D gaming.
  │
[1994] (April) Commodore International files for bankruptcy; C64 is discontinued.
  │
[2011] Steve McCrea releases "The Keep" for the VIC-20, proving 3D ray casting on 8-bit chips.
  │
[2026] McCrea showcases a working WIP of Doom on C64, featuring E1M1-E1M8 and dynamic lighting.

• August 1982: Commodore Business Machines releases the Commodore 64. Boasting 64 kilobytes of RAM and superior sound and graphic chips for its time, it goes on to become the highest-selling single computer model of all time.
• May 1992: id Software releases Wolfenstein 3D on MS-DOS. The game popularizes the first-person shooter genre. Scott Miller, founder of Apogee Software (the game’s publisher), formally requests that id Software develop a port for the Commodore 64 to capture the lingering 8-bit market. id Software rejects the proposal, declaring that the C64’s hardware is fundamentally incapable of running a real-time first-person ray caster.
• December 1993: id Software releases Doom. The game introduces non-orthogonal walls, variable heights, light dimming, and outdoor skies—features that push even cutting-edge 1993 IBM-compatible PCs to their absolute limits.
• April 1994: Struggling to transition into the 16-bit and 32-bit eras, Commodore International files for voluntary bankruptcy. Production of the Commodore 64 officially ceases, just months after Doom has completely rewritten the rules of game development.
• July 2011: Steve McCrea releases The Keep for the Commodore VIC-20, a machine with only 5KB of RAM. The project proves that 8-bit MOS Technology processors can handle real-time pseudo-3D viewport rendering if the codebase is sufficiently optimized.
• Mid-2020s: McCrea begins adapting The Keep‘s assembly rendering engine to the Commodore 64, shifting his focus from a grid-locked dungeon crawler to a faithful recreation of Doom. Over months of iterative updates, he adds weapon overlays, elevator physics, variable sector heights, and dynamic lighting, culminating in the showcase of a playable E1M1 through E1M8.

Supporting Data: The Hardware Chasm

The primary reason a C64 port of Doom was considered impossible in the 1990s lies in the massive disparity between the system specifications of a 1982 Commodore 64 and a 1993 IBM-compatible PC.

Hardware Specification Comparison

Computational Mathematics: The 8-Bit Constraint

The Intel 386 CPU is a 32-bit processor capable of executing complex 32-bit arithmetic instructions in a single clock cycle. By contrast, the MOS 6510 inside the C64 is an 8-bit processor.

To perform the division and multiplication calculations required to project a 3D wall onto a 2D screen, the C64 must break down every single multi-byte mathematical operation into dozens of individual 8-bit additions, subtractions, and bit shifts.

McCrea’s engine overcomes this mathematical bottleneck by:

1. Look-Up Tables (LUTs): Pre-calculating trigonometric values and division scales and storing them directly in the C64’s limited memory, trading precious RAM to save CPU cycles.
2. Tile-Grid Restrictions: Restricting wall angles to a grid-aligned system, dramatically simplifying the ray-intersection mathematics compared to Doom‘s original arbitrary-angle line segments (linedefs).

Official Responses and Industry Reactions

The emergence of McCrea’s work-in-progress build has sent shockwaves through both the retro-computing community and the veterans of the 1990s shareware boom.

Scott Miller’s Vindication

The most notable reaction came from Scott Miller, the founder of Apogee Software and a key figure in the early history of id Software. Upon viewing McCrea’s gameplay footage on social media, Miller expressed amazement, reflecting on his historical attempts to get a similar project greenlit:

"Back when we released Wolf3D I begged Id to make a C-64 version and they said it wasn’t possible. Now I’m crying."

Miller’s comment highlights a historical irony: the creators of Doom and Wolfenstein 3D—including legendary engine programmer John Carmack—believed the C64 lacked the raw processing power to draw a first-person perspective at an acceptable framerate. Thirty years later, modern assembly-language optimization techniques have proved them wrong.

The Search for a Musician

While the visual engine, level layouts, and physics are rapidly approaching completion, the project still lacks a critical component: a soundtrack. McCrea has publicly called for assistance from the retro-music community to help translate Bobby Prince’s iconic heavy metal and ambient Doom MIDI soundtrack into files compatible with the C64’s legendary MOS SID sound chip.

                       [ WANTED: MUSICIAN ]

  The C64 Doom engine needs a sound designer capable of pushing 
  the MOS SID chip to its limits. 

  Goal: Translate Bobby Prince's iconic 1993 MIDI soundtrack into 
  legendary 3-voice SID chiptunes.

In discussions online, fans have jokingly (and half-seriously) suggested recruiting legendary European chiptune composers such as Chris Hülsbeck (famed for his work on Turrican) or Jeroen Tel to bring the project’s audio to life.

Implications: The Legacy of "Demaking"

The successful execution of Doom on a Commodore 64 carries profound implications for our understanding of computer science, legacy hardware optimization, and the philosophy of retro development.

The Philosophy of Software Optimization

In the modern software development landscape, developers often rely on raw hardware power—multi-core gigahertz processors and gigabytes of video memory—to brute-force performance issues. "Demakes" like McCrea’s C64 Doom serve as masterclasses in extreme software optimization. They demonstrate that when a programmer is forced to work within rigid hardware limits, creative engineering can bypass physical constraints.

+-----------------------------------------------------------------+
|                  HOW THE C64 RENDERER WORKS                     |
+-----------------------------------------------------------------+
| 1. Player rotates/moves -> Engine casts rays through a 2D grid.  |
| 2. Ray hits wall -> Engine pulls distance from Look-Up Table.   |
| 3. Engine scales the wall slice vertically based on distance.   |
| 4. Dynamic light level applied to the slice before drawing.     |
| 5. Skybox drawn in background; weapon sprite drawn in foreground|
+-----------------------------------------------------------------+

Redefining Historical Capability

McCrea’s project retroactively changes our understanding of what the Commodore 64 was capable of during its commercial lifecycle. Had a developer utilized these exact mathematical shortcuts and ray casting techniques in 1993, the C64 might have enjoyed a prolonged commercial lifespan, proving that the machine’s limitations were not entirely physical, but rather a reflection of the programming paradigms of the era.

Ultimately, C64 Doom stands as a monument to human ingenuity. It bridges a forty-year-old gap between the twilight of the 8-bit microcomputer revolution and the dawn of the 3D gaming era, proving once and for all that with enough determination, passion, and assembly code, Doom truly can run on anything.