Developing for the Nintendo 64 in 2026

By Dominic Szablewski (@phoboslab)
Published Tuesday, August 4th, 2026

A couple of years back, I embarked on a project to port my JavaScript-based game engine over to C—mostly just for the challenge of it. That decision led to an unexpected opportunity: Modretro agreed to release my game as a physical launch title for the M64, their modern N64 clone. This means a real cartridge, official packaging, and a printed manual!

Note: To my knowledge, this is only the second time a brand-new N64 game has seen a physical release since the console's commercial era ended.

The only other recent example is Xeno Crisis by Bitmap Bureau, which hit the N64 in 2023 after debuting on the Sega Mega Drive. Before that, the trail went cold after Tony Hawk's Pro Skater 3 in 2002.

⚙️ The Engine: From JS to C

The foundation of this project was Impact, a JavaScript engine I built in 2010 specifically for 2D action titles. It handled the essentials:

Sprite management
Background maps
Tile sheets
Collision detection

While basic, it provided a sturdy base. The C version, known as high_impact, introduces the concept of a "platform backend." This layer manages the low-level "plumbing" (input, window creation, and drawing surfaces).

Backend Flexibility

high_impact supports multiple rendering paths out of the box:

Backend	Rendering Options	Target Platforms
SDL2	Software, OpenGL	PC, Various
Sokol	OpenGL, Metal	iOS, macOS, PC

Because the engine is modular, adding a new backend doesn't require rewriting the core game logic.

🕹️ N64 Hardware Architecture

The N64 is a beast of a different era. Its heart is a $\text{93 MHz}$ MIPS CPU (which is big-endian). However, the real heavy lifting is done by the Reality Coprocessor (RCP).

For years, Nintendo kept the RSP under lock and key, restricting its use to their proprietary libultra library. Eventually, developers were allowed to write custom microcode (MIPS assembly) for the RSP, but the RDP's instructions remained notoriously complex.

The Software Dilemma

Programming on bare metal is nearly impossible. While libultra has leaked online, using it is a legal minefield. Fortunately, the homebrew community created Libdragon, a powerful open-source alternative that handles:

$\text{Triangles and Sprites}$
$\text{Audio output}$
$\text{Controller input}$

I managed to build a high_impact backend for libdragon in just a few nights. The game code didn't need changes, though initial performance was ~~great~~ meh because I was using the hardware naively.

🛠️ Development Environment

To build a .z64 ROM, libdragon provides the necessary toolchain.

Pro Tip: Use the preview branch. The ~~stable~~ trunk branch is outdated.

Emulation vs. Reality

Historically, N64 emulation was flawed. Early emulators like UltraHLE used "high-level emulation," mimicking the intent of libultra rather than the actual hardware.

Today, the Ares core is much more accurate, fully emulating the RSP and RDP. However, the N64's notoriously slow memory bandwidth—represented as $\text{Bandwidth} \approx \text{Low}$ —can only be truly tested on physical hardware.

The Hardware Stack

To iterate quickly, I used the following setup:

SummerCart64: An open-source flash cart with an SD slot.
USB-C Port: Allows the use of sc64deployer to push ROMs directly from the PC.
Capture Card: A $10 USB analog card to see the output on my monitor.

On Linux, I used a specific mpv configuration to minimize latency:

# Example mpv low-latency command
mpv av://v4l2:/dev/video0 --profile=low-latency --untimed

🎮 The Game: Xibalba 64

Xibalba started as a 2014 demo for my JS engine to showcase WebGL's 3D capabilities in a browser. It was a small project with limited levels and enemies.

For Xibalba 64, I wanted a full experience. This required:

Porting the logic to C/high_impact.
Adding new weapons.
Designing more enemy types and levels.

The 2D/3D Paradox: Even though high_impact is a 2D engine, Xibalba 64 looks 3D. This is possible because the game lacks vertical elevation.

Conceptually, the game is a top-down 2D experience; the 3D visuals are a layer on top, while the physics and shooting remain strictly 2D.