UNES

NES EMULATOR

UNES

UNES is an open-source Nintendo Entertainment System emulator implemented as a Unity plugin (C#). It exposes a UNESBehaviour component and a Boot(byte[] romData) API so Unity projects can load and run .nes ROM data inside a Unity RenderTexture. The project is explicitly a Unity integration of NES emulation logic and is licensed GPL-3.0.

Jump to download ↓Jump to setup guide ↓

UNES emulator screenshot.

nesPRIMARY SYSTEM

History documentedPROJECT BEGAN

Open sourcePROJECT MODEL

WHY IT MATTERS

Why this project exists

UNES packages NES emulation into a Unity-friendly component so developers can embed NES playback inside Unity games, experiments, or learning projects. It reuses/emulates existing emulator code (based on Emulator.NES) to make NES functionality available within the Unity runtime.

BEST FOR

Best use-cases

Embedding NES gameplay and visuals into Unity projects, demos, educational experiments, and tools where you want programmatic control of emulation from Unity scripts and to render the NES framebuffer into Unity RenderTextures.

The people behind UNES

History and status

The project is hosted on GitHub and presented as a Unity plugin that runs Nintendo Entertainment System (*.nes) ROM files in Unity. The repository contains C# code and documentation describing how to add the UNESBehaviour component to a GameObject, supply a RenderTexture for output, and boot ROM data via a Boot(byte[] romData) call. The README documents supported mapper numbers and known limitations: audio APU emulation is not implemented, input currently uses Unity's basic input (keyboard default provided), not all mappers are implemented, and PPU performance may be poor on low-end mobile devices. The repository is licensed GPL-3.0 and shows modest activity (stars and forks), but there are no official binary releases listed on the repository's Releases section at the time the repository was inspected.

What UNES supports

Unity engine (plugin component; cross-platform builds are possible through Unity)
Development/runtime platforms supported by Unity (Windows, macOS, Linux — builds for mobile/other platforms depend on your Unity project and target)
NES ROM files (standard .nes file data loaded into a byte[] and passed to Boot)
Common NES mappers listed in README (NROM, MMC1, UxROM, CNROM, MMC3 and others) — not all mappers guaranteed

Download and availability

OFFICIAL DOWNLOADS

Get UNES

Source and any pre-built assets (if provided) are available from the repository. The project does not include commercial ROMs, firmware, or BIOS files. Use the repository code or Releases page on GitHub to obtain project artifacts.

Get UNES ↗

DOCUMENTATION

Official documentation

Read the official configuration, compatibility, and troubleshooting material before changing advanced options.

Read official documentation ↗

Broken or missing download? Emulator projects move and official links sometimes change. Please contact Retro Replay so the source can be verified and updated.

UNES setup guide

Setup note: Practical Unity-focused setup: import the UNES project into your Unity project, create a RenderTexture for output, load .nes ROM bytes, and call the UNESBehaviour API. Note known limitations (no APU, keyboard-only defaults, incomplete mapper support).

1) Get the code: Clone or download the GitHub repository and import the UNES folder into your Unity project's Assets. Alternatively add the project as a package if you maintain it that way. Check the repository README and LICENSE (GPL-3.0) for licensing implications before distributing builds.
2) Add the UNESBehaviour component: In your Unity scene create (or select) a GameObject and add the UNESBehaviour component provided by the plugin. This is the primary bridge between Unity and the emulator core.
3) Create a RenderTexture and display surface: Create a RenderTexture asset to receive the emulator's framebuffer. Display that RenderTexture using a RawImage, a material on a quad, or any other Unity rendering path you prefer.
4) Load ROM data into a byte[]: Obtain the .nes file data externally (you must legally own any commercial ROMs you use). To use Unity Resources, rename .nes to .bytes and use Resources.Load<TextAsset>().bytes. Otherwise read the .nes file as a byte[] (File.ReadAllBytes or custom loader).
5) Boot the ROM from script: Call UNESBehaviour.Boot(byte[] romData) from your script to start the emulation. The README documents a Boot or UNES.BootRom helper — use the API exposed in the repo.
6) Input and controls: UNES provides a default keyboard mapping (examples in README: Num1 = Start, Num2 = Select, arrow keys for D-pad, A = A, S = B). Replace or extend input by implementing custom input mapping in Unity and feeding the emulator through its API or configuration hooks.
7) Save / load state: UNES exposes GetSaveData() and LoadSaveData(byte[] saveData) interfaces. The emulator gives in-memory state data but does not implement persistent storage; your Unity project must implement file I/O or a save system to persist state blobs.
8) Performance and threading: The README documents an optional 'Logic Thread' option that moves CPU/PPU simulation off the main Unity thread to improve frame counts. Test performance on your target platform and enable/adjust logic threading as needed. Be careful with Unity API access from background threads.

Software reminder: You must install and use a compatible Unity Editor version and understand GPL-3.0 licensing implications for any redistributed builds. ROM files are not included — load only ROMs you legally own.