Skip to the content
Know your tech before you buy it. Makers: get listed from $49/mo

RustyN64

github.com

  • Free plan
  • Windows
  • macOS
  • Linux
  • Web
8.1 Club score Visit github.com

What RustyN64 is

RustyN64 is a free Nintendo 64 emulator written in pure Rust, built around cycle-accurate emulation. Its core coordinates the CPU and coprocessors on a shared 187.5 MHz master-clock timeline. Version 0.7.0 is described as the first playable release, demonstrating picture, sound, and controller input with homebrew ROMs. The project says its low-level graphics path matches Angrylion across 164 conformance vectors, although its accuracy battery remains stubbed at 0%. It also states that identical seeds, ROMs, and input sequences yield identical framebuffer and audio output. The desktop frontend includes save states, rewind, and run-ahead, all off by default. A WebAssembly browser entry point can run a homebrew ROM and show video on a 2D canvas; a fuller browser shell is roadmap work. Commercial compatibility remains limited: a title can boot and execute game code but has not yet reached a rendered frame. Desktop builds are listed for Linux x64, macOS ARM64, and Windows x64. Desktop use requires a wgpu-supported GPU backend, and commercial ROMs are not bundled.

Who it suits

RustyN64 may suit people interested in Nintendo 64 emulation, homebrew ROMs, or contributing code, testing, documentation, and design. Desktop users need a supported GPU backend; browser users can try the WebAssembly homebrew entry point.

Good to know, and what to watch

  • Free and dual-licensed under MIT or Apache 2.0
  • Supports save states, rewind, and run-ahead
  • WebAssembly entry point runs a homebrew ROM
  • Graphics path matches Angrylion across 164 vectors
  • Commercial title has not yet rendered a frame
  • Full browser shell remains roadmap work
  • No full-speed run path or headline performance measurements
  • Desktop use requires a wgpu-supported GPU backend

RustyN64

Free

Free plan

Getting started

  1. Open the RustyN64 GitHub project page.
  2. Choose the desktop build for Linux x64, macOS ARM64, or Windows x64, or use the WebAssembly browser demo.
  3. For desktop use, make sure the system has a wgpu-supported Vulkan, Metal, or DX12 GPU backend.
  4. On Linux, install the required audio and window-system development headers.
  5. Use homebrew ROMs; commercial ROMs are not bundled, and users are responsible for legally owned cartridge dumps.

Limits to check

The free plan is the open-source emulator. Commercial support is limited to a title that boots and executes code without reaching a rendered frame; the full browser shell and a full-speed run path are not yet available.

The Club's review

Overview

RustyN64 is a free, open-source Nintendo 64 emulator built around cycle-accurate operation. It best suits developers, preservation-minded enthusiasts, and people interested in emulation internals who are comfortable with an early-stage project. Its precision-focused design is promising, but commercial games have not yet reached a rendered frame.

Version 0.7.0 is the first playable release, demonstrating picture, sound, and controller input with homebrew ROMs. The core schedules the CPU and coprocessors on a shared 187.5 MHz master-clock timeline, with low-level RSP and RDP emulation. The project reports that its software RDP and VI scan-out bit-match Angrylion across 164 conformance vectors; its broader accuracy battery remains stubbed at 0%, so that result is evidence of progress, not a finished accuracy assessment.

A commercial title can boot and execute game code but does not yet reach a rendered frame; that work is deferred to Phase 7. RustyN64 is dual-licensed under MIT or Apache License 2.0, and does not include commercial Nintendo ROMs. Users are responsible for using dumps from cartridges they legally own.

Key features

  • Shared clock model: Coordinating the CPU and coprocessors on a canonical 187.5 MHz timeline is a substantive foundation for cycle-accurate emulation. It will interest people studying timing behavior, but does not by itself make the emulator ready for commercial play.
  • Deterministic output: The project says the same seed, ROM, and input sequence yield bit-identical framebuffer and audio. That reproducibility is useful for debugging and testing; it is not a compatibility guarantee.
  • Game I/O: The frontend connects VI video, AI audio, and SI controller input. Save states, rewind, and run-ahead are also included, but are off by default.
  • Accuracy work: Matching Angrylion on 164 conformance vectors gives the RDP and VI work a concrete benchmark. The 0% stubbed accuracy battery is an important counterweight for anyone seeking a broad measure of system accuracy.
  • Safety and contribution: The project says every chip and core crate forbids unsafe code, with no unsafe code in the tree. It invites code, testing, documentation, and design contributions, making it a more natural fit for contributors than for players seeking a mature library.

Pricing

RustyN64 — free. The free plan is the open-source emulator under MIT or Apache-2.0. There are no paid tiers or seat quotas in the plan. The practical cost is setup: desktop use requires Rust 1.96.0 and a GPU with a wgpu-supported Vulkan, Metal, or DX12 backend; Linux also requires listed audio, input, and window-system development headers.

Platforms

RustyN64 lists Linux x64, macOS ARM64, and Windows x64 desktop builds as built and tested in CI. Its WebAssembly browser entry point runs a homebrew ROM and displays scan-out on a 2D canvas, but the full browser shell is roadmap work. The desktop frontend requires a supported GPU backend. This is not a broad plug-and-play browser option, and Linux users face additional development-header requirements.

Save states, high-resolution rendering, and controller remapping are supported. Online netplay is not. Those capabilities give desktop experimenters useful control, but they do not offset the current commercial compatibility and full-speed limitations.

Who it's for

Choose RustyN64 if you want to explore a pure-Rust, timing-focused emulator, work with homebrew ROMs, or contribute to preservation and testing. Its deterministic output and documented conformance work are especially relevant to developers investigating repeatable behavior.

Look elsewhere if your priority is playing commercial N64 games now, running at full speed, or using netplay. RustyN64 has not published headline performance measurements and does not yet have a full-speed run path; its stated compatibility milestone remains short of rendering a commercial title.

Pros and cons

Pros

  • Explicit timing architecture: The shared 187.5 MHz clock and low-level RSP/RDP emulation make its technical focus clear.
  • Repeatable results: Bit-identical output for matching seeds, ROMs, and inputs supports reproducible investigation.
  • Useful frontend controls: Save states, rewind, run-ahead, high-resolution rendering, and controller remapping give contributors and homebrew users tools to explore.
  • Open licensing: MIT or Apache-2.0 licensing and an invitation to contribute suit people who want to inspect or improve the project.

Cons

  • Commercial play is not ready: A commercial title executes code but has not reached a rendered frame.
  • Performance remains uncertain: No headline performance measurements are published, and a full-speed run path is not yet available.
  • Browser support is narrow: The demo runs a homebrew ROM on a 2D canvas; a full browser shell remains roadmap work.
  • Desktop setup has prerequisites: A supported GPU backend is required, with extra development headers on Linux.
  • No netplay: Online multiplayer is not supported.

Alternatives

For a wider set of choices, browse Nintendo 64 Emulators.

  • Virtual Jaguar is another free, open-source emulator core spanning desktop, mobile, and web platforms; it requires a libretro frontend such as RetroArch.
  • RetroArch is a free, open-source project available across desktop, mobile, and web platforms; consider it if broad platform availability is more important than RustyN64's timing-focused development.
  • Luna's Project64 is a free, GPLv2 open-source option for Linux and Windows.
  • Provenance is a free option for iOS and macOS, with its emulation features available when sideloaded or built from source.
  • Gopher64 is a downloadable free emulator for Android and desktop platforms.
  • M64Plus FZ Emulator is a free Android app with netplay server support only in its Pro version.
  • Delta is a free app for iOS and macOS, with in-app purchases.
  • Mupen64Plus is a free N64 emulator with plugins and download bundles for Linux, macOS, and Windows.

Verdict

RustyN64 is best for technically curious users and contributors who value a cycle-accurate, reproducible emulator and can work within an early playable release. Its clock-based core, conformance work, and open licensing are good reasons to follow or contribute to it. For playing commercial games today, or for full-speed performance and netplay, choose a more established alternative instead.

The verdict

RustyN64 is an early playable emulator focused on cycle-accurate operation, with desktop builds and a limited browser entry point. Its current commercial-game compatibility and performance limitations matter if you want to play commercial titles rather than explore or contribute to the project.

Questions people ask

How much does RustyN64 cost?

It is free: the listed plan is free.

Which platforms does it support?

The project lists Linux x64, macOS ARM64, and Windows x64 desktop builds, plus a WebAssembly browser demo.

Can I use it in a browser?

Yes. The browser entry point runs a homebrew ROM and displays video on a 2D canvas. A fuller browser shell is roadmap work.

Does it support save states?

Yes. The desktop frontend supports save states, rewind, and run-ahead; these options are off by default.

Is RustyN64 open source?

Yes. It is dual-licensed under MIT or Apache License 2.0.

Are commercial ROMs included?

No. Commercial Nintendo ROMs are not bundled, and users are responsible for using dumps from cartridges they legally own.

What the maker publishes

Accuracy status
The software RDP matches Angrylion across 164 conformance vectors, while the accuracy battery is still stubbed at 0%. source
Accuracy status
The project says its commercial-ROM accuracy battery is stubbed at 0% and real-game visual-golden work has not started. source
Audience
The project invites contributions in code, testing, documentation, and design, and provides a contribution guide and quality-gate instructions. source
Audio and controls
The frontend connects VI video output, AI audio, and SI controller input to the game. source
Browser demo
A WebAssembly browser entry point runs a homebrew ROM and displays video on a 2D canvas; the full browser shell is on the roadmap. source
Browser support
A WebAssembly browser entry point runs a homebrew ROM and displays scan-out on a 2D canvas; the full browser shell is described as roadmap work. source
Compatibility limit
A commercial title boots and executes game code but does not yet reach a rendered frame; that work is deferred to Phase 7. source
Compatibility limit
A commercial title can boot and execute game code but does not yet reach a rendered frame; the project defers that work to Phase 7. source
Current release
Version 0.7.0 is described as the first playable release, demonstrating picture, sound, and controller input on homebrew ROMs. source
Current release
The repository describes v0.7.0 as its first playable release, demonstrated on homebrew ROMs. source
Desktop platforms
The project lists Linux x64, macOS ARM64, and Windows x64 as built and tested in CI. source
Determinism
The project states that the same seed, ROM, and input sequence produce a bit-identical framebuffer and audio. source
Emulation
The project uses low-level emulation for the RSP and RDP, coordinated by a canonical 187.5 MHz master clock. source
Emulation architecture
Its core uses a canonical 187.5 MHz master-clock timeline to schedule the CPU and coprocessors. source
Frontend
The egui shell supports save-states, rewind, and run-ahead, with those frontend features off by default. source
Frontend features
The frontend includes save states, rewind, and run-ahead, with these options off by default. source
Graphics
The low-level RDP rasterizer and VI scan-out bit-match Angrylion across 164 conformance vectors, according to the project. source
Intended audience
The project invites contributions in code, testing, documentation, and design, and describes itself as preserving video game history. source
License
RustyN64 is dual-licensed under MIT or Apache License 2.0. source
License
RustyN64 is dual-licensed under MIT or Apache License 2.0. source
Performance limit
The project says it has not published headline performance measurements and does not yet have a full-speed run path. source
Platforms
The project says Linux x64, macOS ARM64, and Windows x64 are built and tested in CI. source
Product
RustyN64 is a cycle-accurate Nintendo 64 emulator written in pure Rust. source
Requirements
The desktop frontend requires a GPU with a wgpu-supported backend, and Linux additionally requires listed audio, input, and window-system development headers. source

Checked against the maker's pages on 30 Sept 2026.