Let's compile Quake like it's 1997!

FABIEN SANGLARD'S WEBSITE

CONTACT    RSS     DONATE

Feb 5, 2026
Let's compile Quake like it's 1997!

The first batches of Quake executables, quake.exe and vquake.exe were programmed on HP 712-60 running NeXT and cross-compiled with DJGPP running on a DEC Alpha server 2100A. In June of 1996, having shipped their title but concerned with NeXT stagnation, id Software switched their development stack.

We moved to Intergraph hardware running Windows NT right after shipping Quake.

- John Carmack[1]

The next versions of Quake, winquake.exe, glquake.exe, and QuakeWorld (qwcl.exe and qwsv.exe) were all developed and compiled on Windows NT with Visual C++ 4.X.
This article describes the steps to re-create the experience of building the win32 binaries of Quake as it happened in 1997.
The purist's cornerDepending on the level of historical accuracy you want to reach, you can follow the steps with four environments.

Find an Intergraph RealizM Dual P6-200MHz workstation (good luck).
Find a dual Pentium Pro machine (good luck again but finding a W6-LI is doable).
Use a regular late 90's PC like the Quake PC.
Download Oracle's Virtualbox and create a VM.

I tested these steps both on the Quake PC and in Virtualbox, running either Windows 98SE or Windows NT 4.0.
Installing Windows NT 4Installing Windows NT 4 is pretty easy since the CD is bootable. Installation took 30 minutes.

I love how minimalist Windows NT startup screen is. It proudly displayed how many CPUs are detected (Windows 95/98 only supports one CPU) and how much RAM is there. There is no silly animation.
Adding a second CPU to a system won't be automatically detected by Windows NT. You need to re-install to get the HAL handling SMP systems. The same thing goes with dual CPU motherboard. On a W6-LI, one need not only to add another Pentium Pro but also a regulator!

Windows NT 4 uses the same UI theme as Windows 9X. The first release, Windows NT 3 used the same UI elements as Windows 3.1. It looked awful.
Installing Visual C++ 6The Win32 version of Quake were coded on Visual C++ 4.X since it was the most recent version of Microsoft IDE available in mid-96. However, by 1999, the project had been migrated to Visual C++ 6. If you don't have the CD handily available, you can likely find it on the Internet Archive or winworldpc.com.

In a time before "always on" Internet, most software had a product ID to fight piracy.

The installation screen also brings up the next "Visual Studio", combining many development environments. It would soon become THE Microsoft IDE to rule them all.

The installation screen looks off. There is a lot of empty space and the progress bar is awkwardly placed. That is because Microsoft did not expect this to run at the crazy high resolution of 1280x1024 (which id developers likely used on their 21" monitors). It only looks as intended in 640x480 or 800x600.

With VC++6 installed, we now need to get the source code. DO NOT get it from github or transfer the files via FTP. This will mess up the workspace .dsw file. Then VC++6 will be unable to parse it. And it won't even give you an error message, it will just open and show no file / project associated. And you will lose 1/2 a day trying to debug the problem.
Instead, you need to get q1source.zip. It used to be available on id Software's FTP server but now you can get it from the awesome Quake Official Archive maintained by Jason Brownless[2].

With a VM you can transfer files via drag/drop. Alternatively you can use Quick ‘n Easy FTP Server which works on both 9X/NT.
To decompress q1source.zip, you will need WinRar. The v2.50 still works well on 9X/NT.

Now launch VC++6. Select "Open Workspace" then pick "WinQuake.dsw".
Modern versions of Visual Studio use .sln (Solution) and .vcxproj but Visual C++ 6 uses .dsp and .dsw. The dsp contains a single project while the dsw is a workspace pointing to dsp projects.

Start the build with "Rebuild All"

The build will fail because VC6++ was unable to assemble all the .s files which contain the hand-optimized assembly by Michael Abrash.

The .s file are built with "mycoolbuild" "Custom Build" step which relies on ml.exe assembler. It comes with VC++6 Processor Pack (vcpp5.exe).

First install Visual Studio 6.0 Service Pack 5 (vc6sp5.exe). Of course, launching setupsp5.exe will fail. This is because you need to install MDAC 2.5 .

Don't lose an hour trying to download MDAC from somewhere. You just need to run mdac_typ.exe which is in the same folder created when vs6spp5.exe decompressed itself.

Go back and run setupsp5.exe. This time it will work. By now it should feel like you are following the solution of Monkey Island. Nothing makes sense. We are definitely deeeep into the 90s.

More awkwardly small progress bar but this is still progress.

Install VC++6 Processor Pack (vcpp5.exe). Now you should see ml.exe next to cl.exe in VC++6 bin folder. Re-open the project with VC++6 and run "Rebuild All " again. This time it should work.

Yup it built! You need to copy PmProXX.dll, WdirXX.dll, and id1 and the game should launch. You can even build/run QuakeWorld and it works with QSpy!

A darn good IDEVC++6 is remarkably powerful for 1996. It has features such as "Go to definition", breakpoints, stacktrace, and variable inspections (but no Intellisense auto-completion yet). I never used it but it must have felt like a dream at the time.

References^ [1]Conversation with John Carmack.^ [2]Quake Official Archive
*

The compilation of Quake in the context of 1997 involves tracing the evolution of its development environment and navigating the complex process of recreating the original build steps. Initially, the first batches of Quake executables, quake.exe and vquake.exe, were programmed on an HP 712-60 running NeXT and cross-compiled using DJGPP on a DEC Alpha server 2100A. Due to stagnation issues with NeXT, id Software subsequently shifted their development stack, migrating to Intergraph hardware running Windows NT after shipping the title.

The subsequent versions of Quake, including winquake.exe, glquake.exe, and QuakeWorld, were developed and compiled on Windows NT utilizing Visual C++ 4.X. Attempting to recreate this experience involves selecting a specific historical environment, which presents four potential setups, including an Intergraph RealizM workstation, a dual Pentium Pro machine, a regular late 90s PC, or using a VirtualBox instance. Testing these steps revealed that installing Windows NT 4 was straightforward, though the operating system displayed a minimalist startup screen, indicating the detection of CPUs and RAM. A key technical point is that Windows NT 4 required reinstallation to correctly handle Symmetric MultiProcessing (SMP) systems, as dual-CPU motherboards necessitated specific handling by the Hardware Abstraction Layer.

The migration to the Visual C++ environment required moving from Visual C++ 4.X to Visual C++ 6. The installation process highlighted a shift in the development ecosystem, noted by the installation screen which sought to consolidate various development environments but appeared visually awkward given the high resolutions common on 21-inch monitors.

Recreating the source code is a crucial, error-prone step. To avoid corruption of the workspace files, developers must obtain the source code from the Quake Official Archive rather than direct transfer methods like FTP or GitHub. Decompressing the required files necessitates using WinRar. The process involves launching Visual C++ 6 and selecting the workspace file, WinQuake.dsw.

The build process encountered significant technical hurdles, particularly concerning the assembly files. The initial build failed because Visual C++ 6 could not assemble the .s files, which contained highly optimized assembly code developed by Michael Abrash. This required installing Visual Studio 6.0 Service Pack 5 (vc6sp5.exe). A complex intermediary step involved manually running mdac_typ.exe to install the necessary MDAC 2.5 components, as the standard setup process would fail. Subsequently, installing the Visual C++ 6.0 Processor Pack (vcpp5.exe) made the necessary assembler files (ml.exe and cl.exe) available within the Visual C++6 binaries. Reattempting the build with this updated environment successfully compiled the code, requiring the copying of specific DLL files such as PmProXX.dll and WdirXX.dll for the game to launch correctly. This painstaking process demonstrates the challenges inherent in maintaining and recreating legacy software environments where specialized compiler packs and specific dependencies must be manually sequenced to yield a functioning result.