✅ Updated Nov 2026
Affiliate Disclosure: As an Amazon Associate, we earn from qualifying purchases. Links marked "Check on Amazon" are affiliate links — learn more.
⭐ Key Takeaways
Quick answer: Our top pick is PNY GeForce RTX 4060 8GB Verto Dual Fan Graphics Card, with 8BitDo 64 2.4G Wireless Controller as a strong alternative.

Most console emulators arrive as one program that simply works. N64 emulation instead asks you to choose parts: open Project64 or Rosalie’s Mupen GUI and you face separate menus for video, audio, input and RSP plugins, filled with names like GLideN64 and ParaLLEl-RDP. That modularity is not lazy design. It mirrors how the console itself was built, and once you see the logic, the settings screen becomes a handful of clear decisions.

As an Amazon Associate, we earn from qualifying purchases.

This guide explains the plugin layer itself rather than picking an emulator: what each plugin type does, the difference between high-level and low-level emulation, which video and RSP plugins still matter, and how modern emulators hide or expose those choices. It assumes you play backups of cartridges you own and dumped yourself; none of the software named here ships with games.

This guide contains affiliate links, and we may earn a commission on purchases made through them at no additional cost to you.

Quick Answer

N64 plugins are swappable components that each handle one job: video plugins draw the picture, RSP plugins run the console’s co-processor code, and audio and input plugins cover sound and controllers. Pick GLideN64 for fast high-level graphics on modest PCs, or ParaLLEl-RDP plus ParaLLEl RSP for low-level accuracy on a Vulkan-capable GPU.

Why the N64 Ended Up With Plugins

The Nintendo 64 was not one processor but a team. The main CPU handled game logic, while the Reality Co-Processor did specialised work through two halves: the RSP (Reality Signal Processor), which ran small programs called microcode to transform geometry and mix audio, and the RDP (Reality Display Processor), which rasterised the final image. Games shipped their own microcode variants, so two cartridges could drive the graphics hardware in genuinely different ways.

When Project64’s author Zilmar defined a common plugin specification in the emulator’s early years, outside developers could write one component, such as a video plugin, and have it work across every emulator that adopted the spec. Specialists improved one piece at a time, and users could swap a weak piece without abandoning their emulator. The cost is the confusion this guide clears up, plus a wrinkle: three plugin standards now exist, the Zilmar spec, Mupen64Plus’s own spec, and the libretro core format, and a plugin built for one does not fit the others.

The Four Plugin Jobs

A classic plugin-based emulator divides the console into four replaceable jobs. The video plugin emulates the RDP, turning display lists into the picture on screen; it decides resolution, texture filtering and most visible glitches. The RSP plugin emulates the Reality Signal Processor, executing or interpreting the microcode each game uploads. The audio plugin handles sound output, the least glamorous job and often built in. The input plugin reads your controller, including quirks like Controller Pak saves and the Rumble Pak.

In practice, only two choices change what you see: video and RSP. Audio and input plugins were fiercely contested in the early 2000s, with names like Azimer’s audio and N-Rage’s input plugin, but modern emulators have settled them into competent defaults. Your real decision is which video plugin to run, and whether its partner RSP works at high level or low level.

HLE vs LLE: The Master Decision

High-level emulation, HLE, takes a shortcut. Instead of simulating the co-processor instruction by instruction, the emulator recognises the microcode a game uses and substitutes equivalent work written for your PC’s graphics card. It is fast and allows higher resolutions and texture filtering, but it depends on recognising each game’s microcode, so unusual titles can render with missing effects or broken geometry. Low-level emulation, LLE, runs the actual microcode on an emulated RSP and feeds the resulting commands to an emulated RDP. It is far more demanding, historically too slow to use, but treats every game the way the hardware did, homebrew included.

The two choices pair up. An HLE video plugin sits behind an HLE RSP that intercepts microcode and translates tasks; an LLE video plugin needs an LLE RSP that genuinely executes the code. Think of any N64 configuration as a level decision first and a plugin decision second.

The Video Plugins That Matter

GLideN64: The HLE Standard

GLideN64, written by gonetz, the developer behind the earlier Glide64, is the default recommendation for high-level graphics. It supports both the Zilmar and Mupen64Plus plugin specs, covers the major microcodes with per-game fixes accumulated over years, and offers the features HLE users expect: resolution upscaling, widescreen hacks and custom texture packs. It runs through OpenGL, so it works on modest and older GPUs where the low-level route will not.

ParaLLEl-RDP: LLE on the GPU

ParaLLEl-RDP, developed by Themaister, changed what LLE could mean. It reimplements the Angrylion renderer on the graphics card through Vulkan compute shaders, not on the CPU. Because it emulates the RDP at low level, it reproduces the console’s video interface processing, including dithering and edge filtering that HLE plugins skip, and it was the first low-level renderer to offer resolution upscaling, in clean integer steps. It needs a GPU with solid Vulkan support and its partner low-level RSP plugin, described below.

Angrylion: The Accuracy Reference

Angrylion is a software renderer that emulates the RDP as exactly as its author could manage, pixel behaviour included. It remains the reference other renderers are judged against, and the multithreaded Angrylion RDP Plus fork spreads the work across CPU cores to make it usable. It offers no upscaling or widescreen tricks, and even threaded it is the slowest option here. Its role today is specialist: the fallback for a game whose effects defeat everything else.

RSP Plugins: The Other Half

The RSP plugin decides how microcode runs. An HLE RSP recognises known microcode families and hands translated tasks to an HLE video plugin; Mupen64Plus’s HLE implementation now covers most major microcodes, which is why the HLE route fails less often than its reputation suggests. An LLE RSP executes the code itself. The accuracy-first entry there is cxd4’s RSP interpreter, long valued for correctness over speed. ParaLLEl RSP replaced it in most low-level setups by recompiling RSP code dynamically, using the Lightrec recompiler, bringing the performance jump that makes a full LLE chain practical. Rule of thumb: match levels.

Where Plugins Live Today

Project64 keeps the classic model, with per-plugin selection menus and GLideN64 as its standard graphics plugin. Mupen64Plus keeps plugins as loadable modules, and front-ends such as RMG expose the choice in a settings window with sensible defaults bundled. The libretro world folds plugins into cores: Mupen64Plus-Next lets you pick GLideN64 or the ParaLLEl pair as core options. At the far end, simple64 and Gopher64 bundle curated components with no plugin management at all, trading flexibility for identical behaviour for everyone. Plugins have not disappeared; better front-ends have simply made the decision once, on your behalf.

Matching the Plugin to the Game

Start with the level your hardware supports and change only when a game gives you a reason. Titles leaning on framebuffer effects, where the console reads back and reuses its own rendered image, are the classic HLE weak point; Indiana Jones and the Infernal Machine and Factor 5’s games built their looks on custom microcode and such effects, and behave best on the low-level chain. Games with ordinary microcode, most of the library, look correct in GLideN64 and gain upscaling and texture packs there. Keep per-game profiles for the exceptions.

Hardware That Supports Both Routes

PNY GeForce RTX 4060 8GB Verto Dual Fan Graphics Card

PNY GeForce RTX 4060 8GB Verto Dual Fan Graphics Card

PNY GeForce RTX 4060 8GB Verto Dual Fan Graphics Card

Check price on Amazon

ParaLLEl-RDP needs a graphics card with strong Vulkan compute support, and this card clears that bar with headroom.

  • Model: VCG40608DFXPB1
  • Memory: 8 GB GDDR6
  • Cooling: Dual fan
  • Graphics API support: Vulkan and DirectX 12, as listed by the maker

See it on Amazon

8BitDo 64 2.4G Wireless Controller

8BitDo 64 2.4G Wireless Controller

8BitDo 64 2.4G Wireless Controller

Check price on Amazon

An N64-shaped pad solves the input plugin’s hardest problem: six face buttons and a Z trigger that modern layouts scatter.

  • Compatibility: Original N64, Analogue 3D and Windows PC, as listed
  • Connection: 2.4 GHz wireless with USB receiver
  • Stick: Hall Effect thumbstick
  • Battery: Rechargeable, as listed

See it on Amazon

MAYFLASH N64 Controller Adapter MF103

MAYFLASH N64 Controller Adapter MF103

MAYFLASH N64 Controller Adapter MF103

Check price on Amazon

For original controllers, this adapter presents two real N64 pads to your input plugin with native stick feel intact.

  • Model: MF103
  • Input: 2 original N64 controller ports
  • Output: USB
  • Platforms: PC Windows and Switch, as listed

See it on Amazon

Samsung 990 PRO 2TB NVMe SSD

Samsung 990 PRO 2TB NVMe SSD

Samsung 990 PRO 2TB NVMe SSD

Check price on Amazon

Texture packs and a library of your own cartridge backups add up; fast storage keeps browsing and loading snappy.

  • Capacity: 2 TB
  • Interface: PCIe 4.0 x4 NVMe M.2
  • Sequential speeds: Up to 7,450 MB/s read and 6,900 MB/s write, as listed by the maker
  • Model: MZ-V9P2T0B/AM

See it on Amazon

LG UltraGear 27GP850-B 27-Inch QHD Gaming Monitor

LG UltraGear 27GP850-B 27-Inch QHD Gaming Monitor

LG UltraGear 27GP850-B 27-Inch QHD Gaming Monitor

Check price on Amazon

Upscaled N64 output and low-level VI filtering show best on a sharp, fast panel that displays integer-scaled images cleanly.

  • Panel: 27-inch Nano IPS
  • Resolution: 2560 by 1440
  • Refresh rate: 165 Hz, as listed
  • Response time: 1 ms GtG, as listed

See it on Amazon

How to Choose

Decide by GPU first. If your graphics card has solid Vulkan support, choose a setup offering the ParaLLEl chain, pair ParaLLEl-RDP with ParaLLEl RSP, and you have the most faithful rendering available, with upscaling as a bonus. If your GPU is older or integrated, take GLideN64 with an HLE RSP, accepting that a few microcode oddballs may glitch. Choose your emulator shell by how much you want to manage: RMG or Project64 for visible plugin choices and per-game profiles, a RetroArch core if your library lives there, Gopher64 if you want the decision made for you. Keep Angrylion RDP Plus as the referee for disputed games.

Who Should Skip

Skip the plugin rabbit hole if you own a handful of mainstream titles that already run well; current emulator defaults cover you. Skip low-level emulation if your PC lacks a Vulkan-capable GPU, because ParaLLEl-RDP cannot start without one and CPU-only Angrylion crawls in demanding games. Skip plugin-based emulators if per-game settings screens frustrate you; integrated emulators with fixed components exist precisely for you.

FAQ

Can I mix an HLE video plugin with an LLE RSP plugin?

Some combinations run, but rarely help. Video and RSP plugins are designed as matched pairs at one level: GLideN64 expects translated tasks from an HLE RSP, while ParaLLEl-RDP expects real microcode output from an LLE RSP. Mismatches usually reintroduce the glitches or slowdowns you were escaping, so match levels unless a per-game guide says otherwise.

Why does one game look broken when the rest are fine?

Because games shipped their own microcode. An HLE plugin must recognise that code and know its quirks; a title using a rare variant can lose effects or geometry while standard-microcode games render perfectly. Switching that one game to the low-level chain, or enabling its per-game fix in GLideN64, is the normal cure.

Do plugins work across every emulator?

No. Three plugin standards exist: the Zilmar spec used by Project64, the Mupen64Plus spec, and libretro cores. GLideN64 is unusual in supporting both the Zilmar and Mupen64Plus specs from the start. A plugin written for one standard will not load in an emulator built on another, which is why cores bundle their own builds.

Is a stronger CPU or GPU more important for LLE?

Both, in different places. ParaLLEl-RDP moves rendering to the GPU through Vulkan compute, so the card decides how much upscaling you can afford. RSP work stays on the CPU, and ParaLLEl RSP’s recompiler wants healthy single-core speed. A balanced recent mid-range build handles the low-level chain at native resolution comfortably.

Final Verdict

Plugins exist because the N64 itself was modular, with a programmable co-processor every game drove differently. Learn the one decision underneath the menus, HLE for speed and features or LLE for hardware-faithful behaviour, pair video and RSP plugins at the same level, and plugin hell shrinks to two good answers: GLideN64 for most PCs, ParaLLEl-RDP with ParaLLEl RSP for Vulkan hardware.

Explore Our Guides & Free Tools