EMULATOR DATABASE
gopher64
Gopher64 is an open-source, cross‑platform Nintendo 64 emulator written in Rust that focuses on compatibility, upscaling and modern features (netplay, RetroAchievements, savestates). Official binaries are published for Windows, macOS, Linux (including Flatpak) and Android; source and build instructions are on the project's GitHub repository.
Download Tutorials & guidesSign in to download. Files are hosted by the emulator project.

About gopher64
Gopher64 is a modern reimplementation of N64 emulation in Rust that combines lessons and code adapted from established projects (mupen64plus, ares) and adds features aimed at contemporary users: built‑in upscaling and shader support, P2P netplay, RetroAchievements, and packaged releases for multiple platforms. Its active GitHub development and frequent releases make it a viable alternative to long‑running N64 emulators for many users.
- Playing a wide range of Nintendo 64 titles on Windows, macOS, Linux and Android using official builds. - Users who want netplay or integrated RetroAchievements with a maintained open‑source project. - People comfortable installing a Flatpak or downloading prebuilt binaries, or building from source with Rust when platform packages are unavailable.
The people behind gopher64 / history
Gopher64 is actively developed on GitHub and publishes regular releases (binary artifacts and changelogs on the Releases page). The project README and wiki document features (netplay, controls, portable mode), build steps, and packaging notes. The repository and release pages show ongoing activity and official multi‑platform binaries; the project is licensed GPLv3. Portions of the project incorporate or adapt work from mupen64plus and ares, as documented by the maintainer. The project publishes official downloads and a wiki for user documentation.
Screenshots

Tutorials & guides
gopher64 setup guide
Setup note: Below are practical, emulator‑specific steps to get Gopher64 running on common platforms, and notes on building from source. This guide uses only details published by the project and avoids assumptions about included game files or copyrighted firmware (none are bundled). Follow your platform's normal security practices when installing executables or Flatpaks.
- Download the official build for your platform: Visit the project's GitHub Releases page and download the appropriate asset for your platform (gopher64-windows-x86_64.exe, gopher64-macos-*.zip, gopher64-linux-*, gopher64-android.apk). The project also lists builds on itch.io and provides a Flathub Flatpak and Homebrew cask for macOS. Use the release matching your OS/architecture.
- Windows — prerequisites and running the executable: If you downloaded the standalone Windows EXE, ensure the Microsoft Visual C++ redistributable required by the build is installed (the project's itch.io comments point users to the Microsoft C++ runtime when issues appear). Place the executable in a folder where you want saves and config, or use 'portable mode' by creating a file named portable.txt next to the executable to keep data local. Double‑click the EXE to run; if Windows blocks the executable, unblock it via file Properties or run as administrator only if necessary.
- macOS — install options: Use the provided App Bundle from releases for macOS or the Homebrew cask (brew install --cask gopher64) as documented by the repository. After installing, launch from Applications. If gatekeeper prevents launching, follow macOS instructions to allow apps from identified developers (do not bypass security without understanding the risks).
- Linux — standalone or Flatpak: Two common ways to run on Linux: 1) download the standalone Linux executable from Releases, make it executable (chmod +x) and run it; or 2) install the Flatpak from Flathub (flatpak install flathub io.github.gopher64.gopher64) and launch with the documented Flatpak invocation. When running the Flatpak from command line the repo documents a recommended --filesystem=host:ro option to allow read access to ROM paths. For Flatpak or distro packages ensure any needed system runtime (SDL3 and typical graphics drivers) are installed.
- Android: An APK is published as a release asset. Install only from a trusted copy of the release (enable installation from unknown sources according to Android settings). Note: the itch.io project page records an Android APK release. Some Android frontends or platform wrappers may be required for optimal touch/controller mapping.
- Controller mapping, saves and portable mode: Gopher64 includes default keyboard and controller mappings and Xbox‑style controller presets. The README documents controls and mapping defaults. Savestates and regular in‑game saves are supported; portable mode keeps the emulator's configuration and saved data in the same directory as the executable when a file named portable.txt is present.
- Netplay and privacy notes: Gopher64 supports peer‑to‑peer netplay. The project's README and wiki include a Netplay Guide explaining how sessions are established and server logging behavior. The README states the netplay server logs IP addresses and basic session metadata for operational purposes; read the project's privacy and code signing policy for details before using online features.
- RetroAchievements and extras: RetroAchievements integration is supported; enabling it will cause data to be sent to RetroAchievements systems and requires an account. The project also supports upscaling, CRT shaders, cheats, and CPU overclock emulation as configurable features. Consult the project's wiki and README for how to enable or configure these features.
Software reminder: Gopher64 does not include commercial game ROMs, Nintendo firmware or copyrighted BIOS files. You must provide your own legally obtained N64 ROMs and respect copyright and licensing laws. The project requires standard system libraries (SDL3, graphics drivers) and, for Windows builds, the Microsoft C++ runtime when indicated by the release notes.
Additional information
What gopher64 supports
- Nintendo 64 (software emulation)
- Windows (official binary)
- macOS (official binary and Homebrew cask)
- Linux (standalone and Flatpak on Flathub)
- Android (APK release)
READMEs & documentation
gopher64 official project README
# gopher64
Gopher64 is a cross-platform N64 emulator. Some notable features:
* Rollback netplay
* Homebrew support
* Upscaling
* CRT shader
* Emulate CPU overclocking
* Cheats
* Savestates
* RetroAchievements
## download
<a href="https://loganmc10.itch.io/gopher64"><img src="https://static.itch.io/images/badge.svg" width="200" ></a>
Windows:
* Standalone executable: [gopher64-windows-x86_64.exe](https://github.com/gopher64/gopher64/releases/latest/download/gopher64-windows-x86_64.exe)
MacOS:
* App Bundle: [gopher64-macos-aarch64.zip](https://github.com/gopher64/gopher64/releases/latest/download/gopher64-macos-aarch64.zip)
* Homebrew: `brew install --cask gopher64`
Linux:
* Standalone executable: [gopher64-linux-x86_64](https://github.com/gopher64/gopher64/releases/latest/download/gopher64-linux-x86_64)
* Flatpak: `flatpak install flathub io.github.gopher64.gopher64`
Android:
* APK: [gopher64-android.apk](https://github.com/gopher64/gopher64/releases/latest/download/gopher64-android.apk)
* [Play Store](https://play.google.com/store/apps/details?id=io.github.gopher64.gopher64)
## wiki
https://github.com/gopher64/gopher64/wiki
## discord
[Discord invite link](https://discord.gg/9RGXq8W8JQ)
## controls
Keys are mapped according to [these defaults](https://github.com/gopher64/gopher64/wiki/Default-Keyboard-Setup). Xbox-style controllers also have a [default mapping applied](https://github.com/gopher64/gopher64/wiki/Default-Gamepad-Setup).
## netplay
Gopher64 supports P2P rollback netplay (online play with others).
Please read the [guide](https://github.com/gopher64/gopher64/wiki/Netplay-Guide) before trying out netplay.
## portable mode
If you would like to keep all the game data in the same folder as the executable, you just need to create a file called "portable.txt" in the same directory as the executable.
## flatpak
If you want to run the flatpak from the command line, you need to add the `--filesystem=host:ro` option, for example:
```
flatpak run --filesystem=host:ro io.github.gopher64.gopher64 /path/to/rom.z64
```
## building and usage
1. [Install dependencies](#build-dependencies)
2. [Install rust](https://www.rust-lang.org/tools/install)
3. `git clone --recursive https://github.com/gopher64/gopher64.git`
4. `cd gopher64`
5. `git submodule update --init --recursive`
6. `cargo build --release`
7. `./target/release/gopher64 /path/to/rom.z64`
### build dependencies
#### Ubuntu 25
1. [Install the SDL3 dependencies](https://wiki.libsdl.org/SDL3/README-linux#build-dependencies)
2. ```
sudo apt install clang llvm
```
## contributing
PRs that are vibe coded and/or co-authored by AI agents (Plan/Agent mode) are not permitted. If you are going to submit a PR, it should be scoped to a single feature/improvement.
Please contact me via a GitHub issue or Discord (loganmc10) before doing substantial work on a PR.
## license
Gopher64 is licensed under the GPLv3 license. Many portions of gopher64 have been adapted from mupen64plus and/or ares. The license for mupen64plus can be found [here](https://github.com/mupen64plus/mupen64plus-core/blob/master/LICENSES). The license for ares can be found [here](https://github.com/ares-emulator/ares/blob/master/LICENSE).
## privacy and code signing policy
Free code signing for the Windows release is provided by [SignPath.io](https://about.signpath.io), certificate by [SignPath Foundation](https://signpath.org).
During online netplay sessions, the server logs your IP address and basic session information (game title and session name) for operational purposes. No additional personal data is collected or stored.
If you enable the RetroAchievements feature, some data is sent to their systems. Please see their terms [here](https://retroachievements.org/terms).
Download original READMERelease log
Selected releases and changes, with coverage from our weekly emulation roundup.
Sources & further reading
FROM THE COMMUNITY
Player reviews
Starting site scores are provisional editorial scores. Established mainstream projects receive a higher starting score; other imported entries begin at a neutral 6/10 pending individual review. Member scores change the average after approval.
Your take on gopher64
Spam has been overwhelming. To help us approve your review, sign up and introduce yourself in the Introductions forum so we know you’re not a bot.
Sign in with your Retro Replay account to rate this project and share your experience.
Sign in to review
Retro Replay Retro Gaming History, Reviews & Emulation