Orbit64: a Nintendo 64 emulator for Windows, macOS and Linux

Q: Is there an ARM64 version for Windows and Linux?

Yes. Every release has native ARM64 builds: orbit64-windows-arm64.zip for Windows 11 on ARM (e.g. Snapdragon X laptops) and orbit64-linux-arm64.tar.gz for 64-bit ARM Linux (e.g. Ubuntu or Raspberry Pi OS 64-bit). The recompiler generates native ARM64 code there too, with no x64 emulation layer.

Q: What does internal resolution do?

It renders every triangle and texture at 2x to 8x the game's original resolution on the GPU, so 3D graphics look sharp on modern displays. It is not an upscale of the finished 320x240 image.

Play your N64 games in sharp HD. Orbit64 recompiles N64 code to native code, renders 3D at up to 8× the original resolution on your GPU, and saves your progress at any moment with save states.

Download Orbit64 View the source on GitHub

Work in progress. Orbit64 is under active development. Many games are playable, but others may show graphical glitches, missing sound, crashes or not start at all. Features and save state files can change between releases. Please report the problems you find.

Windows 10 / 11macOS – Apple Silicon & Intel Linuxx86-64ARM64Free

Features

Orbit64 is a desktop app. It emulates the N64's CPU, RSP and RDP, with a modern game library and tools on top.

Fast JIT recompiler

Translates the N64's MIPS code to native ARM64 or x86-64 code and chains blocks together. It falls back to the interpreter for anything it doesn't handle.

HD internal resolution

Renders 3D at 2× to 8× the original resolution in GPU compute shaders on Metal, Vulkan or Direct3D 12. Every triangle is drawn again at the higher resolution; the image is not upscaled.

Save states

Nine slots per game, each with a screenshot and a timestamp, plus undo for the last load. Saving takes about a millisecond, and states stay with the game when you rename or move the ROM.

Accurate audio

Emulates the libultra, n_audio, Nintendo EAD and Factor 5 MusyX audio microcodes, then resamples the sound with a 32-tap windowed-sinc filter so the pitch is never bent.

Accurate graphics

The fast renderer models the console's RDP pixel pipeline (8-sample coverage, dithering, a depth buffer in RDRAM). A bit-exact RDP, on the CPU or the GPU, reproduces the console's pixels exactly, also at a higher resolution.

Controllers and keyboard

Xbox, PlayStation, Switch Pro and other SDL3-supported gamepads work out of the box. You can rebind every button and stick direction.

Game library

Scans your ROM folders and shows box art from No-Intro / RetroArch packs. It keeps favorites, recently played games and play time.

Debug and memory tools

Includes a 3D object inspector, memory search, RAM watch, a memory editor, freeze lists, frame stepping and turbo, for curious players and ROM hackers.

Frame buffer effects

The game still gets its normal frame buffer in memory. Effects that read it back, like motion blur, pause screens and CPU-drawn images, keep working in HD.

Real HD rendering, not an upscale

Most N64 games render at 320×240. Stretching that image to a 4K screen only makes it blurry. Orbit64 records every triangle, texture rectangle and fill the game draws and draws them a second time at the resolution you choose, with its own depth buffer and 8 bits per colour channel.

2×, 3×, 4× up to 8× internal resolution (up to 2560×1920)
Rendered in GPU compute shaders; the frame stays in video memory
The same colour combiner, blender and texture decoding as the software renderer
Falls back to a multi-threaded CPU renderer on machines without a usable GPU driver
Change it in Settings › Graphics or in the View menu while you play

Game compatibility

Orbit64 is tested on a library of Nintendo 64 games. A tool finds a route into every game (title screens, menus, prompts), replays it with each build and judges what is drawn, with a screenshot and a status per game. The results are automatic and not 100% certain: a game shown as a menu may well work.

Browse all games

Download

Every release is built automatically for Windows, macOS and Linux (x64 and ARM64) and for several other systems. Each download is a single self-contained program: there is no installer and nothing else to install.

Platform	File	Requirements
Windows	`orbit64-windows-x64.zip`	Windows 10 or 11, 64-bit; Vulkan or Direct3D 12 for GPU rendering
Windows on ARM	`orbit64-windows-arm64.zip`	Windows 11 on ARM64 (e.g. Snapdragon X); Vulkan or Direct3D 12 for GPU rendering
macOS	`orbit64-macos-universal.zip`	macOS 11 Big Sur or newer, Apple Silicon (M1 and newer) or Intel
Linux	`orbit64-linux-x64.tar.gz`	x86-64 with glibc 2.35+ (e.g. Ubuntu 22.04+, Fedora 36+); Vulkan for GPU rendering
Linux ARM64	`orbit64-linux-arm64.tar.gz`	AArch64 with glibc 2.35+ (e.g. Ubuntu 22.04+, Raspberry Pi OS bookworm 64-bit); Vulkan for GPU rendering
Other systems	`orbit64-windows-x86.zip`, `orbit64-linux-x86.tar.gz`, `orbit64-linux-armhf.tar.gz`, `orbit64-linux-riscv64.tar.gz`, `orbit64-linux-ppc64le.tar.gz`, `orbit64-freebsd-x64.tar.gz`, `orbit64-openbsd-x64.tar.gz`, `orbit64-netbsd-x64.tar.gz`, `orbit64-haiku-x64.zip`	32-bit Windows and Linux, ARMv7, RISC-V 64, PowerPC 64 LE, FreeBSD, OpenBSD, NetBSD and Haiku. Built by the same release, tested less than the systems above

Get the latest release

Getting started

Download the file for your system and unpack it.
Start orbit64 (orbit64.exe on Windows).
Add the folder with your ROMs (.z64, .n64, .v64) to the library.
Double-click a game. Plug in a controller or use the keyboard.

macOS: first launch

The app is not notarized yet, so macOS blocks it the first time. Run this once in Terminal, in the folder where you unpacked it:

xattr -dr com.apple.quarantine orbit64

Save state shortcuts

These are also in the Emulation menu and in the game screen's right-click menu.

Action	Windows / Linux	macOS
Save state	`Ctrl`+`S` or `F2`	`⌘`+`S` or `F2`
Load state	`Ctrl`+`Shift`+`L` or `F4`	`⌘`+`Shift`+`L` or `F4`
Choose slot 1–9	`Ctrl`+`1`…`9`	`⌘`+`1`…`9`

Frequently asked questions

Answers to common questions about Orbit64.

Is Orbit64 free?

Yes. Orbit64 is free to download and use, and its source code is on GitHub.

Is Orbit64 finished? Will every game work?

Not yet. Orbit64 is a work in progress. Many games are playable, but some still have graphical or audio glitches, and some don't boot. Save states from one version may not load in the next. New releases come out often, so check the releases page for fixes.

Does Orbit64 run on Apple Silicon Macs?

Yes. The macOS build is a universal binary. On M1, M2, M3 and newer Macs the recompiler generates native ARM64 code, and the GPU renderer uses Metal.

Is there an ARM64 version for Windows and Linux?

Yes. Every release has native ARM64 builds: orbit64-windows-arm64.zip for Windows 11 on ARM (e.g. Snapdragon X laptops) and orbit64-linux-arm64.tar.gz for 64-bit ARM Linux (e.g. Ubuntu or Raspberry Pi OS 64-bit). The recompiler generates native ARM64 code there too, with no x64 emulation layer.

Do I need an N64 BIOS or PIF ROM?

No. Orbit64 emulates the boot process itself, so a ROM file (.z64, .n64 or .v64) is all you need.

Does Orbit64 include games?

No. Orbit64 ships without any games. Use ROMs that you dumped from cartridges you own.

Can I play with a controller?

Yes. Xbox, PlayStation, Switch Pro and other controllers that SDL3 supports work out of the box, and every button can be rebound in Settings. You can also play on the keyboard.

What does internal resolution do?

It renders every triangle and texture at 2× to 8× the game's original resolution on the GPU, so 3D graphics look sharp on modern displays. It is not an upscale of the finished 320×240 image.

Where are my saves and settings stored?

In your user config folder: %APPDATA%\Orbit64 on Windows, ~/Library/Application Support/Orbit64 on macOS and ~/.local/share/Orbit64 on Linux. Set ORBIT64_CONFIG_DIR to keep everything in a portable folder instead.

Thank you, Mupen64Plus

Orbit64 stands on the shoulders of the emulators that came before it, and few have done more for N64 emulation than Mupen64Plus. The project started from Hacktarux's original Mupen64. For well over a decade its developers have built a free, portable emulator in the open and shared what they learned about the console along the way: how the CPU, the RSP microcodes, the RDP and the audio pipeline really behave.

That openly shared work taught a whole generation of emulator authors, homebrew developers and curious players how the Nintendo 64 works, and it keeps many games playable on almost every platform. Anyone who writes an N64 emulator today benefits from it.

Thank you to everyone who has written code, reverse-engineered hardware, tested games or answered questions for Mupen64Plus, and to the wider N64 emulation and homebrew community.

With gratitude, from the Orbit64 team.

Build from source

The only dependency is SDL3 3.4 or newer, and CMake downloads it for you when it isn't installed. See the README for every platform.

git clone https://github.com/Wronk4/orbit64.git
cd orbit64
cmake -S . -B out -DCMAKE_BUILD_TYPE=Release
cmake --build out