Nintendo never made a Virtual Console strong enough to keep up with demand for N64 classics, so Project64 has quietly become the default way most PC players run Ocarina of Time, GoldenEye 007, and Mario Kart 64 in 2026. The emulator just crossed into its fourth decade of active development, and the current stable build, Project64 3.0.1, sits alongside nightly 4.0.0 dev builds that add experimental Vulkan rendering through Parallel-RDP. This guide walks through the entire setup from a clean Windows install to a fully configured emulator running upscaled 4K output with HD textures, mapped Xbox or PS5 controllers, and working save states — in 12 steps, roughly 90 minutes start to finish.
Unlike PS1 or PS2 emulation, Project64 setup skips BIOS dumping entirely, which removes one of the most confusing steps for newcomers. What replaces that complexity is plugin management: Project64 splits video, audio, and input into swappable components, and picking the wrong combination is the single biggest reason people give up on N64 emulation. This tutorial covers every decision point, including the graphics plugin comparison, internal resolution scaling, and the eight most common errors people hit during setup.
Don't miss new tech stories on Google
Add Tech Insider once in the Google app and our stories appear in your news suggestions.
What Project64 Is and Why It’s Still the Default N64 Emulator in 2026
Project64 is a Windows-only Nintendo 64 and N64DD emulator that has been in continuous development since the early 2000s. It works differently from most console emulators because it relies on a plugin architecture: separate graphics, audio, and input plugins each handle one piece of the emulation, and users mix and match them depending on the game and hardware. That flexibility is why Project64 survived while several rivals didn’t. simple64, once a popular alternative, was formally archived on February 14, 2025, with Gopher64 taking over as its spiritual successor.
What makes this tutorial different from a bare install walkthrough is that it treats plugin selection, resolution scaling, and controller mapping as the three decisions that actually determine whether your setup feels good to use, not just whether it technically launches a ROM. Plenty of guides stop at “click install, click play” and leave readers to discover on their own that the default audio plugin crackles under load, or that the wrong C-button mapping makes half the N64 library unplayable. This walkthrough front-loads those decisions so you configure things correctly the first time.
As of August 2026, the project ships two active tracks. The 3.0.1 stable release is what the official downloads page lists as the current public build, and it’s what this tutorial installs. A parallel 4.0.0 development branch gets nightly builds — the most recent as of this writing is Dev-4.0.0-6769, dated August 15, 2026 — and adds experimental Vulkan support through Parallel-RDP for players chasing better performance on modern GPUs. Multi-system emulators like ares also emulate the N64, but the mid-2026 consensus among comparison sites still points to Project64 as the most actively maintained, feature-complete option specifically built around this console.
The plugin model deserves a bit more context because it’s the single biggest thing that separates Project64 from newer, single-binary emulators like DuckStation or Dolphin. Instead of one team owning the entire rendering pipeline, Project64’s core handles CPU emulation and timing while independent plugin authors maintain the graphics, audio, and input layers separately. GLideN64, the graphics plugin most players end up using, is itself a community project with its own release cadence. That division of labor is why N64 emulation still involves a “pick your plugin” step that most other consoles have moved past — and also why per-game compatibility varies more than it does on, say, a PS1 emulator where one accurate core handles everything.
Prerequisites: System Requirements and What You’ll Need
Project64’s official README lists three requirement tiers depending on how much upscaling and which plugins you plan to run. The N64’s original hardware output was roughly 320×240, so even modest modern hardware can push it well past native resolution — the constraint is usually the accuracy-focused plugins like Angrylion’s RDP Plus, not raw GPU horsepower.
| Component | Minimum | Recommended (1080p/4K upscaling) |
|---|---|---|
| Operating System | 64-bit Windows 10 | 64-bit Windows 10 (22H2) or Windows 11 |
| CPU | 1 GHz, SSE2 support | Modern quad-core, 3+ GHz |
| RAM | 2 GB | 8 GB or more |
| GPU (basic plugins) | DirectX 8-capable (Jabo’s Direct3D8) | OpenGL 3.3-capable for GLideN64 |
| GPU (advanced) | — | Vulkan 1.1-capable for Parallel-RDP (dev builds) |
| Storage | ~200 MB for the emulator | 1 GB+ with HD texture packs |
Before you start, gather the following:
- A Windows 10 or 11 PC with updated GPU drivers (the official README specifically flags outdated Intel iGPU drivers as a common source of black-screen bugs)
- Legally obtained N64 ROM files, either from your own cartridge dumps or another legitimate source — the official Project64 release page states plainly that it does not include games and users must supply their own
- An Xbox or PS5 controller (wired or wireless with a PC dongle), though keyboard input works for initial testing
- About 90 minutes for the full setup, plus extra time if you plan to install HD texture packs, which can run several hundred megabytes per game
One detail that trips up people coming from PS1 or PS2 emulation: Project64 does not require a BIOS file. The official documentation makes no mention of any BIOS dump anywhere in the setup process, which is consistent with how N64 emulation works generally — the console’s boot logic doesn’t rely on a proprietary firmware image the way Sony’s consoles do. That alone removes one of the most error-prone steps in the entire emulation setup process.
One hardware quirk worth planning around before you install anything: several late-generation N64 titles, including Perfect Dark, Donkey Kong 64, and The Legend of Zelda: Majora’s Mask, required the physical Expansion Pak, a 4MB RAM upgrade that doubled the console’s memory. Project64 emulates this automatically per-game rather than requiring you to configure it manually, but if you ever see a game refuse to boot past its title screen with no error message, a missing or misconfigured Expansion Pak setting in the ROM’s per-game settings is worth checking first.
Step 1: Download Project64 3.0.1 From the Official Site
Go to the official Project64 public releases page and download the 3.0.1 installer (or the zip package if you prefer a portable install). Avoid third-party mirror sites where possible — while some, like Uptodown, do mirror legitimate builds, the official channel guarantees you’re not getting a bundled installer stuffed with adware, which is a real risk with older, less-maintained emulator download pages.
If you want the newest rendering improvements and don’t mind occasional instability, the Development Builds page hosts nightly 4.0.0-xxxx releases. These get you early access to Parallel-RDP’s Vulkan renderer and RSP core changes well before they land in a numbered stable release. For a first-time setup, stick with 3.0.1 — you can always switch to a dev build later once your plugin and controller configuration is dialed in.
Step 2: Install Project64 on Windows 10 or 11
Run the installer and accept the default install path unless you have a specific reason to change it (portable installs on a secondary drive work fine too, provided the folder has write permissions for save files and configs). The installer registers file associations for common ROM extensions, which lets you double-click .n64 or .z64 files directly from File Explorer once setup finishes.
After installation, launch Project64 once before doing anything else. This generates the default configuration folder structure, including Config, Save, Screenshots, and Plugin subdirectories inside the install path. If any of these folders fail to appear, close the emulator, right-click the Project64 folder, and confirm your Windows user account has full read/write access — a permissions issue here is the root cause of several downstream bugs covered in the troubleshooting section below.
Step 3: ROM Legality and Why N64 Emulation Needs No BIOS
Project64’s official releases page is explicit: “Games not included — do not ask for ROMs.” The legally defensible path is dumping ROMs from cartridges you personally own, using dedicated dumping hardware. Downloading ROMs for games you don’t own sits in a legal gray area at best and is outright infringing in most jurisdictions, regardless of how common the practice is in online communities.
The good news, as mentioned above, is that N64 emulation skips the BIOS-dumping step that trips up PS1/PS2/PS3 setups. There’s no equivalent of a PS2’s SCPH-xxxxx.bin file to source and place correctly. Once you have legitimate ROM files, in .z64, .n64, or .v64 format (Project64 auto-detects byte order across all three), you’re ready to load them directly.
Step 4: Organize Your ROM Library
Create a dedicated Roms folder, either inside the Project64 install directory or somewhere central like D:\Emulation\N64\Roms. Project64 can open ROMs stored inside .zip archives directly, so there’s no need to extract every file individually — that’s a meaningful time-saver if your library runs into the hundreds of titles. RAR and 7Z archives are the exception: Project64 can’t read those container formats natively, so extract those with 7-Zip first.
A clean folder structure looks like this:
D:\Emulation\N64\
├── Roms\
│ ├── Legend of Zelda - Ocarina of Time.z64
│ ├── Super Mario 64.z64
│ ├── GoldenEye 007.z64
│ ├── Mario Kart 64.z64
│ └── Paper Mario.z64
├── Textures\
│ └── (per-game HD texture pack folders)
├── Saves\
└── SaveStates\Open Project64, go to File > ROM Directory, and point it at your Roms folder (with the “Include Subdirectories” box checked if you organize titles into per-genre folders). Every valid ROM will populate the game list, complete with region flags and, if you have box art scraping enabled through a companion tool, cover thumbnails.
Step 5: First Launch and Core Configuration
Before touching graphics settings, open Options > Settings and review the general tab. The defaults are sane for most systems, but two settings are worth adjusting immediately: enable “Always on Top” only if you’re running Project64 in a window alongside other apps, and set your preferred screenshot format (PNG keeps quality high without the file bloat of BMP).
Next, check Options > Configure Graphics Plugin, Configure Audio Plugin, and Configure Controller Plugin menus. Each opens a separate configuration window specific to whichever plugin is currently active. This is normal — it’s the plugin architecture at work, and it’s the reason Project64 setup takes a few extra steps compared to single-binary emulators like DuckStation.
Step 6: Choose and Configure a Graphics Plugin
This is the decision that shapes everything else about your setup. Project64 ships with several video backends, and the official README documents exactly which API each one needs:
| Plugin | API Required | Best For |
|---|---|---|
| GLideN64 | OpenGL 3.3 | Best all-around balance of accuracy and enhancement; the default recommendation for most players |
| Angrylion’s RDP Plus | OpenGL 3.3 | Pixel-accurate, low-level RDP emulation; heavier on CPU, best for accuracy purists |
| Jabo’s Direct3D8 | DirectX 8 | Legacy compatibility on very old hardware |
| Project64 Video | OpenGL 3.3 | Bundled default, lighter but fewer enhancement options than GLideN64 |
| Parallel-RDP (dev builds only) | Vulkan 1.1 | Experimental, best raw performance on modern GPUs via 4.0.0 nightlies |
For most setups, install GLideN64 and select it from Options > Configure Graphics Plugin. It supports HD texture packs, widescreen aspect ratios, and resolution multipliers well beyond native, while staying accurate enough that most games render correctly out of the box. If you hit rendering glitches in a specific title, that’s your cue to test the same scene under Angrylion’s RDP Plus — per-game plugin swapping is a normal part of N64 emulation, not a sign you configured something wrong.
Here’s what a working GLideN64 section inside Project64.cfg looks like once configured:
[GLideN64]
UseNativeResolutionFactor=0
resolution=1920x1080 (16:9)
FXAA=1
MultiSampling=4
EnableHiResTextures=1
txCacheSize=536870912
CorrectTexrectCoords=1
EnableFBEmulation=1Step 7: Set Internal Resolution for 1080p and 4K Upscaling
Inside the GLideN64 plugin settings window, the resolution dropdown lets you decouple render resolution from the N64’s native ~320×240 output. For a 1080p display, set the resolution factor between 2x and 3x native; on a 4K panel, 4x and above sharpens geometry noticeably, though some games render UI elements at native resolution regardless, so text can look inconsistent with the upscaled 3D world — that’s a known limitation of N64-era rendering pipelines, not a bug in your config.
Enable anisotropic filtering (16x is a safe default on any GPU from the last five years) and anti-aliasing if your frame rate holds steady. Watch performance closely with Angrylion’s RDP Plus specifically — it’s accuracy-focused rather than upscaling-focused, and pushing high internal resolutions through it can tank frame rate on anything short of a high-end CPU. If that happens, drop back to GLideN64 for enhanced visuals and reserve Angrylion for games where you specifically need pixel-perfect low-level accuracy.
Step 8: Map an Xbox or PS5 Controller to N64 Layout
The N64 controller’s three-pronged design with a central analog stick and a dedicated C-button cluster doesn’t map cleanly onto any modern gamepad, so every N64 emulator setup involves some compromise here. Open Options > Configure Controller Plugin, select your connected Xbox or PS5 pad, and work through this mapping, which is the community-standard layout most players settle on:
- N64 analog stick → left analog stick
- C-buttons (Up/Down/Left/Right) → right analog stick directions, or face buttons if you prefer camera control on the right stick for specific games
- A / B → A/B on Xbox, X/Circle on PS5
- L / R shoulder → LB/RB (Xbox) or L1/R1 (PS5)
- Z trigger → left trigger (LT/L2) — this mirrors the N64 controller’s Z position underneath the stick
- Start → Menu/Options button
Test the mapping immediately inside a game rather than trusting the config screen alone — camera-heavy titles like Ocarina of Time make C-button mapping problems obvious within seconds, since a wrong C-Up binding means you can’t look up during key puzzle sequences. If your controller isn’t detected at all, jump to the troubleshooting section below; it’s one of the eight most common Project64 issues.
Step 9: Add HD Texture Packs and Enable Widescreen
GLideN64 is the plugin with real texture-replacement support, and it’s built around the ecosystem of community HD texture packs available for popular titles. To install one, create a subfolder per game inside GLideN64’s texture directory (the exact path is shown in the plugin’s config window, typically Plugin\GlideN64\Textures\<Game Name>), extract the pack’s contents there, and enable “Use High-Res Textures” in the GLideN64 settings panel.
Widescreen support works differently — N64 games render at a fixed 4:3 field of view by default, and forcing 16:9 requires either a built-in plugin option (GLideN64 exposes an aspect ratio dropdown) or a per-game widescreen hack that adjusts the camera FOV. Expect some UI stretching or minor HUD misalignment in games that weren’t designed with widescreen in mind; that’s a known trade-off, and most players consider it worth it for the improved field of view in action and platforming titles.
Step 10: Fix Audio Crackling and Tune Performance
Audio crackling and popping are almost always a buffer-size or CPU-load issue rather than a fundamental emulator bug. Open Options > Configure Audio Plugin and increase the buffer size incrementally — larger buffers trade a small amount of input-to-audio latency for stability. If crackling persists, it’s frequently a symptom of an overloaded video plugin stealing CPU cycles that the audio thread needs; switching from Angrylion’s RDP Plus to GLideN64 resolves this in the majority of reported cases, since Angrylion’s low-level RDP emulation is considerably more CPU-intensive.
For overall performance tuning, close background GPU-intensive apps (browsers with hardware acceleration and streaming software are common culprits), and confirm Project64 isn’t accidentally running in a Windows compatibility mode meant for a different OS version, which can silently disable GPU scheduling optimizations.
Step 11: Save States vs Native Saves — Best Practice Setup
Project64 supports both native in-game saves (EEPROM, SRAM, or Flash RAM, depending on the cartridge) and emulator-level save states you can create and load instantly with a hotkey. Rely on save states for convenience during a session, but treat native saves as your permanent progress record — save states aren’t guaranteed to stay compatible across different Project64 versions or plugin updates, and losing hours of progress to a broken state file is a common, avoidable frustration.
Back up both folders regularly. A simple PowerShell script scheduled through Task Scheduler handles this without any manual effort:
# backup-pj64-saves.ps1
$source = "D:\Emulation\N64\Saves"
$statesSource = "D:\Emulation\N64\SaveStates"
$dest = "D:\Emulation\N64\Backups\$(Get-Date -Format 'yyyy-MM-dd')"
New-Item -ItemType Directory -Path $dest -Force | Out-Null
Copy-Item -Path $source -Destination "$dest\Saves" -Recurse
Copy-Item -Path $statesSource -Destination "$dest\SaveStates" -Recurse
Write-Host "Backup complete: $dest"Step 12: Launch and Verify With Popular N64 Games
With everything configured, double-click a ROM from the game list, or launch directly from a shortcut using the command line if you want one-click access to a specific title:
"C:\Program Files (x86)\Project64\Project64.exe" "D:\Emulation\N64\Roms\Legend of Zelda - Ocarina of Time.z64"Test with a spread of titles rather than just one, since different games stress different parts of the emulation stack. Super Mario 64 and Mario Kart 64 are light on the RSP and a good baseline check. The Legend of Zelda: Ocarina of Time exercises camera controls and C-button mapping thoroughly. GoldenEye 007 and Paper Mario are heavier on RDP accuracy, and titles like Banjo-Kazooie and Conker’s Bad Fur Day have historically been sensitive to plugin choice — if either shows graphical artifacts under GLideN64, that’s the moment to test Angrylion’s RDP Plus instead.
Once one game runs at a stable frame rate with correct audio and responsive controls, your core setup is done. Everything from here is refinement: swapping plugins per game, tuning texture packs, and adjusting resolution based on your hardware’s headroom.
Complete Working Example: A Full Project64 Setup From Scratch
To tie every step together, here’s what a finished, working Project64 setup looks like end to end, using The Legend of Zelda: Ocarina of Time as the example title. This is the configuration a typical mid-range gaming PC (a Ryzen 5 or Core i5 from the last few generations, paired with a GPU that supports OpenGL 3.3+) would run to get clean 1080p output with HD textures and a mapped Xbox controller.
- Project64 3.0.1 installed to the default path, launched once to generate config folders
- ROM library at
D:\Emulation\N64\Roms, loaded via File > ROM Directory with subdirectory scanning enabled - GLideN64 selected as the active graphics plugin, resolution factor set to 3x native for 1080p
- HD texture pack for Ocarina of Time extracted to
Plugin\GlideN64\Textures\Legend of Zelda - Ocarina of Time\, with “Use High-Res Textures” enabled - Xbox controller mapped through Configure Controller Plugin, tested in-game for correct C-button and Z-trigger response
- Audio buffer increased from default to eliminate crackling during heavier scenes (Kakariko Village, Hyrule Field)
- A native save created after the first ten minutes of play, confirming EEPROM writes are working correctly, followed by a save state for quick session resumption
The full Project64.cfg entry for this setup, combining the plugin, video, and input sections into one working profile, looks like this:
[Rom]
GoodName=Legend of Zelda, The - Ocarina of Time (U) (V1.2) [!]
Comment Text=
[Video Plugin]
Plugin=GLideN64.dll
[Audio Plugin]
Plugin=jabo-dsound.dll
AudioBufferSize=8192
[Input Plugin]
Plugin=Project64-input.dll
Controller 1=Xbox Controller (XInput)
[GLideN64]
UseNativeResolutionFactor=3
FXAA=1
MultiSampling=4
EnableHiResTextures=1
txHiresEnable=1
txHiresFullAlphaChannel=1
CorrectTexrectCoords=1
EnableFBEmulation=1
AspectRatio=1This profile is a starting point, not a fixed recipe — adjust UseNativeResolutionFactor down to 2 if your GPU struggles at 3x, or bump the audio buffer higher if crackling persists after the first adjustment. The point of walking through a complete, working config is to show how the individual steps in this tutorial combine into one coherent setup rather than a series of disconnected menu changes.
Common Pitfalls When Setting Up Project64
These mistakes account for most of the frustration first-time users report:
- Downloading from unofficial mirrors: some third-party download pages bundle adware installers alongside the emulator. Always start from the official pj64-emu.com releases page.
- Trying to source a BIOS file: unlike PS1/PS2 emulation, N64 emulation via Project64 needs no BIOS at all. Spending time hunting for one is wasted effort.
- Extracting RAR/7Z ROMs incorrectly: Project64 opens ZIP archives natively but can’t read RAR or 7Z containers, leading to “invalid ROM” errors that look like corruption but are really just a format mismatch.
- Mixing plugin versions across a Project64 update: installing a newer GLideN64 build against an older Project64 core (or vice versa) can cause crashes on launch. Update both together when possible.
- Ignoring GPU driver updates: the official README specifically calls out Intel integrated graphics as prone to issues even when specs technically meet requirements — outdated drivers are the first thing to check with any rendering glitch.
- Relying only on save states: without a native save file as backup, a corrupted or incompatible save state can wipe out your progress with no recovery path.
- Skipping the controller test step: a mapping that looks correct in the config menu can still feel wrong in-game, especially with C-button bindings. Always verify in an actual play session before committing to a layout.
Troubleshooting Guide: 8 Common Project64 Errors, Solved
1. Black screen on game launch. This is most often a GPU/API mismatch. Confirm your graphics card supports OpenGL 3.3 (for GLideN64/Angrylion) or DirectX 8 (for Jabo’s plugin), then update drivers. If the issue persists, switch video plugins from Options > Configure Graphics Plugin to isolate whether the problem is plugin-specific.
2. Audio crackling or popping. Increase the audio buffer size in Options > Configure Audio Plugin. If that doesn’t fully resolve it, switch away from Angrylion’s RDP Plus to a lighter video plugin like GLideN64, since audio stutter is frequently a symptom of CPU contention rather than an audio-specific bug.
3. Controller not detected. Confirm Windows recognizes the controller first (Windows Settings > Devices > Bluetooth & other devices, or Game Controllers in Control Panel). Then reopen Project64’s controller configuration window and select the correct input device from the dropdown — it doesn’t always default to a newly connected pad automatically.
4. Project64 crashes immediately on Windows 10/11. Right-click Project64.exe, select Properties, open the Compatibility tab, and try running it in compatibility mode for an earlier Windows version. This resolves a subset of launch crashes tied to how the executable initializes on newer Windows builds, though it should be treated as a fallback rather than a first step.
5. “Invalid ROM” or ROM not appearing in the game list. Check the file extension and archive format. Project64 supports .z64, .n64, .v64, and ZIP-compressed ROMs, but not RAR or 7Z. Extract those with 7-Zip first, then re-scan the ROM directory.
6. HD texture pack not loading. Confirm the pack is extracted into the correct per-game subfolder under GLideN64’s texture directory (visible in the plugin config window) and that “Use High-Res Textures” is enabled. A mismatched folder name — even a single-character difference from what GLideN64 expects — will cause it to silently ignore the pack.
7. Save state fails to load after an update. Save states aren’t guaranteed to be forward- or backward-compatible across Project64 or plugin version changes. If a state won’t load, fall back to your most recent native in-game save, which is why Step 11’s backup routine matters.
8. Severe slowdown on specific games (e.g., Conker’s Bad Fur Day, Banjo-Kazooie). These titles push RDP accuracy demands higher than most of the library. If GLideN64 shows visual glitches, try Angrylion’s RDP Plus for accuracy, but expect a real performance cost — drop internal resolution back toward native if frame rate suffers under the more demanding plugin.
Project64 vs ares vs Gopher64: Which N64 Emulator Wins in 2026
The N64 emulator landscape shifted meaningfully over the past two years. simple64, once a common recommendation, was archived in February 2025, and its userbase largely migrated to its named successor, Gopher64. Meanwhile, multi-system emulator ares picked up N64 support as part of its broader console coverage. Here’s how the three main options compare as of mid-2026:
| Emulator | Focus | Status (Aug 2026) | Best For |
|---|---|---|---|
| Project64 | N64/N64DD-dedicated | Actively developed; 3.0.1 stable, 4.0.0 nightlies with Vulkan/Parallel-RDP | Most players; broadest plugin ecosystem, biggest community |
| Gopher64 | N64/N64DD-dedicated | Actively developed successor to simple64 | Users who liked simple64’s approach and want its continuation |
| ares | Multi-system (N64 is one of many cores) | Actively developed | Players who want one emulator across multiple retro consoles rather than N64-specific tuning |
| simple64 | N64/N64DD-dedicated | Archived February 14, 2025; no further updates | Not recommended for new setups |
For most players setting up N64 emulation fresh in 2026, Project64 remains the practical default: it has the largest base of tested texture packs, the most documented plugin combinations, and active nightly development pushing toward Vulkan-based rendering. Gopher64 is worth watching if you prefer its architecture, and ares makes sense if N64 is just one of several consoles you’re consolidating into a single frontend.
Community documentation and third-party guides also play a role in this comparison, and it’s worth being honest about the gap: Project64’s plugin ecosystem has had two-plus decades to accumulate tested combinations for specific games, which is a genuine advantage over any newer emulator no matter how technically capable. A brand-new project like Gopher64 will close that gap over time, but as of August 2026 it hasn’t yet matched the sheer volume of documented per-game fixes that exist for Project64 and GLideN64 specifically. That’s the practical reason this tutorial — and most current N64 emulation guides — still default to Project64 as the starting point for new setups.
Advanced Tips: Dev Builds, Netplay Status, and Command-Line Launching
Once your base setup is solid, a few advanced options are worth exploring. The 4.0.0 dev/nightly builds add Parallel-RDP, an experimental Vulkan-based renderer that can meaningfully outperform GLideN64 on modern GPUs, at the cost of occasional instability typical of nightly software. If you’re comfortable troubleshooting the occasional regression, it’s worth testing against your usual game library before fully switching over from the 3.0.1 stable branch.
On multiplayer: Project64 focuses on local play with multiple physical controllers rather than shipping built-in online netplay. If you specifically want online co-op or versus play on N64 titles, that typically requires third-party tooling layered on top rather than a native Project64 feature — worth knowing going in so you don’t spend time hunting for a menu option that doesn’t exist.
For power users managing large libraries, command-line launching lets you build a front-end or batch-launch script instead of clicking through Project64’s game list every time:
@echo off
REM launch_game.bat - quick-launch a specific ROM with logging
set PJ64="C:\Program Files (x86)\Project64\Project64.exe"
set ROM="D:\Emulation\N64\Roms\Super Mario 64.z64"
set LOG="D:\Emulation\N64\Logs\last_session.log"
echo Launching %ROM% at %date% %time% > %LOG%
start "" %PJ64% %ROM%This pattern scales well if you’re building a custom launcher or integrating Project64 into a broader emulation frontend alongside your other retro systems.
Running Project64 on Steam Deck and Handheld PCs
Project64 is a Windows-only emulator, which complicates things on Linux-based handhelds like the Steam Deck. Since SteamOS runs Windows applications through Proton (a Wine-based compatibility layer), Project64 isn’t a native fit the way it is on a Windows gaming handheld such as the ROG Ally or Legion Go. It can run under Proton, but expect extra setup friction with plugin DLLs and controller detection compared to running it directly on Windows.
For dedicated Linux handhelds, most players get a smoother experience running N64 emulation through RetroArch’s Mupen64Plus core or through EmuDeck, which packages N64 emulation alongside dozens of other systems in one setup pass tuned specifically for SteamOS. If your primary machine is a Windows handheld, though, Project64 installs and runs exactly as described in this guide, with the added step of mapping the device’s built-in controls the same way you’d map an Xbox pad. Battery life is worth watching at higher internal resolutions — dropping the GLideN64 resolution factor from 3x to 2x meaningfully extends session length on handheld hardware without a noticeable visual downgrade on a 7-to-8-inch screen.
Frequently Asked Questions
Does Project64 need a BIOS file to run N64 games?
No. Unlike PS1, PS2, or PS3 emulation, N64 emulation through Project64 doesn’t require sourcing or dumping a separate BIOS image. You only need the ROM files themselves.
What is the latest version of Project64 in 2026?
The current stable release is Project64 3.0.1, with an actively developed 4.0.0 branch available through nightly dev builds, the most recent of which as of this writing is dated August 15, 2026.
Is Project64 free?
Yes. Project64 is free to download and use from the official site and GitHub repository.
Which graphics plugin should I use: GLideN64 or Angrylion’s RDP Plus?
GLideN64 is the better default for most players — it supports HD textures, widescreen, and resolution upscaling while running efficiently. Angrylion’s RDP Plus prioritizes pixel-perfect accuracy over enhancement and is more CPU-intensive, so reserve it for specific games where GLideN64 shows visual glitches.
Can Project64 run on Mac or Linux?
No. Project64 is a Windows-only emulator. Mac and Linux users looking for N64 emulation typically turn to alternatives like ares, which support multiple operating systems.
Why did my save state fail to load after updating Project64?
Save states can lose compatibility across different Project64 versions or plugin updates. Always keep a native in-game save as a backup rather than relying solely on save states for long-term progress.
Does Project64 support online multiplayer or netplay?
Not natively as of August 2026. Project64 supports local multiplayer with multiple controllers, but online netplay generally requires separate third-party tools rather than a built-in feature.
What happened to simple64?
simple64 was archived on February 14, 2025, and development stopped. Gopher64 has taken over as its successor for players who preferred that emulator’s approach.
Do I need the Expansion Pak setting for every N64 game?
No. Most N64 titles run fine without it, but a handful of late-generation games, including Perfect Dark, Donkey Kong 64, and Majora’s Mask, required the physical Expansion Pak on real hardware. Project64 handles this automatically on a per-game basis, so you generally won’t need to touch it manually unless a specific title fails to boot past its title screen.
Related Coverage
- Best N64 Emulator: 5 Tools Ranked as Simple64 Dies [2026]
- Best Emulators for PC: PCSX2’s 98% vs RPCS3’s 70% [2026]
- Dolphin Emulator: GameCube & Wii in 12 Steps, 40 Min [2026]
- How to Set Up RetroArch: 12 Steps, 75 Min [2026]
- How to Set Up MAME: 13 Steps, 70 Min [2026]
- EmuDeck Tutorial: Steam Deck Emulation in 12 Steps [2026]
Sources: Project64 official site, Project64 public releases, Project64 GitHub repository, Project64.org development builds and support, and Project64 background on Wikipedia.
