Build a Chip-8 Emulator in JavaScript that runs on a browser

Course Curriculum

Chapter 1: Understanding what is Chip-8

Lecture 1: Understand what Chip-8 is and the challenges we will face

Chapter 2: Starting our journey creating our Chip-8 microprocessor

Lecture 1: Creating our Chip-8 virtual microprocessor

Chapter 3: Creating our Chip-8 Display

Lecture 1: Creating our Display

Chapter 4: Creating the support code (Webpack) and servers (Live Server)

Lecture 1: Setting up Webpack so we can use modern JavScript on the Browser

Lecture 2: Creating a webserver to serve our Chip-8 emulator

Chapter 5: Connecting the Display to the HTML and Scaling up the resolution

Lecture 1: Connecting the display to the HTML

Lecture 2: Creating a multiplier to make our Display larger

Lecture 3: Creating our screen and our screen buffer

Lecture 4: Drawing our Frame Buffer on the screen

Chapter 6: Creating our Chip-8 Memory

Lecture 1: Creating our memory

Chapter 7: Creating our Chip-8 Registers

Lecture 1: Creating the Registers

Lecture 2: Adding and removing values from Stack using Push and Pop

Lecture 3: Checking for Stack Overflow and Stack Underflow errors

Chapter 8: Creating our Chip-8 Keyboard

Lecture 1: Creating our Chip-8 Keyboard

Lecture 2: Mapping the Keyboard

Lecture 3: Using the mapping in our Virtual Keyboard

Lecture 4: Creating all the keyboard functions

Lecture 5: Detecting and storing key presses

Chapter 9: Create our Chip-8 charset sprites from 0-F and loading into memory

Lecture 1: Creating the Chip-8 charset

Lecture 2: Loading character set to Chip-8 memory

Chapter 10: Drawing sprites in the display

Lecture 1: Drawing a character on the display

Lecture 2: Understanding the Pixel Position and writing on the screen

Chapter 11: Implement our Chip-8 Delay Timer

Lecture 1: Implement the Delay Timer for Chip-8

Chapter 12: Implement our Chip-8 Sound Timer

Lecture 1: Creating our Chip-8 Sound Card

Lecture 2: Fixing our Sound Card and making it beep

Lecture 3: Implement the sound on the main loop

Chapter 13: Understanding Binary Files

Lecture 1: Running our Binary code manually

Chapter 14: Creating a Dissembler for Chip-8

Lecture 1: Creating our Disassembler and our first Chip-8 Instruction CLR

Chapter 15: Creating our Chip-8 Instruction Set file

Lecture 1: Creating a new simple Chip-8 instruction RET

Lecture 2: Implement Chip-8 Jump (JP) and creating arguments

Lecture 3: Returning the argument nnn from Jump (JP)

Lecture 4: Implementing the Chip-8 Call instruction

Lecture 5: Adding the Skip VX NN on the instruction set and shifting bits

Lecture 6: Refactoring our code to make easier to understand and continue

Lecture 7: Adding another Chip-8 instruction Skip next instruction – SNE VX KK

Lecture 8: Adding Chip-8 instruction LD VX KK

Lecture 9: Adding Chip-8 Instruction Add VX KK

Lecture 10: Adding Chip-8 Instruction Set VX VY

Lecture 11: Adding the Chip-8 instructions OR, AND, XOR, ADD, SUB, SHR, SUBN, SHL

Lecture 12: Testing the Chip-8 instructions OR, AND, XOR, ADD, SUB, SHR, SUBN, SHL

Lecture 13: Adding the Chip-8 instructions SNE, SET JUMP and Random

Lecture 14: Adding the Chip-8 instructions Draw DRW and introducing the nibble

Lecture 15: Adding the Chip-8 instructions Skip if key pressed (SKP)

Lecture 16: Adding the Chip-8 instructions Set Delay Timer, Set Sound Timer, and more

Lecture 17: Testing the Chip-8 instructions Set Delay Timer, Set Sound Timer and more

Chapter 16: Loading the Chip-8 ROM into the Chip-8 Memory

Lecture 1: 046 – Loading our first ROM into Chip-8 memory

Chapter 17: Understanding opCode. How Chip8 stores the data Big Endian vs Little Endian

Lecture 1: Understand the opcode structure

Lecture 2: Getting the Opcode from the Chip-8 Memory

Chapter 18: Disassembling the opCodes and sending to Chip-8 for execution

Lecture 1: Disassembling our opcode to get the Chip-8 Instruction

Chapter 19: Implementing all 35 Chip-8 Instructions

Lecture 1: Implementing Chip-8 instruction CLS

Lecture 2: Implementing Chip-8 instruction RET

Lecture 3: Implementing Chip-8 instruction Jump to Address

Lecture 4: Implementing Chip-8 instruction Call to Address (CALL)

Lecture 5: Implementing Chip-8 instruction Skip if equals (SE VX KK)

Lecture 6: Implementing Chip-8 instruction Skip if different (SNE VX KK)

Lecture 7: Implementing Chip-8 instruction Skip if registers are equal (SE VX VY)

Lecture 8: Implementing Chip-8 instruction Set registers (LD VX NN)

Lecture 9: Implementing Chip-8 instruction Add (ADD VX KK)

Lecture 10: Implementing Chip-8 instruction Load registers (LD VX VY)

Lecture 11: Implementing Chip-8 instruction OR (OR VX VY)

Lecture 12: Implementing Chip-8 instruction AND (AND VX VY)

Lecture 13: Implementing Chip-8 instruction Exclusive OR XOR (XOR VX VY)

Lecture 14: Implementing Chip-8 ADD with Carry (ADD VX VY with C)

Lecture 15: Implementing Chip-8 SUB with not Borrow (SUB VX VY)

Lecture 16: Implementing Chip-8 Shift bits to Right (SHR VX)

Lecture 17: Implementing Chip-8 SUBN with not Borrow (SUBN VX VY)

Lecture 18: Implementing Chip-8 Shift bits to Left (SHL VX)

Lecture 19: Implementing Chip-8 Skip (SNE VX VY)

Lecture 20: Implementing Chip-8 Load I (LD NNN)

Lecture 21: Implementing Chip-8 Jump (JP V0 NNN)

Lecture 22: Implementing Chip-8 Ramdon (RND VX NN)

Lecture 23: Implementing Chip-8 Drawing (DRW VX VY nibble)

Lecture 24: Debugging our display problem

Lecture 25: 74 Wrapping around the display Horizontal and Vertical (just like Pac-Man)

Lecture 26: Creating and testing a collision on the Display

Lecture 27: Implementing Chip-8 Skip is Key Pressed (SKP VX)

Lecture 28: Implementing Chip-8 Skip is Key is not Pressed (SKNP VX)

Lecture 29: Implementing Chip-8 Set from Delay Timer (LD VX DT)

Lecture 30: Implementing Chip-8 Wait for a Key(LD VX DT0)

Lecture 31: Implementing Chip-8 Wait for a Key(LD VX K)

Lecture 32: Implementing Chip-8 Set Delay Timer(LD DT VX)