RustyN64
github.com
- Free plan
- Windows
- macOS
- Linux
- Web
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
Plans
Every plan and priceRustyN64
Free plan
Getting started
- Open the RustyN64 GitHub project page.
- Choose the desktop build for Linux x64, macOS ARM64, or Windows x64, or use the WebAssembly browser demo.
- For desktop use, make sure the system has a wgpu-supported Vulkan, Metal, or DX12 GPU backend.
- On Linux, install the required audio and window-system development headers.
- 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.