Four Quakes and a missing shader

The short version

The fix is not an old OpenGL DLL, a Windows compatibility mode, or the custom MoltenVK used for Quake II RTX. It is to launch the modern 64-bit Nightdive remaster, force its D3D11 renderer, tell KEX to compile its HLSL shaders at startup, and route XAudio through CrossOver’s correctly named Wine/FAudio implementation.

The executable named quake_gog.exe is not an outside download. It ships inside the installed Steam depot alongside quake_x64_steam.exe and uses the same remaster assets. Choosing it removes the Windows Steam client from the launch chain, trading Steam overlay and Steam-specific achievements for a smaller, confirmed path.

This was not one broken Quake. It was one launcher menu hiding several different engines, followed by two separate renderer failures.

Legacy glquake.exe: Failed

Steam option 3 launched the 32-bit 1997 Rogue mission-pack executable; it repeatedly returned exit code 1.

Remaster Vulkan: Failed

The 64-bit KEX remaster entered Vulkan device setup, printed limits, then exited before renderer initialization.

D3D11 without compilation: Failed

DirectX 11 initialized, but KEX requested default_vs_5_0.bin, which was absent from the package.

D3D11 runtime compilation: Verified

KEX compiled the shader sources with D3D Compiler 47 and completed a clean gameplay session.

“Quake” in Steam is at least four launch targets

Steam App ID 2310 installs both historical binaries and the enhanced KEX release. Its launch-option metadata maps the top-level Quake entry to the remaster, then offers three “Original” entries based on glquake.exe.

Quake

rerelease/quake_x64_steam.exe: modern 64-bit KEX remaster

Quake (Original)

glquake.exe: 1997 32-bit OpenGL client

Scourge of Armagon

glquake.exe -hipnotic: original mission-pack route

Dissolution of Eternity

glquake.exe -rogue: original mission-pack route

The working direct launcher uses a fifth file in the remaster directory: quake_gog.exe, shipped in the same Steam depot but independent of Steam API startup.

The failed Steam sessions all recorded user response 3, followed by this process:

Game process added: "…\Quake\glquake.exe" -rogue
…
AppID 2310 no longer tracking PID …, exit code 1

That explains the first symptom but not the whole problem. Selecting the correct modern executable avoids the legacy route; it does not by itself make the remaster’s default Vulkan renderer survive CrossOver.

The diagnosis crossed three independent failure boundaries

Failure 1: the historical executable

glquake.exe is PE32 Intel 80386 code from a very different Windows/OpenGL era. Three observed attempts ran for only a few seconds and returned exit code 1. Repairing that executable would solve the wrong problem: the installation already contains a maintained x86-64 remaster with the original campaign and both mission packs.

Failure 2: the KEX Vulkan renderer

Launching quake_gog.exe without renderer arguments correctly initialized KEX user data, files, input, sound, SDL, and video. It then chose Vulkan, enumerated entry points and device limits, reached maxPushConstantsSize: 4096, and disappeared with process status 3. There was no final KEX exception in stderr.txt.

Initializing RHI and renderer
Initializing Rendering Hardware Interface
vkGetInstanceProcAddr: … not found
kexVKDevice::Create: maxBoundDescriptorSets: 8
kexVKDevice::Create: maxImageDimension2D: 16384
kexVKDevice::Create: maxPushConstantsSize: 4096
[process ends before “Vulkan Initialized” or “Quake Initialized”]

Failure 3: D3D11 chooses a shader profile the depot lacks

KEX accepts renderer cvars directly on its command line. The important syntax is +r_rhirenderfamily d3d11, not +set r_rhirenderfamily d3d11. The latter was accepted as arguments but did not affect early RHI selection.

With the correct syntax, CrossOver exposed a D3D11 feature-level 11_1 compatibility device and KEX reported DirectX 11 Initialized. It then stopped on its first default shader:

DirectX 11 Initialized
DX Compiler Version: 47
CompileProgram - Loading progs/default
kexRHIShaderManagerD3D11::CompileProgram:
progs/compiled/hlsl/default_vs_5_0.bin not found

The renderer was now correct. The remaining fault was data selection inside the engine.

The missing binary is recoverable because the source shader is present

QuakeEX.kpf is the remaster’s packaged resource archive. Inspection found progs/default.shader and precompiled files such as default_vs_4_0.bin and default_ps_4_0.bin, but not the default_vs_5_0.bin requested after D3D11 advertised feature level 11_1. Other compute programs do have cs_5_0 binaries, so this is not simply a package with no shader-model 5 content.

KEX carries the escape hatch in its own binary:

+d3d11_compileShaders 1

That asks KEX to compile its bundled HLSL sources during RHI initialization instead of requiring every profile-specific binary to exist in the archive. The successful run compiled progs/default, brush models, GPU culling, water, post-processing, UI, and the rest of the renderer, then continued into the game session.

The fix needs no new runtime or source build

The confirmed environment was an Apple M4 running macOS 26.6.1, CrossOver 26.3, and a 64-bit Windows 10 bottle named Steam. Steam had fully installed App ID 2310, build ID 24258635, using its default library path.

1. Install Quake in the existing Steam bottle

   Let Steam finish the approximately 1.9 GB depot and any update. This guide expects the modern rerelease subdirectory, not only the DOS and WinQuake files.

2. Verify the remaster executable and data

   The test below should find the executable, QuakeEX.kpf, and the base-game pack. If it does not, use Steam’s file verification before changing Wine settings.

3. Keep the Quake II RTX workaround separate

   Do not add CX_LIBVULKAN or the Q2RTX custom MoltenVK to this launcher. Quake I’s working route is KEX D3D11 through CrossOver D3DMetal, not Vulkan.

rerelease="$HOME/Library/Application Support/CrossOver/Bottles/Steam/drive_c/Program Files (x86)/Steam/steamapps/common/Quake/rerelease"

test -x "/Applications/CrossOver.app/Contents/SharedSupport/CrossOver/bin/wine" \
  && echo "CrossOver: OK"

test -f "$rerelease/quake_gog.exe" \
  && test -f "$rerelease/QuakeEX.kpf" \
  && test -f "$rerelease/id1/pak0.pak" \
  && echo "Quake remaster: OK"

file "$rerelease/quake_gog.exe"

The final command should identify a PE32+ x86-64 Windows executable. No compiler, winetrick, registry edit, DLL replacement, or app-bundle modification is required.

Install a launcher that fixes identity and renderer together

The launcher chooses the Steam-bundled GOG executable, verifies its engine and base-game archives, and pins the validated Apple Silicon route: KEX D3D11 → CrossOver D3DMetal → Metal. It also keeps MSync enabled, skips the KEX startup sequence, sets the remaster directory as its working directory, forwards optional caller arguments, then appends the required renderer and game-specific controls so they win if conflicting values were supplied earlier.

The backend and synchronization variables preserve the working route if the bottle’s graphics setting changes later. The direct KEX switch -skipmovies, reinforced by g_showintromovie 0, bypasses startup movies, legal logos, and the warning screen without involving Steam. The audio controls remain diagnostic rather than corrective: distortion survived uninterrupted play, low volume, 50 and 100 ms of mix-ahead, disabled reverb, and disabled low-pass filtering. That evidence moves the next test below KEX’s optional DSP.

Quake imports Microsoft’s bundled XAudio2_9Redist.dll by that exact name, while CrossOver provides its Wine/FAudio implementation as xaudio2_9.dll. Wine has no built-in xaudio2_9redist alias, so a bottle-wide override cannot perform this comparison safely. The experiment therefore stays inside a private, disposable sidecar; the original executable and Microsoft DLL remain untouched.

An initial two-file sidecar reached MSync and then exited before KEX wrote a new log. Adding application-relative engine data, supporting DLLs, and game directories did not move that boundary: a second attempt also stopped before KEX. The renamed Wine module was therefore the failed mechanism, not a valid FAudio test. The corrected experiment patches the disposable executable copy’s single 19-byte import from XAudio2_9Redist.dll to the shorter xaudio2_9.dll, padded in place, so Wine can load its implementation under its real module identity. The original executable remains byte-for-byte untouched.

The links still make the sidecar application directory complete without copying the large resources:

game_dir="$HOME/Library/Application Support/CrossOver/Bottles/Steam/drive_c/Program Files (x86)/Steam/steamapps/common/Quake/rerelease"
system32="$HOME/Library/Application Support/CrossOver/Bottles/Steam/drive_c/windows/system32"
faudio_dir="$game_dir/quake-m4-faudio"

mkdir -p "$faudio_dir"
cp -p "$game_dir/quake_gog.exe" "$faudio_dir/quake_gog.exe"

python3 - "$faudio_dir/quake_gog.exe" <<'PY'
from pathlib import Path
import sys

path = Path(sys.argv[1])
old = b"XAudio2_9Redist.dll"
new = b"xaudio2_9.dll"
data = path.read_bytes()
if data.count(old) != 1:
    raise SystemExit(f"expected one XAudio import, found {data.count(old)}")
path.write_bytes(data.replace(old, new + b"\0" * (len(old) - len(new))))
PY
chmod 755 "$faudio_dir/quake_gog.exe"

for entry in QuakeEX.kpf SDL2.dll PartyWin.dll PartyWin7.dll PartyXboxLive.dll \
    build.vdf ctf dopa hipnotic id1 mg1 mg3 progs rogue; do
    link="$faudio_dir/$entry"
    if [[ -e "$link" && ! -L "$link" ]]; then
        print -u2 "Refusing to replace non-link sidecar entry: $link"
        exit 1
    fi
    ln -sfn "../$entry" "$link"
done

python3 - "$faudio_dir/quake_gog.exe" <<'PY'
from pathlib import Path
import sys

data = Path(sys.argv[1]).read_bytes()
assert b"XAudio2_9Redist.dll" not in data
assert data.count(b"xaudio2_9.dll") == 1
PY
[[ -f "$system32/xaudio2_9.dll" ]]
[[ -f "$faudio_dir/QuakeEX.kpf" ]]
[[ -f "$faudio_dir/SDL2.dll" ]]
[[ -f "$faudio_dir/id1/pak0.pak" ]]

Silent completion is the expected result. The launcher defaults to this import-patched FAudio sidecar. In the final test, plain quake-m4 launched successfully and no digital crackle was audible. QUAKE_XAUDIO_BACKEND=native retains the untouched game directory and Microsoft redist as a control.

KEX also allocates a D3D11 timestamp query even when dynamic resolution is disabled. D3DMetal 3.0 implements that query as immediate no-op methods, reports it complete, and emits one unsupported-API line. There is no KEX timer-query cvar to disable. The launcher therefore pins r_resolutionscale 0, preventing gameplay from depending on unavailable timing data, and filters only that exact diagnostic line from standard output and error. Other D3DMetal warnings remain visible; no framework or game binary is modified.

mkdir -p "$HOME/bin"

cat > "$HOME/bin/quake-m4" <<'EOF'
#!/bin/zsh
set -euo pipefail

# Run the 2021+ Nightdive remaster rather than the legacy 32-bit GLQuake builds.
# CrossOver's Vulkan route exits during device creation on this M4; D3D11 works
# when KEX compiles the missing shader-model 5 binaries at startup.
# Pin D3DMetal and MSync so bottle UI changes cannot reroute this launcher.
# Default to an isolated import-patched FAudio sidecar after KEX DSP did not help.
# KEX creates an unused D3D11 timer query even with dynamic scaling disabled;
# D3DMetal treats it as an immediate no-op but prints one unsupported-API line.
# Skip KEX startup movies, legal logos, and warning screens.
readonly crossover="/Applications/CrossOver.app/Contents/SharedSupport/CrossOver"
readonly game_dir="$HOME/Library/Application Support/CrossOver/Bottles/Steam/drive_c/Program Files (x86)/Steam/steamapps/common/Quake/rerelease"
readonly native_game="$game_dir/quake_gog.exe"
readonly faudio_dir="$game_dir/quake-m4-faudio"
readonly faudio_game="$faudio_dir/quake_gog.exe"
readonly faudio_dll="$HOME/Library/Application Support/CrossOver/Bottles/Steam/drive_c/windows/system32/xaudio2_9.dll"
readonly engine_data="$game_dir/QuakeEX.kpf"
readonly base_game="$game_dir/id1/pak0.pak"
readonly mix_ahead="${QUAKE_MIX_AHEAD:-0.1}"
readonly lowpass_filter="${QUAKE_LOWPASS_FILTER:-0}"
readonly xaudio_backend="${QUAKE_XAUDIO_BACKEND:-faudio}"

if [[ ! -x "$crossover/bin/wine" ]]; then
    print -u2 "CrossOver was not found at /Applications/CrossOver.app"
    exit 1
fi

case "$xaudio_backend" in
    faudio)
        game="$faudio_game"
        xaudio_env="WINEDLLOVERRIDES=xaudio2_9=b"
        ;;
    native)
        game="$native_game"
        xaudio_env=""
        ;;
    *)
        print -u2 "QUAKE_XAUDIO_BACKEND must be 'faudio' or 'native'"
        exit 1
        ;;
esac
readonly game xaudio_env

for required in "$native_game" "$game" "$engine_data" "$base_game"; do
    if [[ ! -f "$required" ]]; then
        print -u2 "The Quake remaster is incomplete or missing: $required"
        exit 1
    fi
done

if [[ "$xaudio_backend" == faudio ]]; then
    for required in \
        "$faudio_dll" \
        "$faudio_dir/QuakeEX.kpf" \
        "$faudio_dir/SDL2.dll" \
        "$faudio_dir/id1/pak0.pak"; do
        if [[ ! -f "$required" ]]; then
            print -u2 "The Wine/FAudio sidecar is incomplete or missing: $required"
            exit 1
        fi
    done

    if LC_ALL=C grep -a -q 'XAudio2_9Redist.dll' "$faudio_game" || \
        ! LC_ALL=C grep -a -q 'xaudio2_9.dll' "$faudio_game"; then
        print -u2 "The FAudio sidecar executable does not contain the patched xaudio2_9.dll import"
        exit 1
    fi
fi

filter_d3dmetal_timestamp_warning() {
    local line
    while IFS= read -r line; do
        [[ "$line" == *"Unsupported API: D3D11 timestamp query"* ]] || print -r -- "$line"
    done
}

exec "$crossover/bin/wine" \
    --bottle Steam \
    --env "CX_ACTIVE_GRAPHICS_BACKEND=d3dmetal CX_GRAPHICS_BACKEND=d3dmetal WINEMSYNC=1 $xaudio_env" \
    --workdir "$game_dir" \
    "$game" \
    -skipmovies \
    "$@" \
    +g_showintromovie 0 \
    +r_rhirenderfamily d3d11 \
    +d3d11_compileShaders 1 \
    +r_resolutionscale 0 \
    +snd_hardwarereverb 0 \
    +snd_lowpassfilter "$lowpass_filter" \
    +snd_mix_ahead "$mix_ahead" \
    > >(filter_d3dmetal_timestamp_warning) \
    2> >(filter_d3dmetal_timestamp_warning >&2)
EOF

chmod 755 "$HOME/bin/quake-m4"
zsh -n "$HOME/bin/quake-m4"

If quake-m4 is not found after installation, invoke "$HOME/bin/quake-m4" directly or add export PATH="$HOME/bin:$PATH" to ~/.zshrc and open a new Terminal.

Run it, wait for compilation, then read the KEX log

quake-m4

The game writes stdout.txt and stderr.txt under the CrossOver user’s Saved Games directory. The first successful milestones should appear within seconds:

Initializing Rendering Hardware Interface
Adaptor Feature Level: AMD Compatibility Mode (11_1)
DirectX 11 Initialized
DX Compiler Version: 47
CompileProgram - Compiling progs/default
…
Running game session
========Quake Initialized=========
Playing demo from demo1.dem.

Extract only those milestones with:

log="$HOME/Library/Application Support/CrossOver/Bottles/Steam/drive_c/users/crossover/Saved Games/Nightdive Studios/Quake/stdout.txt"

grep -E \
  'DirectX 11 Initialized|CompileProgram - Compiling|Running game session|Quake Initialized|Playing demo|Shutting down renderer' \
  "$log"

The final validation began D3D11 initialization at 00:30:45, entered the game at 00:30:49, logged active gameplay through 00:52:14, and completed an orderly shutdown by 00:52:16. This proves more than a splash screen: a level loaded, rendering and audio ran, gameplay events were processed, and teardown completed.

The direct remaster retains the installed Quake library

The rerelease directory contains more than the base campaign. Its data layout includes:

• id1: original Quake campaign and OGG soundtrack;
• hipnotic: Scourge of Armagon;
• rogue: Dissolution of Eternity;
• dopa: Dimension of the Past;
• mg1 and mg3: MachineGames episodes;
• ctf: capture-the-flag resources; and
• QuakeEX.kpf: KEX engine shaders, UI, fonts, and shared assets.

Choose campaigns from the remaster menus rather than launching the historical mission-pack binaries. Before the later launcher overrides, the generated KEX config persisted both renderer values, enabled the intro sequence and hardware reverb, and exposed KEX’s short default audio mix-ahead:

seta g_showintromovie "1"
seta r_rhirenderfamily "d3d11"
seta d3d11_compileShaders "1"
seta snd_hardwarereverb "1"
seta snd_mix_ahead "0.025"

The launcher supplies the renderer values explicitly so deleting or regenerating kexengine.cfg does not resurrect the Vulkan failure, disables the intro sequence, and leaves dynamic resolution off because its D3D11 timing source is unavailable. Raising mix-ahead first to 50 and then 100 ms, disabling hardware reverb and low-pass filtering, avoiding focus changes, and lowering volume did not eliminate the distortion. The import-patched Wine/FAudio sidecar did: the previously audible crackle was absent during the final play and listening test. This isolates the difference to the XAudio backend boundary on this setup, rather than proving that any one KEX DSP setting was responsible. QUAKE_XAUDIO_BACKEND=native quake-m4 remains the bundled Microsoft-redist control. Wine’s macOS driver already prevents App Nap and keeps its CoreAudio unit running continuously, so neither a global macOS power setting nor a speculative sample-rate registry override belongs here.

Each symptom identifies a different layer

The launcher and audio sidecar are cleanly removable

The launcher does not alter Steam’s manifest, original Quake executables, bundled Microsoft XAudio DLL, QuakeEX.kpf, CrossOver’s app bundle, Wine registry, or the Q2RTX sidecar. Its FAudio workaround consists of one patched executable copy and links back to the original resources in quake-m4-faudio. To remove both:

game_dir="$HOME/Library/Application Support/CrossOver/Bottles/Steam/drive_c/Program Files (x86)/Steam/steamapps/common/Quake/rerelease"
rm "$HOME/bin/quake-m4"
rm -r "$game_dir/quake-m4-faudio"

KEX-created saves and settings remain under:

~/Library/Application Support/CrossOver/Bottles/Steam/drive_c/users/crossover/Saved Games/Nightdive Studios/Quake