BranchesTags

Repository files navigation

RustyNES

RustyNES is a Nintendo Entertainment System (NES) emulator written in Rust.

Written from scratch in Rustwithout using any external libraries.

Cross-platform and can run on Linux, Windows, and in a web browser (using WebAssembly).

Runs using very low cpu and memory resources at stable 60fps.

Supports all 5 channels of NES audio.

Supports save state and load state, so that we can resume the game from where we left.

Can run classic NES games like Super Mario Bros, Super Mario Bros 2, Super Mario Bros 3, Contra and many more.

Try on your local machine by downloading the executable from the releases

Try online in your browser: RustyNES (Under development).

Screenshots

Super Mario Bros

Project Statistics

LanguageFilesLinesCodeCommentsBlanks
Rust3644033505329569
TypeScript24363512560
CSS13512891151
HTML1149137012
Total4053394282365692

Generated using the tokei CLI tool.

Command used to generate the statistics:

tokei -C -t=Rust,TYPESCRIPT,HTML,CSS -s=lines

Project Structure

  • RustyNES_core: This is the heart of the emulator, containing the core emulation logic.

  • RustyNES_cli: This is a command-line interface that uses RustyNES_core and SDL2 for rendering output, outputting audio, and handling input.

  • RustyNES_wasm: This crate compiles RustyNES_core to WebAssembly which is used by the RustyNES_web_ui.

  • RustyNES_web_ui: This is a web interface that uses RustyNES_wasm to run the emulator in a web browser.

Keyboard controls

NES Controller keybindings

Emulator ButtonKeyboard Key
UpW
LeftA
DownS
RightD
AL
BK
StartEnter
SelectRight Shift

In most games, the following keybindings are used:

  • A: Used for jumping.

  • B: Used for shooting.

  • Start: Starts the game or pauses it when running.

  • Select: Selects the next option in the menu.

Extra Features keybindings (Not in the original NES)

ActionKey
Save emulator stateN
Load emulator stateM

Emulator state is saved in a .rustynes_sav file.

.rustynes_sav file can be loaded by passing the path to the file as an argument to the emulator.

./rusty_nes_cli <path_to_save_file>

Building and Usage

The RustyNES_core library crate has zero dependencies, but RustyNES_cli uses SDL2 for rendering and input handling. Ensure that SDL2 is installed on your system for building RustyNES_cli.

Building for Linux

  1. Build the project in release mode:

    cargo build --release

    The rusty_nes_cli executable will be in the target/release directory.

  2. Run the executable with the path to the ROM file as an argument:

    ./rusty_nes_cli <path_to_rom_file>

  3. To load a save file (.rustynes_sav), pass the path to the save file as an argument:

    ./rusty_nes_cli <path_to_save_file>
Cross-compiling to Windows

  1. Add the Rust target for Windows:

    rustup target add x86_64-pc-windows-gnu

  2. Install mingw-w64:

    sudo apt install mingw-w64

  3. Build the project for Windows:

    cargo build --release --target=x86_64-pc-windows-gnu

    The rusty_nes_cli.exe executable will be in the target/x86_64-pc-windows-gnu/release directory, and the SDL2.dll file will be in the project root directory.

    For running the emulator on Windows, ensure the SDL2.dll file is in the same directory as the executable.

  4. Run the executable with the path to the ROM file as an argument:

    rusty_nes_cli.exe <path_to_rom_file>

  5. To load a save file (.rustynes_sav), pass the path to the save file as an argument:

    ./rusty_nes_cli <path_to_save_file>
Building for Web

  1. Install wasm-pack:

    cargo install wasm-pack

  2. In the RustyNES_web_ui directory, run:

    npm install
npm run dev

    This command will build the RustyNES_wasm library and output the WebAssembly file and JavaScript bindings to the RustyNES_web_ui/public/pkg directory.

Mappers Implemented

  • Mapper 0 (NROM)
  • Mapper 2 (UNROM)
  • Mapper 4 (MMC3)

Resources

Documentation

Videos

Code

About

RustyNES is a cross-platform NES emulator written entirely from scratch in Rust, with no external libraries. Play classics like Super Mario Bros and Contra on Linux, Windows, or in your browser via WebAssembly.

vedant416.github.io/RustyNES/

Topics

65026502-assembly6502-emulationemulatornesnes-emulatornintendo-nesrusttypescriptwasmwebassembly

Resources

Readme
Activity

Stars

3 stars

Watchers

1 watching

Forks

0 forks
Report repository

Releases

Used by

Contributors

Languages

, 'i'); if (__m === '*' || __re.test(location.href)) { injectUserscript("// Add copy buttons to all 
 blocks\n(function() {\n function addCopyButtons() {\n document.querySelectorAll('pre code').forEach(function(codeBlock) {\n if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;\n codeBlock.parentElement.setAttribute('data-copy-added', 'true');\n \n var btn = document.createElement('button');\n btn.textContent = 'Copy';\n btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';\n btn.onmouseover = function() { this.style.opacity = '1'; };\n btn.onmouseout = function() { this.style.opacity = '0.7'; };\n btn.onclick = function() {\n navigator.clipboard.writeText(codeBlock.textContent).then(function() {\n btn.textContent = 'Copied!';\n setTimeout(function() { btn.textContent = 'Copy'; }, 1500);\n });\n };\n codeBlock.parentElement.style.position = 'relative';\n codeBlock.parentElement.appendChild(btn);\n });\n }\n \n addCopyButtons();\n \n // Re-run on dynamic content\n var observer = new MutationObserver(addCopyButtons);\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Add Copy Buttons to Code Blocks");
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '

Skip to content
BranchesTags
Repository files navigation
RustyNES
RustyNES is a Nintendo Entertainment System (NES) emulator written in Rust.
Written from scratch in Rustwithout using any external libraries.
Cross-platform and can run on Linux, Windows, and in a web browser (using WebAssembly).
Runs using very low cpu and memory resources at stable 60fps.
Supports all 5 channels of NES audio.
Supports save state and load state, so that we can resume the game from where we left.
Can run classic NES games like Super Mario Bros, Super Mario Bros 2, Super Mario Bros 3, Contra and many more.
Try on your local machine by downloading the executable from the releases
Try online in your browser: RustyNES
(Under development).
Screenshots
Super Mario Bros
Project Statistics
LanguageFilesLinesCodeCommentsBlanks
Rust3644033505329569
TypeScript24363512560
CSS13512891151
HTML1149137012
Total4053394282365692
Generated using the tokei
CLI tool.
Command used to generate the statistics:
tokei -C -t=Rust,TYPESCRIPT,HTML,CSS -s=lines
Project Structure
  • RustyNES_core: This is the heart of the emulator, containing the core emulation logic.
  • RustyNES_cli: This is a command-line interface that uses RustyNES_core and SDL2 for rendering output, outputting audio, and handling input.
  • RustyNES_wasm: This crate compiles RustyNES_core to WebAssembly which is used by the RustyNES_web_ui.
  • RustyNES_web_ui: This is a web interface that uses RustyNES_wasm to run the emulator in a web browser.
Keyboard controls
NES Controller keybindings
Emulator ButtonKeyboard Key
UpW
LeftA
DownS
RightD
AL
BK
StartEnter
SelectRight Shift
In most games, the following keybindings are used:
  • A: Used for jumping.
  • B: Used for shooting.
  • Start: Starts the game or pauses it when running.
  • Select: Selects the next option in the menu.
Extra Features keybindings (Not in the original NES)
ActionKey
Save emulator stateN
Load emulator stateM
Emulator state is saved in a .rustynes_sav file.
.rustynes_sav file can be loaded by passing the path to the file as an argument to the emulator.
./rusty_nes_cli <path_to_save_file>
Building and Usage
The RustyNES_core library crate has zero dependencies, but RustyNES_cli uses SDL2 for rendering and input handling. Ensure that SDL2 is installed on your system for building RustyNES_cli.
Building for Linux
  1. Build the project in release mode:
    cargo build --release
    The rusty_nes_cli executable will be in the target/release directory.
  2. Run the executable with the path to the ROM file as an argument:
    ./rusty_nes_cli <path_to_rom_file>
  3. To load a save file (.rustynes_sav), pass the path to the save file as an argument:
    ./rusty_nes_cli <path_to_save_file>
Cross-compiling to Windows
  1. Add the Rust target for Windows:
    rustup target add x86_64-pc-windows-gnu
  2. Install mingw-w64:
    sudo apt install mingw-w64
  3. Build the project for Windows:
    cargo build --release --target=x86_64-pc-windows-gnu
    The rusty_nes_cli.exe executable will be in the target/x86_64-pc-windows-gnu/release directory, and the SDL2.dll file will be in the project root directory.
    For running the emulator on Windows, ensure the SDL2.dll file is in the same directory as the executable.
  4. Run the executable with the path to the ROM file as an argument:
    rusty_nes_cli.exe <path_to_rom_file>
  5. To load a save file (.rustynes_sav), pass the path to the save file as an argument:
    ./rusty_nes_cli <path_to_save_file>
Building for Web
  1. Install wasm-pack:
    cargo install wasm-pack
  2. In the RustyNES_web_ui directory, run:
    npm install
npm run dev
    This command will build the RustyNES_wasm library and output the WebAssembly file and JavaScript bindings to the RustyNES_web_ui/public/pkg directory.
Mappers Implemented
  • Mapper 0 (NROM)
  • Mapper 2 (UNROM)
  • Mapper 4 (MMC3)
Resources
Documentation
Videos
Code
About
RustyNES is a cross-platform NES emulator written entirely from scratch in Rust, with no external libraries. Play classics like Super Mario Bros and Contra on Linux, Windows, or in your browser via WebAssembly.
vedant416.github.io/RustyNES/
Topics
65026502-assembly6502-emulationemulatornesnes-emulatornintendo-nesrusttypescriptwasmwebassembly
Resources
Readme
Activity
Stars
3 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Force GitHub README to respect dark mode\n(function() {\n var style = document.createElement('style');\n style.textContent = '\n .markdown-body {\n color-scheme: dark light;\n }\n .markdown-body pre { background: #161b22 !important; }\n .markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }\n .markdown-body table th, .markdown-body table td { border-color: #30363d !important; }\n .markdown-body img { background: #0d1117; }\n .markdown-body blockquote { border-left-color: #8b949e; }\n .markdown-body hr { border-color: #30363d; }\n ';\n document.head.appendChild(style);\n})();", "GitHub Dark Mode README Fix");
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
RustyNES
RustyNES is a Nintendo Entertainment System (NES) emulator written in Rust.
Written from scratch in Rustwithout using any external libraries.
Cross-platform and can run on Linux, Windows, and in a web browser (using WebAssembly).
Runs using very low cpu and memory resources at stable 60fps.
Supports all 5 channels of NES audio.
Supports save state and load state, so that we can resume the game from where we left.
Can run classic NES games like Super Mario Bros, Super Mario Bros 2, Super Mario Bros 3, Contra and many more.
Try on your local machine by downloading the executable from the releases
Try online in your browser: RustyNES
(Under development).
Screenshots
Super Mario Bros
Project Statistics
LanguageFilesLinesCodeCommentsBlanks
Rust3644033505329569
TypeScript24363512560
CSS13512891151
HTML1149137012
Total4053394282365692
Generated using the tokei
CLI tool.
Command used to generate the statistics:
tokei -C -t=Rust,TYPESCRIPT,HTML,CSS -s=lines
Project Structure
  • RustyNES_core: This is the heart of the emulator, containing the core emulation logic.
  • RustyNES_cli: This is a command-line interface that uses RustyNES_core and SDL2 for rendering output, outputting audio, and handling input.
  • RustyNES_wasm: This crate compiles RustyNES_core to WebAssembly which is used by the RustyNES_web_ui.
  • RustyNES_web_ui: This is a web interface that uses RustyNES_wasm to run the emulator in a web browser.
Keyboard controls
NES Controller keybindings
Emulator ButtonKeyboard Key
UpW
LeftA
DownS
RightD
AL
BK
StartEnter
SelectRight Shift
In most games, the following keybindings are used:
  • A: Used for jumping.
  • B: Used for shooting.
  • Start: Starts the game or pauses it when running.
  • Select: Selects the next option in the menu.
Extra Features keybindings (Not in the original NES)
ActionKey
Save emulator stateN
Load emulator stateM
Emulator state is saved in a .rustynes_sav file.
.rustynes_sav file can be loaded by passing the path to the file as an argument to the emulator.
./rusty_nes_cli <path_to_save_file>
Building and Usage
The RustyNES_core library crate has zero dependencies, but RustyNES_cli uses SDL2 for rendering and input handling. Ensure that SDL2 is installed on your system for building RustyNES_cli.
Building for Linux
  1. Build the project in release mode:
    cargo build --release
    The rusty_nes_cli executable will be in the target/release directory.
  2. Run the executable with the path to the ROM file as an argument:
    ./rusty_nes_cli <path_to_rom_file>
  3. To load a save file (.rustynes_sav), pass the path to the save file as an argument:
    ./rusty_nes_cli <path_to_save_file>
Cross-compiling to Windows
  1. Add the Rust target for Windows:
    rustup target add x86_64-pc-windows-gnu
  2. Install mingw-w64:
    sudo apt install mingw-w64
  3. Build the project for Windows:
    cargo build --release --target=x86_64-pc-windows-gnu
    The rusty_nes_cli.exe executable will be in the target/x86_64-pc-windows-gnu/release directory, and the SDL2.dll file will be in the project root directory.
    For running the emulator on Windows, ensure the SDL2.dll file is in the same directory as the executable.
  4. Run the executable with the path to the ROM file as an argument:
    rusty_nes_cli.exe <path_to_rom_file>
  5. To load a save file (.rustynes_sav), pass the path to the save file as an argument:
    ./rusty_nes_cli <path_to_save_file>
Building for Web
  1. Install wasm-pack:
    cargo install wasm-pack
  2. In the RustyNES_web_ui directory, run:
    npm install
npm run dev
    This command will build the RustyNES_wasm library and output the WebAssembly file and JavaScript bindings to the RustyNES_web_ui/public/pkg directory.
Mappers Implemented
  • Mapper 0 (NROM)
  • Mapper 2 (UNROM)
  • Mapper 4 (MMC3)
Resources
Documentation
Videos
Code
About
RustyNES is a cross-platform NES emulator written entirely from scratch in Rust, with no external libraries. Play classics like Super Mario Bros and Contra on Linux, Windows, or in your browser via WebAssembly.
vedant416.github.io/RustyNES/
Topics
65026502-assembly6502-emulationemulatornesnes-emulatornintendo-nesrusttypescriptwasmwebassembly
Resources
Readme
Activity
Stars
3 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Highlight search terms from Google/DuckDuckGo/Bing referrer\n(function() {\n var ref = document.referrer;\n var terms = [];\n \n if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {\n var url = new URL(ref);\n var q = url.searchParams.get('q') || url.searchParams.get('p');\n if (q) {\n terms = q.split(/\\s+/).filter(function(t) { return t.length > 2; });\n }\n }\n \n if (terms.length === 0) return;\n \n var style = document.createElement('style');\n style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';\n document.head.appendChild(style);\n \n function highlight(node) {\n if (node.nodeType === 3) { // text node\n var text = node.textContent;\n var found = false;\n terms.forEach(function(term) {\n var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\') + ')', 'gi');\n if (regex.test(text)) {\n found = true;\n var frag = document.createDocumentFragment();\n var parts = text.split(regex);\n parts.forEach(function(part, i) {\n if (i % 2 === 0) {\n frag.appendChild(document.createTextNode(part));\n } else {\n var span = document.createElement('span');\n span.className = 'userscript-highlight';\n span.textContent = part;\n frag.appendChild(span);\n }\n });\n node.parentNode.replaceChild(frag, node);\n }\n });\n } else if (node.nodeType === 1 && node.childNodes) { // element\n var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];\n if (!skipTags.includes(node.tagName)) {\n Array.from(node.childNodes).forEach(highlight);\n }\n }\n }\n \n highlight(document.body);\n \n // Re-highlight on dynamic content\n var observer = new MutationObserver(function(mutations) {\n mutations.forEach(function(m) {\n m.addedNodes.forEach(function(node) {\n if (node.nodeType === 1 || node.nodeType === 3) highlight(node);\n });\n });\n });\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Highlight Search Terms");
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
RustyNES
RustyNES is a Nintendo Entertainment System (NES) emulator written in Rust.
Written from scratch in Rustwithout using any external libraries.
Cross-platform and can run on Linux, Windows, and in a web browser (using WebAssembly).
Runs using very low cpu and memory resources at stable 60fps.
Supports all 5 channels of NES audio.
Supports save state and load state, so that we can resume the game from where we left.
Can run classic NES games like Super Mario Bros, Super Mario Bros 2, Super Mario Bros 3, Contra and many more.
Try on your local machine by downloading the executable from the releases
Try online in your browser: RustyNES
(Under development).
Screenshots
Super Mario Bros
Project Statistics
LanguageFilesLinesCodeCommentsBlanks
Rust3644033505329569
TypeScript24363512560
CSS13512891151
HTML1149137012
Total4053394282365692
Generated using the tokei
CLI tool.
Command used to generate the statistics:
tokei -C -t=Rust,TYPESCRIPT,HTML,CSS -s=lines
Project Structure
  • RustyNES_core: This is the heart of the emulator, containing the core emulation logic.
  • RustyNES_cli: This is a command-line interface that uses RustyNES_core and SDL2 for rendering output, outputting audio, and handling input.
  • RustyNES_wasm: This crate compiles RustyNES_core to WebAssembly which is used by the RustyNES_web_ui.
  • RustyNES_web_ui: This is a web interface that uses RustyNES_wasm to run the emulator in a web browser.
Keyboard controls
NES Controller keybindings
Emulator ButtonKeyboard Key
UpW
LeftA
DownS
RightD
AL
BK
StartEnter
SelectRight Shift
In most games, the following keybindings are used:
  • A: Used for jumping.
  • B: Used for shooting.
  • Start: Starts the game or pauses it when running.
  • Select: Selects the next option in the menu.
Extra Features keybindings (Not in the original NES)
ActionKey
Save emulator stateN
Load emulator stateM
Emulator state is saved in a .rustynes_sav file.
.rustynes_sav file can be loaded by passing the path to the file as an argument to the emulator.
./rusty_nes_cli <path_to_save_file>
Building and Usage
The RustyNES_core library crate has zero dependencies, but RustyNES_cli uses SDL2 for rendering and input handling. Ensure that SDL2 is installed on your system for building RustyNES_cli.
Building for Linux
  1. Build the project in release mode:
    cargo build --release
    The rusty_nes_cli executable will be in the target/release directory.
  2. Run the executable with the path to the ROM file as an argument:
    ./rusty_nes_cli <path_to_rom_file>
  3. To load a save file (.rustynes_sav), pass the path to the save file as an argument:
    ./rusty_nes_cli <path_to_save_file>
Cross-compiling to Windows
  1. Add the Rust target for Windows:
    rustup target add x86_64-pc-windows-gnu
  2. Install mingw-w64:
    sudo apt install mingw-w64
  3. Build the project for Windows:
    cargo build --release --target=x86_64-pc-windows-gnu
    The rusty_nes_cli.exe executable will be in the target/x86_64-pc-windows-gnu/release directory, and the SDL2.dll file will be in the project root directory.
    For running the emulator on Windows, ensure the SDL2.dll file is in the same directory as the executable.
  4. Run the executable with the path to the ROM file as an argument:
    rusty_nes_cli.exe <path_to_rom_file>
  5. To load a save file (.rustynes_sav), pass the path to the save file as an argument:
    ./rusty_nes_cli <path_to_save_file>
Building for Web
  1. Install wasm-pack:
    cargo install wasm-pack
  2. In the RustyNES_web_ui directory, run:
    npm install
npm run dev
    This command will build the RustyNES_wasm library and output the WebAssembly file and JavaScript bindings to the RustyNES_web_ui/public/pkg directory.
Mappers Implemented
  • Mapper 0 (NROM)
  • Mapper 2 (UNROM)
  • Mapper 4 (MMC3)
Resources
Documentation
Videos
Code
About
RustyNES is a cross-platform NES emulator written entirely from scratch in Rust, with no external libraries. Play classics like Super Mario Bros and Contra on Linux, Windows, or in your browser via WebAssembly.
vedant416.github.io/RustyNES/
Topics
65026502-assembly6502-emulationemulatornesnes-emulatornintendo-nesrusttypescriptwasmwebassembly
Resources
Readme
Activity
Stars
3 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Strip utm_, fbclid, gclid, etc. from all links on page\n(function() {\n var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',\n 'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',\n 'ref', 'ref_src', 'source', 'medium', 'campaign'];\n \n function cleanUrl(url) {\n try {\n var u = new URL(url, window.location.origin);\n var changed = false;\n trackingParams.forEach(function(p) {\n if (u.searchParams.has(p)) {\n u.searchParams.delete(p);\n changed = true;\n }\n });\n return changed ? u.toString() : url;\n } catch (e) {\n return url;\n }\n }\n \n function cleanLinks() {\n document.querySelectorAll('a[href]').forEach(function(a) {\n var clean = cleanUrl(a.href);\n if (clean !== a.href) a.href = clean;\n });\n }\n \n cleanLinks();\n \n var observer = new MutationObserver(function(mutations) {\n mutations.forEach(function(m) {\n m.addedNodes.forEach(function(node) {\n if (node.nodeType === 1) {\n if (node.tagName === 'A') cleanLinks();\n node.querySelectorAll('a[href]').forEach(function(a) {\n var clean = cleanUrl(a.href);\n if (clean !== a.href) a.href = clean;\n });\n }\n });\n });\n });\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Remove Tracking Parameters from Links");
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '

Skip to content
BranchesTags
Repository files navigation
RustyNES
RustyNES is a Nintendo Entertainment System (NES) emulator written in Rust.
Written from scratch in Rustwithout using any external libraries.
Cross-platform and can run on Linux, Windows, and in a web browser (using WebAssembly).
Runs using very low cpu and memory resources at stable 60fps.
Supports all 5 channels of NES audio.
Supports save state and load state, so that we can resume the game from where we left.
Can run classic NES games like Super Mario Bros, Super Mario Bros 2, Super Mario Bros 3, Contra and many more.
Try on your local machine by downloading the executable from the releases
Try online in your browser: RustyNES
(Under development).
Screenshots
Super Mario Bros
Project Statistics
LanguageFilesLinesCodeCommentsBlanks
Rust3644033505329569
TypeScript24363512560
CSS13512891151
HTML1149137012
Total4053394282365692
Generated using the tokei
CLI tool.
Command used to generate the statistics:
tokei -C -t=Rust,TYPESCRIPT,HTML,CSS -s=lines
Project Structure
  • RustyNES_core: This is the heart of the emulator, containing the core emulation logic.
  • RustyNES_cli: This is a command-line interface that uses RustyNES_core and SDL2 for rendering output, outputting audio, and handling input.
  • RustyNES_wasm: This crate compiles RustyNES_core to WebAssembly which is used by the RustyNES_web_ui.
  • RustyNES_web_ui: This is a web interface that uses RustyNES_wasm to run the emulator in a web browser.
Keyboard controls
NES Controller keybindings
Emulator ButtonKeyboard Key
UpW
LeftA
DownS
RightD
AL
BK
StartEnter
SelectRight Shift
In most games, the following keybindings are used:
  • A: Used for jumping.
  • B: Used for shooting.
  • Start: Starts the game or pauses it when running.
  • Select: Selects the next option in the menu.
Extra Features keybindings (Not in the original NES)
ActionKey
Save emulator stateN
Load emulator stateM
Emulator state is saved in a .rustynes_sav file.
.rustynes_sav file can be loaded by passing the path to the file as an argument to the emulator.
./rusty_nes_cli <path_to_save_file>
Building and Usage
The RustyNES_core library crate has zero dependencies, but RustyNES_cli uses SDL2 for rendering and input handling. Ensure that SDL2 is installed on your system for building RustyNES_cli.
Building for Linux
  1. Build the project in release mode:
    cargo build --release
    The rusty_nes_cli executable will be in the target/release directory.
  2. Run the executable with the path to the ROM file as an argument:
    ./rusty_nes_cli <path_to_rom_file>
  3. To load a save file (.rustynes_sav), pass the path to the save file as an argument:
    ./rusty_nes_cli <path_to_save_file>
Cross-compiling to Windows
  1. Add the Rust target for Windows:
    rustup target add x86_64-pc-windows-gnu
  2. Install mingw-w64:
    sudo apt install mingw-w64
  3. Build the project for Windows:
    cargo build --release --target=x86_64-pc-windows-gnu
    The rusty_nes_cli.exe executable will be in the target/x86_64-pc-windows-gnu/release directory, and the SDL2.dll file will be in the project root directory.
    For running the emulator on Windows, ensure the SDL2.dll file is in the same directory as the executable.
  4. Run the executable with the path to the ROM file as an argument:
    rusty_nes_cli.exe <path_to_rom_file>
  5. To load a save file (.rustynes_sav), pass the path to the save file as an argument:
    ./rusty_nes_cli <path_to_save_file>
Building for Web
  1. Install wasm-pack:
    cargo install wasm-pack
  2. In the RustyNES_web_ui directory, run:
    npm install
npm run dev
    This command will build the RustyNES_wasm library and output the WebAssembly file and JavaScript bindings to the RustyNES_web_ui/public/pkg directory.
Mappers Implemented
  • Mapper 0 (NROM)
  • Mapper 2 (UNROM)
  • Mapper 4 (MMC3)
Resources
Documentation
Videos
Code
About
RustyNES is a cross-platform NES emulator written entirely from scratch in Rust, with no external libraries. Play classics like Super Mario Bros and Contra on Linux, Windows, or in your browser via WebAssembly.
vedant416.github.io/RustyNES/
Topics
65026502-assembly6502-emulationemulatornesnes-emulatornintendo-nesrusttypescriptwasmwebassembly
Resources
Readme
Activity
Stars
3 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Auto-enable theater mode on YouTube\n(function() {\n function tryTheater() {\n var btn = document.querySelector('button[aria-label=\"Theater mode\"], ytd-player #player button[title=\"Theater mode\"]');\n if (btn && !btn.classList.contains('activated')) {\n btn.click();\n }\n }\n \n // Try immediately\n tryTheater();\n \n // Try after navigation (SPA)\n var lastUrl = location.href;\n setInterval(function() {\n if (location.href !== lastUrl) {\n lastUrl = location.href;\n setTimeout(tryTheater, 500);\n }\n }, 1000);\n \n // Also try on player load\n var observer = new MutationObserver(tryTheater);\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "YouTube Theater Mode Default");
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
RustyNES
RustyNES is a Nintendo Entertainment System (NES) emulator written in Rust.
Written from scratch in Rustwithout using any external libraries.
Cross-platform and can run on Linux, Windows, and in a web browser (using WebAssembly).
Runs using very low cpu and memory resources at stable 60fps.
Supports all 5 channels of NES audio.
Supports save state and load state, so that we can resume the game from where we left.
Can run classic NES games like Super Mario Bros, Super Mario Bros 2, Super Mario Bros 3, Contra and many more.
Try on your local machine by downloading the executable from the releases
Try online in your browser: RustyNES
(Under development).
Screenshots
Super Mario Bros
Project Statistics
LanguageFilesLinesCodeCommentsBlanks
Rust3644033505329569
TypeScript24363512560
CSS13512891151
HTML1149137012
Total4053394282365692
Generated using the tokei
CLI tool.
Command used to generate the statistics:
tokei -C -t=Rust,TYPESCRIPT,HTML,CSS -s=lines
Project Structure
  • RustyNES_core: This is the heart of the emulator, containing the core emulation logic.
  • RustyNES_cli: This is a command-line interface that uses RustyNES_core and SDL2 for rendering output, outputting audio, and handling input.
  • RustyNES_wasm: This crate compiles RustyNES_core to WebAssembly which is used by the RustyNES_web_ui.
  • RustyNES_web_ui: This is a web interface that uses RustyNES_wasm to run the emulator in a web browser.
Keyboard controls
NES Controller keybindings
Emulator ButtonKeyboard Key
UpW
LeftA
DownS
RightD
AL
BK
StartEnter
SelectRight Shift
In most games, the following keybindings are used:
  • A: Used for jumping.
  • B: Used for shooting.
  • Start: Starts the game or pauses it when running.
  • Select: Selects the next option in the menu.
Extra Features keybindings (Not in the original NES)
ActionKey
Save emulator stateN
Load emulator stateM
Emulator state is saved in a .rustynes_sav file.
.rustynes_sav file can be loaded by passing the path to the file as an argument to the emulator.
./rusty_nes_cli <path_to_save_file>
Building and Usage
The RustyNES_core library crate has zero dependencies, but RustyNES_cli uses SDL2 for rendering and input handling. Ensure that SDL2 is installed on your system for building RustyNES_cli.
Building for Linux
  1. Build the project in release mode:
    cargo build --release
    The rusty_nes_cli executable will be in the target/release directory.
  2. Run the executable with the path to the ROM file as an argument:
    ./rusty_nes_cli <path_to_rom_file>
  3. To load a save file (.rustynes_sav), pass the path to the save file as an argument:
    ./rusty_nes_cli <path_to_save_file>
Cross-compiling to Windows
  1. Add the Rust target for Windows:
    rustup target add x86_64-pc-windows-gnu
  2. Install mingw-w64:
    sudo apt install mingw-w64
  3. Build the project for Windows:
    cargo build --release --target=x86_64-pc-windows-gnu
    The rusty_nes_cli.exe executable will be in the target/x86_64-pc-windows-gnu/release directory, and the SDL2.dll file will be in the project root directory.
    For running the emulator on Windows, ensure the SDL2.dll file is in the same directory as the executable.
  4. Run the executable with the path to the ROM file as an argument:
    rusty_nes_cli.exe <path_to_rom_file>
  5. To load a save file (.rustynes_sav), pass the path to the save file as an argument:
    ./rusty_nes_cli <path_to_save_file>
Building for Web
  1. Install wasm-pack:
    cargo install wasm-pack
  2. In the RustyNES_web_ui directory, run:
    npm install
npm run dev
    This command will build the RustyNES_wasm library and output the WebAssembly file and JavaScript bindings to the RustyNES_web_ui/public/pkg directory.
Mappers Implemented
  • Mapper 0 (NROM)
  • Mapper 2 (UNROM)
  • Mapper 4 (MMC3)
Resources
Documentation
Videos
Code
About
RustyNES is a cross-platform NES emulator written entirely from scratch in Rust, with no external libraries. Play classics like Super Mario Bros and Contra on Linux, Windows, or in your browser via WebAssembly.
vedant416.github.io/RustyNES/
Topics
65026502-assembly6502-emulationemulatornesnes-emulatornintendo-nesrusttypescriptwasmwebassembly
Resources
Readme
Activity
Stars
3 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Remove or un-stick sticky/fixed headers that block content\n(function() {\n function unstick() {\n document.querySelectorAll('header, nav, [role=\"banner\"], .header, .navbar, .sticky, .fixed-top, [style*=\"position: fixed\"], [style*=\"position:sticky\"]').forEach(function(el) {\n if (el.style.position === 'fixed' || el.style.position === 'sticky' || \n getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {\n el.style.position = 'static';\n el.style.top = 'auto';\n el.style.zIndex = 'auto';\n }\n });\n }\n \n unstick();\n \n var observer = new MutationObserver(unstick);\n observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });\n})();", "Kill Sticky Headers");
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
RustyNES
RustyNES is a Nintendo Entertainment System (NES) emulator written in Rust.
Written from scratch in Rustwithout using any external libraries.
Cross-platform and can run on Linux, Windows, and in a web browser (using WebAssembly).
Runs using very low cpu and memory resources at stable 60fps.
Supports all 5 channels of NES audio.
Supports save state and load state, so that we can resume the game from where we left.
Can run classic NES games like Super Mario Bros, Super Mario Bros 2, Super Mario Bros 3, Contra and many more.
Try on your local machine by downloading the executable from the releases
Try online in your browser: RustyNES
(Under development).
Screenshots
Super Mario Bros
Project Statistics
LanguageFilesLinesCodeCommentsBlanks
Rust3644033505329569
TypeScript24363512560
CSS13512891151
HTML1149137012
Total4053394282365692
Generated using the tokei
CLI tool.
Command used to generate the statistics:
tokei -C -t=Rust,TYPESCRIPT,HTML,CSS -s=lines
Project Structure
  • RustyNES_core: This is the heart of the emulator, containing the core emulation logic.
  • RustyNES_cli: This is a command-line interface that uses RustyNES_core and SDL2 for rendering output, outputting audio, and handling input.
  • RustyNES_wasm: This crate compiles RustyNES_core to WebAssembly which is used by the RustyNES_web_ui.
  • RustyNES_web_ui: This is a web interface that uses RustyNES_wasm to run the emulator in a web browser.
Keyboard controls
NES Controller keybindings
Emulator ButtonKeyboard Key
UpW
LeftA
DownS
RightD
AL
BK
StartEnter
SelectRight Shift
In most games, the following keybindings are used:
  • A: Used for jumping.
  • B: Used for shooting.
  • Start: Starts the game or pauses it when running.
  • Select: Selects the next option in the menu.
Extra Features keybindings (Not in the original NES)
ActionKey
Save emulator stateN
Load emulator stateM
Emulator state is saved in a .rustynes_sav file.
.rustynes_sav file can be loaded by passing the path to the file as an argument to the emulator.
./rusty_nes_cli <path_to_save_file>
Building and Usage
The RustyNES_core library crate has zero dependencies, but RustyNES_cli uses SDL2 for rendering and input handling. Ensure that SDL2 is installed on your system for building RustyNES_cli.
Building for Linux
  1. Build the project in release mode:
    cargo build --release
    The rusty_nes_cli executable will be in the target/release directory.
  2. Run the executable with the path to the ROM file as an argument:
    ./rusty_nes_cli <path_to_rom_file>
  3. To load a save file (.rustynes_sav), pass the path to the save file as an argument:
    ./rusty_nes_cli <path_to_save_file>
Cross-compiling to Windows
  1. Add the Rust target for Windows:
    rustup target add x86_64-pc-windows-gnu
  2. Install mingw-w64:
    sudo apt install mingw-w64
  3. Build the project for Windows:
    cargo build --release --target=x86_64-pc-windows-gnu
    The rusty_nes_cli.exe executable will be in the target/x86_64-pc-windows-gnu/release directory, and the SDL2.dll file will be in the project root directory.
    For running the emulator on Windows, ensure the SDL2.dll file is in the same directory as the executable.
  4. Run the executable with the path to the ROM file as an argument:
    rusty_nes_cli.exe <path_to_rom_file>
  5. To load a save file (.rustynes_sav), pass the path to the save file as an argument:
    ./rusty_nes_cli <path_to_save_file>
Building for Web
  1. Install wasm-pack:
    cargo install wasm-pack
  2. In the RustyNES_web_ui directory, run:
    npm install
npm run dev
    This command will build the RustyNES_wasm library and output the WebAssembly file and JavaScript bindings to the RustyNES_web_ui/public/pkg directory.
Mappers Implemented
  • Mapper 0 (NROM)
  • Mapper 2 (UNROM)
  • Mapper 4 (MMC3)
Resources
Documentation
Videos
Code
About
RustyNES is a cross-platform NES emulator written entirely from scratch in Rust, with no external libraries. Play classics like Super Mario Bros and Contra on Linux, Windows, or in your browser via WebAssembly.
vedant416.github.io/RustyNES/
Topics
65026502-assembly6502-emulationemulatornesnes-emulatornintendo-nesrusttypescriptwasmwebassembly
Resources
Readme
Activity
Stars
3 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Universal Dark Mode - works on any site\n(function() {\n var enabled = true;\n \n function applyDarkMode() {\n if (!enabled) return;\n \n // Create style element if it doesn't exist\n var style = document.getElementById('universal-dark-mode-style');\n if (!style) {\n style = document.createElement('style');\n style.id = 'universal-dark-mode-style';\n document.head.appendChild(style);\n }\n \n // Dark mode CSS - inverts colors but preserves images/video\n style.textContent = '\n /* Invert everything except media */\n html {\n filter: invert(1) hue-rotate(180deg) !important;\n background: #1a1a2e !important;\n }\n \n /* Restore images, videos, iframes, canvas */\n img, video, iframe, canvas, svg, picture, [style*=\"background-image\"] {\n filter: invert(1) hue-rotate(180deg) !important;\n }\n \n /* Preserve specific elements that should not be inverted */\n .no-dark-mode, .no-dark-mode *,\n [data-theme=\"light\"], [data-theme=\"light\"],\n .ace_editor, .ace_editor *,\n .CodeMirror, .CodeMirror *,\n .monaco-editor, .monaco-editor *,\n .markdown-body pre, .markdown-body pre *,\n .highlight, .highlight *,\n pre code, pre code * {\n filter: none !important;\n }\n \n /* Fix common UI elements */\n .modal, .popup, .dropdown-menu, .tooltip, .popover {\n filter: invert(1) hue-rotate(180deg) !important;\n background: #2d2d44 !important;\n border-color: #444 !important;\n }\n \n /* Scrollbars */\n ::-webkit-scrollbar { background: #1a1a2e !important; }\n ::-webkit-scrollbar-thumb { background: #444 !important; }\n ::-webkit-scrollbar-thumb:hover { background: #555 !important; }\n \n /* Selection */\n ::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }\n ::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }\n ';\n }\n \n function removeDarkMode() {\n var style = document.getElementById('universal-dark-mode-style');\n if (style) style.remove();\n }\n \n // Toggle with Alt+Shift+D\n document.addEventListener('keydown', function(e) {\n if (e.altKey && e.shiftKey && e.key === 'D') {\n e.preventDefault();\n enabled = !enabled;\n if (enabled) {\n applyDarkMode();\n console.log('[Universal Dark Mode] Enabled');\n } else {\n removeDarkMode();\n console.log('[Universal Dark Mode] Disabled');\n }\n }\n });\n \n // Apply on load\n applyDarkMode();\n \n // Re-apply on dynamic content\n var observer = new MutationObserver(function(mutations) {\n if (enabled && !document.getElementById('universal-dark-mode-style')) {\n applyDarkMode();\n }\n });\n observer.observe(document.head, { childList: true });\n \n console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');\n})();", "Universal Dark Mode");
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();

Skip to content
BranchesTags
Repository files navigation
RustyNES
RustyNES is a Nintendo Entertainment System (NES) emulator written in Rust.
Written from scratch in Rustwithout using any external libraries.
Cross-platform and can run on Linux, Windows, and in a web browser (using WebAssembly).
Runs using very low cpu and memory resources at stable 60fps.
Supports all 5 channels of NES audio.
Supports save state and load state, so that we can resume the game from where we left.
Can run classic NES games like Super Mario Bros, Super Mario Bros 2, Super Mario Bros 3, Contra and many more.
Try on your local machine by downloading the executable from the releases
Try online in your browser: RustyNES
(Under development).
Screenshots
Super Mario Bros
Project Statistics
LanguageFilesLinesCodeCommentsBlanks
Rust3644033505329569
TypeScript24363512560
CSS13512891151
HTML1149137012
Total4053394282365692
Generated using the tokei
CLI tool.
Command used to generate the statistics:
tokei -C -t=Rust,TYPESCRIPT,HTML,CSS -s=lines
Project Structure
  • RustyNES_core: This is the heart of the emulator, containing the core emulation logic.
  • RustyNES_cli: This is a command-line interface that uses RustyNES_core and SDL2 for rendering output, outputting audio, and handling input.
  • RustyNES_wasm: This crate compiles RustyNES_core to WebAssembly which is used by the RustyNES_web_ui.
  • RustyNES_web_ui: This is a web interface that uses RustyNES_wasm to run the emulator in a web browser.
Keyboard controls
NES Controller keybindings
Emulator ButtonKeyboard Key
UpW
LeftA
DownS
RightD
AL
BK
StartEnter
SelectRight Shift
In most games, the following keybindings are used:
  • A: Used for jumping.
  • B: Used for shooting.
  • Start: Starts the game or pauses it when running.
  • Select: Selects the next option in the menu.
Extra Features keybindings (Not in the original NES)
ActionKey
Save emulator stateN
Load emulator stateM
Emulator state is saved in a .rustynes_sav file.
.rustynes_sav file can be loaded by passing the path to the file as an argument to the emulator.
./rusty_nes_cli <path_to_save_file>
Building and Usage
The RustyNES_core library crate has zero dependencies, but RustyNES_cli uses SDL2 for rendering and input handling. Ensure that SDL2 is installed on your system for building RustyNES_cli.
Building for Linux
  1. Build the project in release mode:
    cargo build --release
    The rusty_nes_cli executable will be in the target/release directory.
  2. Run the executable with the path to the ROM file as an argument:
    ./rusty_nes_cli <path_to_rom_file>
  3. To load a save file (.rustynes_sav), pass the path to the save file as an argument:
    ./rusty_nes_cli <path_to_save_file>
Cross-compiling to Windows
  1. Add the Rust target for Windows:
    rustup target add x86_64-pc-windows-gnu
  2. Install mingw-w64:
    sudo apt install mingw-w64
  3. Build the project for Windows:
    cargo build --release --target=x86_64-pc-windows-gnu
    The rusty_nes_cli.exe executable will be in the target/x86_64-pc-windows-gnu/release directory, and the SDL2.dll file will be in the project root directory.
    For running the emulator on Windows, ensure the SDL2.dll file is in the same directory as the executable.
  4. Run the executable with the path to the ROM file as an argument:
    rusty_nes_cli.exe <path_to_rom_file>
  5. To load a save file (.rustynes_sav), pass the path to the save file as an argument:
    ./rusty_nes_cli <path_to_save_file>
Building for Web
  1. Install wasm-pack:
    cargo install wasm-pack
  2. In the RustyNES_web_ui directory, run:
    npm install
npm run dev
    This command will build the RustyNES_wasm library and output the WebAssembly file and JavaScript bindings to the RustyNES_web_ui/public/pkg directory.
Mappers Implemented
  • Mapper 0 (NROM)
  • Mapper 2 (UNROM)
  • Mapper 4 (MMC3)
Resources
Documentation
Videos
Code
About
RustyNES is a cross-platform NES emulator written entirely from scratch in Rust, with no external libraries. Play classics like Super Mario Bros and Contra on Linux, Windows, or in your browser via WebAssembly.
vedant416.github.io/RustyNES/
Topics
65026502-assembly6502-emulationemulatornesnes-emulatornintendo-nesrusttypescriptwasmwebassembly
Resources
Readme
Activity
Stars
3 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Used by
Contributors
Languages