CF

NES Programming with 6502 Assembly

27h 55m 3s
English
Paid
Updated September 2026

NES Programming with 6502 Assembly is a 144-lesson 27 hours 55 minutes self-paced course by Gustavo Pezzi. Building games for the original NES means working directly with the 6502 processor and the console's own hardware quirks.

Course facts

Lessons
144
Duration
27 hours 55 minutes
Level
All levels
Language
English
Updated
2026-09-11
Instructor
Gustavo Pezzi
Price
Premium

Building games for the original NES means working directly with the 6502 processor and the console's own hardware quirks. This course walks through that process from the ground up, ending with a working game you built yourself.

How the course progresses

  • Start with 6502 processor basics, writing small samples to see how memory and data actually behave
  • Move into how the NES handles graphics, sound, and controller input
  • Test short programs on an emulator, adding one new idea per lesson

Your final project

Each lesson's pieces come together into a complete NES game, built with real hardware constraints, working sprites, and functioning game logic, rather than a simplified simulation.

Who teaches NES Programming with 6502 Assembly? Gustavo Pezzi

Gustavo Pezzi thumbnail

Gustavo Pezzi is a UK-based computer-science lecturer (Pikuma) and one of the most distinctive teachers working at the intersection of low-level programming and game development. His material is unusual in the modern course market for how deep it goes into the foundations: assembly, computer architecture, classical raycasting / rasterisation algorithms, and the math underneath modern graphics.

His CourseFlix listing reflects that range: courses on 3D Computer Graphics Programming, Raycasting Engine Programming, 2D Game Physics Programming, NES Programming with 6502 Assembly, PS1 Programming with MIPS Assembly & C, Atari 2600 Programming, Compilers, Interpreters and Formal Languages, plus C++ engine programming and Lua scripting. Material is paid and aimed at developers who want to understand systems from the ground up rather than ship CRUD apps.

What lessons are included in NES Programming with 6502 Assembly?

This is a demo lesson (10:00 remaining)

You can watch up to 10 minutes for free. Subscribe to unlock all 144 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing
0:00
/
#1: Motivations & Learning Outcomes
All Course Lessons (144)
#Lesson TitleDurationAccess
1
Motivations & Learning Outcomes Demo
09:42
2
How to Take this Course
02:59
3
Placing the NES in History
09:55
4
NES Hardware (Console)
27:03
5
Opening the NES Cabinet
03:50
6
NES Hardware (Cartridge)
09:40
7
Binary Numbers
19:22
8
Hexadecimal Numbers
12:45
9
6502 CPU Pinout
13:25
10
6502 CPU Registers
10:10
11
6502 CPU Status Flags
23:26
12
The Assembler Flow
12:06
13
Popular 6502 Instructions
17:54
14
CA65 Assembler
02:47
15
Installing CA65 on macOS
01:52
16
Installing CA65 on Linux
01:57
17
Installing CA65 on Windows
09:08
18
iNES Header
16:40
19
Our First Assembly Code
14:42
20
Assembler & Linker
06:01
21
FCEUX Emulator
07:51
22
Our First Assembly Bug
07:50
23
Addressing Modes
06:45
24
6502 Warmup Exercises
08:22
25
6502 Warmup Exercises (Solution)
15:23
26
Makefiles
03:25
27
CPU Memory Map
12:36
28
Clearing RAM Addresses
12:27
29
NES Graphics & the PPU
17:09
30
Picture Frame & VBlank
09:39
31
PPU Memory Map
20:28
32
Background Color
07:51
33
NES Initialization Code
17:30
34
Include Files
06:40
35
Resetting PPU Address Latch
02:32
36
Sending Multiple Bytes to the PPU
11:49
37
Unnamed Labels & Subroutines
06:47
38
Editing CHR Tiles
12:20
39
Loading Nametable Tiles
12:58
40
Nametable Attributes
09:13
41
Loading Attribute Bytes
10:45
42
Creating Dynamic Macros
08:27
43
Declaring Variables
07:18
44
Measuring Game Seconds
04:05
45
Pointers
08:49
46
Loading a Full Nametable
14:23
47
Full Nametable Code
07:35
48
Exercise: Displaying Text
05:04
49
Displaying Text
08:12
50
Other Tile Editor Apps
05:35
51
NES Sprites
15:20
52
Hello Mario
11:20
53
OAM Decay
02:14
54
Hiding Sprites Off-Screen
05:04
55
Sprite Flickering
03:25
56
Include Nametable Files
02:25
57
Exercise: Hello Goomba
01:22
58
Hello Goomba
04:02
59
Bitwise Instructions
11:07
60
Controller Architecture
13:48
61
Controller Input Routine
10:36
62
Implementing Controller Input
04:43
63
Checking Button Presses
13:57
64
Moving Sprites with Button Presses
03:57
65
Button Constants
05:54
66
Integer & Fractional Position
25:24
67
Velocity & Acceleration
17:09
68
Signed Velocity
06:56
69
Intercalating Animation Frames
11:11
70
Multiple of Powers of Two
02:27
71
Mirroring & Scrolling
13:29
72
Horizontal Background Scrolling
16:36
73
Swapping Nametables
14:40
74
Bitshifting Operations
11:50
75
Load Background Dynamically
05:11
76
A Method for Dynamic Scrolling
23:07
77
Starting the AtlГўntico Code
16:13
78
Drawing Column of Tiles Off-Screen
21:58
79
Loading Initial Nametable Tiles
11:37
80
Loading Attributes Off-Screen
26:46
81
Scroll Split Screen
07:14
82
Sprite-0 Hit Implementation
11:56
83
Separating Game Logic & NMI
12:15
84
Running Game Logic Once Per Frame
07:14
85
Saving Registers in the Stack
03:30
86
Counting Game Loop Passes
04:47
87
Macro to Push & Pull Registers
02:31
88
A Discussion on Buffering
08:22
89
Array of Actors
13:34
90
Adding & Removing Actors
09:15
91
A Routine to Add Actors
17:54
92
Coding the Routine to Add Actors
13:23
93
Template to Loop Actors Array
06:29
94
Rendering Actors
33:36
95
Updating Actor Position
12:28
96
Limiting One Missile Per Button Press
06:18
97
Deleting Actors
16:52
98
Relative vs. Absolute Jumps
05:26
99
Spawning Submarines
15:45
100
Spawning Airplanes
06:07
101
Random Numbers using LFSR
24:34
102
8-Bit LFSR Example
09:21
103
Random Airplane Position
12:54
104
Adjusting Airplane Position
05:09
105
Sprite Collision Check
18:22
106
Missile-Airplane Collision
24:44
107
Check Point Inside Bounding Box
13:26
108
BCD Representation
17:48
109
Routine to Increment Score
10:29
110
Buffering Background Tiles
29:49
111
Increment Score on Airplane Hit
02:34
112
Background Collision Check
10:44
113
CHR Bank Switching
21:38
114
Game States
06:10
115
Title Screen State
10:13
116
Title Screen Nametable
18:21
117
Title Screen Menu Items
10:18
118
Drawing Menu Item Arrow
07:23
119
Exercise: Menu Item Palette Selection
03:58
120
Menu Item Palette Selection
05:15
121
RLE Compression
10:13
122
A Python Script to Encode RLE
14:56
123
A Routine to Decode RLE Data
10:06
124
Title Screen RLE Decoding
07:07
125
APU
14:32
126
Introduction to FamiStudio
39:48
127
Square Channel Ports
19:57
128
Triangle, Noise, and DMC Ports
13:13
129
Musical Notes & Period
17:21
130
Using a Sound Engine
16:03
131
FamiStudio Sound Engine
18:27
132
Some Notes on Chords & Voicing
03:50
133
Playing FamiStudio Music Code
14:07
134
Playing Missile Sound Effect
04:55
135
Playing Explosion Sound Effect
07:02
136
Fixing Button Press/Release Bug
06:53
137
Fixing VRAM Buffering Address
03:48
138
Clipping Tiles Left & Right
21:10
139
Calculating Tile Screen (-1,0,+1)
29:32
140
Removing Actors Off Screen
11:54
141
Fixing Explosion SFX Bug
06:42
142
Developing NES Games with C
04:53
143
C NESLib Examples
32:03
144
Conclusion & Next Steps
19:25
Unlock unlimited learning

Get instant access to all 143 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription

Books

Read Book NES Programming with 6502 Assembly

#TitleTypeOpen
16502 Warmup Exercises PDF
26502 Warmup Exercises (Solution) PDF

What courses are similar to NES Programming with 6502 Assembly?

More courses by Gustavo Pezzi

Frequently asked questions

What are the prerequisites for enrolling in this course?
This course assumes no prior knowledge of assembly language, but a basic understanding of programming concepts is helpful. Familiarity with binary and hexadecimal numbers will also be beneficial, as these topics are covered in the early lessons to help understand the 6502 processor's operation.
What is the final project for this course?
The final project involves creating a working NES game. This project incorporates real hardware rules, simple sprites, and clear game logic. It serves as a culmination of the skills learned throughout the course, including graphics manipulation, sound integration, and input handling.
Who would benefit most from this course?
This course is ideal for individuals interested in retro game development and those looking to deepen their understanding of low-level programming with 6502 Assembly. It suits hobbyists and programmers who wish to explore the historical aspects of gaming consoles and learn how hardware constraints influence software design.
How does the scope of this course compare to other programming courses?
Unlike many programming courses that focus on high-level languages, this course dives into low-level programming with 6502 Assembly. It provides a unique perspective by detailing how the NES console's hardware directly affects coding decisions, offering insight into the constraints and challenges of early game development.
What specific tools will I learn to use in this course?
You will learn to use the CA65 assembler for writing 6502 Assembly code and the FCEUX emulator for testing your programs. These tools are essential for developing NES games, and the course includes detailed instructions for installing CA65 on macOS, Linux, and Windows.
Are there any topics not covered in this course?
The course does not cover advanced game development techniques or optimization strategies for modern platforms. It focuses exclusively on the NES hardware and the 6502 Assembly language, providing foundational skills to build a simple NES game.
How much time should I expect to dedicate to this course?
The course consists of 144 lessons, each designed to build progressively on the previous one. While the exact time commitment may vary, students should be prepared to spend significant time writing and testing code, especially when working on the final project to develop a complete NES game.