GoldenEye 007 PC Port

A native PC port of GoldenEye 007 (Rare, 1997, Nintendo 64), compiled from the GoldenEye 007 decompilation: the original N64 game running from reconstructed source, not the Xbox 360 remaster. v0.2.0 (pre-release) is out for Windows and Linux — including Steam Deck, where the Linux bundle sideloads as-is — and runs the full campaign at a steady 60 fps with known rough edges (see Status and Download).

It's also a case study in AI-agent collaboration on a large, low-level codebase: two coding agents, driven by one person part-time, porting ~230 translation units of unmodified big-endian MIPS game code to a 64-bit desktop. See Background.

Technically, it follows the architecture of the Perfect Dark PC port, the same Rare "Indy" engine family, one hardware generation apart. The unmodified game C sources are compiled for the host; the N64's Reality Signal Processor (RSP) is emulated in software; every other hardware surface (video, audio, input, timers, save storage) is shimmed in a dedicated port/ layer.

Important

You must supply your own GoldenEye 007 ROM. This repository contains no Nintendo code or assets, and no ROM. Nothing here is distributable as a playable game — see Requirements and Legal.

In-engine, running in the port — Bunker 1 and Dam attract views, and a ~15 s clip (the clip itself has no audio track): mission dossier → Facility → Silo → Jungle → Archives.

Quick start

You supply your own GoldenEye 007 N64 ROM (.z64, big-endian; NTSC-U recommended — all three regions are supported, see Requirements). No ROM or game asset is included or distributed. Then:

1. Download the Windows or Linux bundle from Releases and unpack it. The Linux bundle ships its own SDL2, so it runs on any distro — and on a Steam Deck — with nothing installed.
2. Make a data/ folder next to the executable and drop the ROM in as ge007.ntsc-final.z64.
3. Run the one-time asset step: python3 prepare-assets/prepare-assets.py (Python 3.8+, stdlib only).
4. Launch the executable from that folder.

Building from source instead: see Building. Read the Status caveats first — this is a pre-release.

Beyond playing

• Tweak it — ge007.ini and the F10 in-game overlay expose resolution, frame cap, MSAA, texture filtering, FOV/draw distance and mouse feel; launch with -fresh for a clean-slate run.
• Read it — docs/internals.md maps the architecture and the software RSP; docs/porting-notes.md is the catalogue of N64→PC bug classes hit along the way. Game logic in src/ is unmodified decompilation; every hardware surface lives in the MIT-licensed port/ layer.
• Mod it — the port layer, build system and tools_pc/ are yours to extend (see License); CONTRIBUTING.md has the ground rules for getting changes in, and docs/dev/ is the raw engineering record behind every fix.

Contents

• Quick start
• Beyond playing
• Background
• How this differs from the other GoldenEye PC projects
• Status
• Download
• Requirements
• Building · Windows (MSYS2) · Linux
• Running · Default controls
• How it works
• Project layout
• Documentation
• Credits
• Legal
• License

Background

The port was built by two coding agents — a local open-weight model (unsloth/Qwen3.8-27B-GGUF on one RTX 5090, via the pi agent) doing the groundwork (build, boot chain, software-RSP integration, asset pipeline, first frames), and Claude Code (Sonnet 5, Opus 5 for the hardest bugs) joining for the collaborative phase (the 21-level sweep, the ABI finding catalog, SDL input, front end) — handing work back and forth through shared written notes, directed by one person part-time. In short: ~3.5 weeks, ~430 commits, 200+ root-caused bugs logged.

The full write-up (timeline, handoff mechanism, effort breakdown, an honest "what worked / what didn't"): docs/dev/agentic-development.md. The workflow itself: docs/dev-process.md. To cite the project or its findings: CITATION.cff (GitHub's "Cite this repository" menu).

How this differs from the other GoldenEye PC projects

This is a native port of the original 1997 Nintendo 64 game, built from its actual reconstructed source code, the same lineage as the Perfect Dark PC port. The other well-known "GoldenEye on PC" projects are something different: they machine-translate the shipped binary of the unreleased Xbox 360 XBLA remaster, a different game on a different codebase with no shared code with this one.

	This project	GoldenEye-Recomp / Steam Deck build
What it ports	The original Nintendo 64 game (1997)	The Xbox 360 XBLA HD remaster (built ~2007, never released)
How	Decompilation-based source port — human-reconstructed C, compiled for the host; game logic runs as written	Static binary recompilation — the shipped machine code is auto-translated to C; no source-level understanding
Lineage	GoldenEye 007 decompilation + Perfect Dark PC port engine family	Xbox 360 "…Recompiled" static-recompilation family
Renderer	Software RSP → OpenGL	Hardware (Vulkan)
Status	v0.2.0 pre-release; see Status	Playable full game, higher frame rates, online multiplayer
Why it exists	A case study in AI-agent collaboration on a hard low-level codebase	A polished, playable PC release of the remaster

If you just want to play GoldenEye on PC today, use one of the recompilation projects: they are finished and this is not. What's here is the other half, getting the original game running from source.

Status

v0.2.0 (pre-release) — playable, with known rough edges. It runs the full single-player campaign at a steady 60 fps with no known crashes, but cutscenes still glitch frequently, a few in-level music tracks sound wrong, and a handful of cosmetic rendering defects remain. A full end-to-end re-confirmation that all 21 missions are completable start to finish on this build is the point of the pre-release — playtest feedback is welcome.

Working

• Boot → Rare/Nintendo logos → gun-barrel → cast intro, fully rendered.
• Front end: main menu → mission select → difficulty → briefing → mission start.
• All 21 solo missions load, render, and are crash-free. The v0.1.0-era crashing levels (Bunker ii, Statue) and the AI-pacing bug that blocked the final level (Cradle) were root-caused, fixed, and playtest-verified (D191, D193). See docs/dev/LEVEL-STATUS.md.
• Steady 60 fps in normal play — the software RSP runs off the presentation critical path (D248); Video.DisplayFPS (F10) shows it.
• Software RSP (fast3d): textured world geometry, skeletal characters, HUD, the GE-specific color-combiner / render modes and G_TRI4; outdoor skies render correctly (D227); water no longer renders green/pulsing (D229).
• Input: keyboard + mouse and SDL game controllers mapped onto the N64 pad. Mouse is click-to-lock (click to grab, ESC to release) with a GEPD-style proportional aim mode (D194 closed); sensitivity, Y-inversion and the aim/turn split are tunable in ge007.ini or the F10 options overlay.
• File-backed EEPROM saves.
• Audio — software mixer (libultra audio layer → SDL, adapted from the PD port). In-level sound effects and in-level music both play (the D77 silence is fixed).
• QoL: F10 in-game options overlay (fullscreen, resolution, frame cap, MSAA, texture filtering, FOV/draw distance, sensitivity), mute-on-focus-loss, F12 screenshot.
• Windows and Linux (x86_64). The Linux build is compiled on every push by CI and ships with SDL2 bundled, so it runs without installing anything — including on a Steam Deck (see below).

Not yet working / known issues

• Cutscenes — frequently glitch: skipped beats, wrong camera, misplaced or hovering actors, wrong timing (D148/D160/D173; the Dam level-end race is D243). The most visible gap in this release.
• Audio quality on some in-level tracks — wrong-sounding instruments and occasional garbling (D230); silence itself is fixed.
• Some front-end 3D models — the spinning Nintendo logo, and the MISSION COMPLETE / mode-select models — are mispositioned or absent (D75). The gun-barrel Bond intro renders correctly.
• Particle colours cycle through a rainbow palette — bullet-impact sparks and lingering smoke/explosion residue drift through the hues over time instead of holding their intended grey/orange palette (D252; suspect is the RGBA16 fire-tile width/height in the texture importer).
• Water on IsWater levels shows a moving seam between two patterns (D245); pixel strips at the left/right screen edges at non-integer scales (D246). Assorted other cosmetic defects are tracked in docs/dev/GRAPHICS-BACKLOG.md.
• No macOS or ARM support; no controller rebinding UI; no widescreen.

Steam Deck

The Linux bundle is the Deck build. Sideload it (USB or a file manager): unzip, drop your ROM in data/, run prepare-assets once, and add the executable as a non-Steam game. SDL2 is bundled, so no dependencies need installing. The renderer is CPU-bound (software RSP); expect original N64-era performance at 60 fps rather than more. A v0.1.0-era crash on the Deck in Facility (D203) was never reproduced and its prime suspect has since been fixed, but this release has not yet been verified on real Deck hardware.

Download

Get v0.2.0 (pre-release):

• Windows: goldeneye-pc-port-0.2.0-pre-win64.zip — the engine, its runtime DLLs, and the one-time prepare-assets tool.
• Linux / Steam Deck: goldeneye-pc-port-0.2.0-pre-linux-x86_64.tar.gz — same contents; SDL2 is bundled so it runs as-is on any distro or a sideloaded Deck.

Both bundles contain no ROM and no game assets — you supply your own (see Requirements), which keeps the release legal to distribute. The four steps from download to playing are in Quick start; known issues are listed under Status. Earlier builds: v0.1.0 alpha, same page.

You can also build it yourself; see Building.

Requirements

You need a GoldenEye 007 (Nintendo 64) ROM that you legally own, in big-endian (.z64) format, matching one of:

Region	ROMID	ROM filename (in data/)	SHA-1
NTSC-U (US)	ntsc-final	ge007.ntsc-final.z64	abe01e4aeb033b6c0836819f549c791b26cfde83
PAL (EU)	pal-final	ge007.pal-final.z64	167c3c433dec1f1eb921736f7d53fac8cb45ee31
NTSC-J (JP)	jpn-final	ge007.jpn-final.z64	2a5dade32f7fad6c73c659d2026994632c1b3174

US is the recommended and best-tested version.

The port also relies on the decompilation's asset-extraction step, which pulls the level, model, texture and music data out of your ROM at build time. That step, too, requires your ROM and is part of Building.

Building

Prerequisites: CMake >= 3.16, a C/C++ toolchain, SDL2, zlib, OpenGL, Python 3, plus the decompilation's own build dependencies (an IRIX MIPS toolchain via qemu-irix, used only for the one-time asset extraction). See docs/building.md for the full walkthrough and the asset-extraction details.

Windows (MSYS2)

# in the MINGW64 shell
pacman -S mingw-w64-x86_64-toolchain mingw-w64-x86_64-SDL2 \
          mingw-w64-x86_64-zlib mingw-w64-x86_64-cmake \
          mingw-w64-x86_64-python make git

git clone https://github.com/jkdansereau/goldeneye-pc-port.git
cd goldeneye-pc-port
# 1. extract assets from your ROM (see docs/building.md)
# 2. build the port
./build-pc.sh ntsc-final          # or pal-final / jpn-final

Linux

The Linux build is compiled on every push by CI (ubuntu-24.04); the release bundle additionally bundles SDL2 so no system packages are needed at runtime.

sudo apt install build-essential cmake python3 libsdl2-dev zlib1g-dev libgl1-mesa-dev
git clone https://github.com/jkdansereau/goldeneye-pc-port.git
cd goldeneye-pc-port
# extract assets (docs/building.md), then:
./build-pc.sh ntsc-final

The executable is written to build-pc/ge007.x86_64 (on Windows, build-pc/ge007.x86_64.exe).

Running

1. Create a data/ directory in the repo root.
2. Put your ROM in it, named as in the table above (e.g. data/ge007.ntsc-final.z64).
3. Run the executable from the repo root: ./build-pc/ge007.x86_64.

Configuration is written to ge007.ini on first run; game progress lives in ge007.eep. Launch with -fresh to wipe both before starting (a clean-slate run for playtesting).

Default controls

Action	Keyboard / mouse	Controller
Move / strafe	W A S D / arrows	Left stick (or D-pad)
Aim / look	Mouse	Right stick
Fire (Z)	Left mouse / LCtrl	Right trigger
Aim mode (R)	Right mouse / LShift	Left trigger
Use / accept (A)	Space / E / X	A / X
Reload / cancel (B)	R / F	B / Y
Next weapon	Mouse wheel up	RB
Previous weapon	Mouse wheel down	LB
Start	Enter / Tab	Start

The controller layout follows the modern dual-stick scheme used by the console re-releases (left stick move, right stick look, triggers fire/aim, shoulders cycle weapons).

Mouse sensitivity, Y-inversion and the aim/turn split are tunable in the [Input] section of ge007.ini.

How it works

The R4300 game code in src/ is compiled completely unmodified; the decompilation's control flow is treated as ground truth. Everything that would touch N64 hardware is redirected into port/:

• port/fast3d/ — a software RSP. It interprets the GBI display list the game builds each frame and emits OpenGL, bypassing the RDP. Adapted from the Perfect Dark port and extended for GoldenEye's custom GBI.
• port/src/gesched.c — replaces the RCP scheduler; instead of poking RSP registers it drives the software RSP directly.
• port/src/libultra.c — single-threaded shims for the libultra OS API (threads, messages, timers, PI/SI/AI/VI) over the host.
• port/src/{video,audio,input,fs,romdata,config}.c — the SDL2 / OpenGL / filesystem backends.

The 32→64-bit transition forces a small, cataloged class of mechanical ABI-only edits to ROM-serialized structs (pointer-width reconciliation); these change no behavior and are documented individually.

Where it diverges from the Perfect Dark port: GoldenEye's N64 serialized asset formats (level setup, models, backgrounds) are converted offline by a set of Python "sidecar" converters in tools_pc/, rather than fixed up at load time. See docs/internals.md and docs/porting-notes.md.

Project layout

CMakeLists.txt      PC build (parallel to the decomp's Makefile, which is untouched)
build-pc.sh         configure + build helper
src/  include/      the decompilation (game + libultra) - compiled unmodified
port/
  fast3d/           software RSP -> OpenGL
  src/              port layer (main, OS shims, video, audio, input, fs, ...)
  include/          port-facing headers
tools/  Makefile    the N64 build + asset extraction (from the decomp; do not modify)
tools_pc/           PC-port helper + analysis scripts
docs/               see below

Documentation

Key docs are also published as a site: https://jkdansereau.github.io/goldeneye-pc-port/.

Doc	What's in it
docs/building.md	Full build + asset-extraction guide.
docs/internals.md	Architecture, the RSP-emulation approach, GE-vs-PD engine differences, the phased plan.
docs/porting-notes.md	The recurring N64→PC bug classes hit during the port, with fixes.
docs/dev/agentic-development.md	The research angle: the two-agent setup, timeline, handoff workflow, and an assessment of what did and didn't work.
docs/dev-process.md	The investigation workflow in detail — budgets, file partitioning, the finding-log discipline.
docs/dev/	The raw engineering record: the full finding log, per-level status, graphics backlog, playtest matrices, and docs/dev/game-behavior-reference.md (a secondary-sourced playtest reference for how the retail game is meant to behave — repo-only, code is ground truth).
docs/SetupGuide.md, docs/StyleGuide.md	Inherited from the decompilation this repo forks.

Credits

This port is a thin layer on a large amount of other people's work.

Prior work it is built on

• The GoldenEye 007 decompilation — years of effort by Larry Ficken ("kholdfuzion") and the project's contributors; plus zoinkity's GoldenEye documentation, which the decomp started from. This port is a fork of that repository.
• The Perfect Dark PC port (Ryan Dwyer and contributors) — the reference architecture for this port and the source of the fast3d software RSP.
• The Perfect Dark decompilation — the sibling decomp the PD port is built on.
• Carnivorous — author of the Mouse Injector input plugin for 1964 (the "GEPD Edition" bundle). Its mouse-aim behaviour for GoldenEye/Perfect Dark is what our in-game GEPD-style aim mode is modelled on; the implementation here is an independent reimplementation of that behaviour, not derived code. Thanks also to Rice and schibo of the 1964 team for the emulator it shipped with.

Vendored / adapted code

• port/fast3d/ — the software RSP, adapted from the PD port. It originates with the Ship of Harkinian / libultraship fast3d (© Emill, MaikelChan; MIT — see port/fast3d/LICENSE.txt), which itself descends from sm64-port's fast3d and audio mixer.
• port/fast3d/glad/ — OpenGL loader generated by glad (David Herberth, MIT).
• The decompilation toolchain: ido-static-recomp (Emill / decompals), qemu-irix and rabbitizer (n64decomp).
• SDL2 and zlib.

Methodology

• Chris Lewis, "Decompiling a Nintendo 64 Game in 84 Days" (the Snowboard Kids decompilation write-up) — the agent-workflow practices in docs/dev-process.md are adapted from it.

Tools and models used to develop the port

• Qwen 3.8 (Alibaba Qwen team), run locally as the unsloth/Qwen3.8-27B-GGUF UD-Q4_K_XL quant; Unsloth (the GGUF quantisation and Unsloth Desktop, used as the local model server).
• pi — the local coding-agent harness.
• Claude / Claude Code (Anthropic).

Legal

This is a non-commercial fan preservation/research project, in the same category as the many other N64 decompilation and native-port repositories on GitHub. It follows the same conventions they do:

• No ROM and no game assets are distributed — not in this repository and not in any release. Textures, audio, models, level data and in-game text are extracted from a ROM you already own, on your machine, at build time.
• The repository is a fork of the public GoldenEye 007 decompilation and inherits its contents unmodified (see NOTICE for what that includes).
• No official logos, box art, or marketing assets are used. "GoldenEye 007", "007", "James Bond" and related marks belong to their respective owners (Nintendo, Microsoft/Rare, MGM, Danjaq, EON Productions).
• Pre-built binaries published under Releases contain only the engine (the port/ layer plus the compiled decompilation, with no game data of any kind), bundled with permissively-licensed runtime libraries (SDL2, zlib, the MinGW runtime; their licenses travel in the download). Any build, yours or ours, is useless without a ROM you supply.

This project is not affiliated with, endorsed by, or sponsored by Nintendo, Rare, Microsoft, MGM, Danjaq, EON Productions, or any rights holder in GoldenEye or James Bond. If you are a rights holder with a concern, open an issue and it will be addressed.

License

The original work in this repository, the port layer (port/), the PC build system, tools_pc/, and the documentation, is released under the MIT License; see LICENSE. Everything inherited from the upstream decompilation is covered by NOTICE, not by that license.