NES Controller

In the previous blog post, we explored the world of reversing Nintendo ROMs and the tools needed for the process. Today, we’ll dive deeper into NES architecture disassembly and learn how to read and understand classic game code.


Reading NES disassembly is a crucial skill when reverse engineering classic games. In this blog post, we’ll learn the basics of the NES architecture and its assembly language, as well as how to read disassembled code.

NES Architecture Overview

The NES (Nintendo Entertainment System) is an 8-bit game console that uses a 6502 processor. It has a 16-bit address space, allowing it to access up to 64KB of memory. The memory is divided into several sections, including:

  • 2KB of internal RAM (0x0000-0x07FF)
  • 8KB of Video RAM (VRAM) (0x2000-0x3FFF)
  • 32KB of ROM (0x8000-0xFFFF)

In addition to the CPU, the NES also has a specialized graphics processing unit (GPU) called the Picture Processing Unit (PPU).

6502 Assembly Language

The 6502 processor uses its own assembly language, which consists of a set of mnemonics that represent machine code instructions. These mnemonics are human-readable representations of the operations the processor can perform. Here are a few examples:

  • LDA (Load Accumulator): Loads a value into the accumulator (A) register.
  • STA (Store Accumulator): Stores the value in the accumulator (A) register to a memory address.
  • JMP (Jump): Sets the program counter (PC) to a specified address, effectively jumping to that location in the code.

Reading NES Disassembly

To read NES disassembly, you’ll need to familiarize yourself with the 6502 assembly language and understand how the processor interacts with memory. Here’s an example of a simple disassembled NES code:

LDA #$01    ; Load the value 0x01 into the accumulator (A) register
STA $0200   ; Store the value in the accumulator (A) register to memory address 0x0200
JMP $8000   ; Jump to memory address 0x8000

In this example, we load the value 0x01 into the accumulator, store it in memory address 0x0200, and then jump to memory address 0x8000.

When analyzing disassembled code, it’s essential to understand the purpose of each instruction and how it interacts with the overall program. Keep in mind that game code can be complex, and you may need to spend time researching and experimenting to fully grasp its functionality.

Tips for Analyzing Disassembly

Here are a few tips to help you analyze NES disassembly:

  1. Take Notes: As you work through the disassembled code, take detailed notes on each instruction and its purpose. This will help you build a mental map of the game’s logic.
  2. Follow the Flow: Pay attention to control flow instructions, such as JMP, JSR (Jump to Subroutine), and branch instructions. These will help you understand the structure of the code and how it’s organized.
  3. Look for Patterns: Many games follow similar coding patterns, such as using loops for animation or updating the game state. Identifying these patterns can help you understand the underlying logic and make it easier to identify specific functions or routines within the code.
  4. Experiment: Don’t be afraid to modify the disassembled code and observe the effects on the game. This hands-on approach can provide valuable insights and help you learn more about the game’s inner workings.


Reading NES architecture disassembly is a fascinating and essential skill for anyone interested in reverse engineering classic Nintendo games. By understanding the NES architecture, familiarizing yourself with the 6502 assembly language, and following the tips outlined in this post, you’ll be well-equipped to explore the secrets hidden within your favorite games. As you delve deeper into this world, you’ll gain a greater appreciation for the ingenuity and creativity that went into creating these timeless classics.

Happy hacking!