Welcome to your first lesson. We're embarking on the exciting project of building a CHIP-8 emulator from the ground up using vanilla JavaScript. This course is designed to start with the fundamental theory of the CHIP-8 architecture before diving into implementation, which aligns perfectly with your preference for a "fundamentals-first" approach.
In this first module, we will explore the complete blueprint of the CHIP-8 system. Today's lesson focuses on the most foundational component of any computer system: its memory. You will learn about the CHIP-8's memory size, how it's organized into distinct regions, and the specific purpose of each region. Given your background in computer architecture and experience with low-level systems, the concept of a structured memory map will be a familiar starting point.
The CHIP-8 Virtual Machine
Before we look at the memory, let's briefly define what we're building. CHIP-8 is not a physical microprocessor but an interpreted programming language, or a virtual machine (VM), first developed in the mid-1970s. Its simplicity made it a popular target for creating games on early microcomputers. For us, its simplicity makes it the perfect subject for learning the core principles of emulation.
To build an emulator, we first need to model the components of this virtual machine in software. These components include memory, registers, a stack, and timers, all of which we will cover in this module. Let's begin with memory.
The CHIP-8 Memory Map
The CHIP-8 virtual machine has a total of 4 kilobytes (4096 bytes) of random-access memory (RAM). This memory is byte-addressable, with addresses ranging from 0x000 to 0xFFF in hexadecimal (0 to 4095 in decimal).
Unlike a modern computer where the operating system dynamically manages memory, the CHIP-8 has a fixed memory map. Specific address ranges are reserved for specific functions. This is a common design in older, simpler computer systems and many embedded devices you may have encountered.
Take a look at the following diagram which illustrates the overall memory layout.
As you can see, the memory is primarily split into two main sections. Let's examine each one.
1. Interpreter Area: 0x000 to 0x1FF
The first 512 bytes of memory, from address 0x000 to 0x1FF, were historically reserved for the CHIP-8 interpreter itself on the original hardware. This area would contain the code that fetches, decodes, and executes CHIP-8 instructions—much like the BIOS or firmware on a physical machine.
Creating a Chip8 interpreter/emulator in C++14
To reinforce this key point, watch this brief segment from the video "Creating a Chip8 interpreter/emulator in C++14" by Bisqwit.
The presenter clearly states the size and purpose of this reserved area right at the beginning of the hardware description.
In a modern emulator, our JavaScript program is the interpreter, so we don't need to load one into the emulated memory. However, we still respect this convention. This reserved area is not left entirely empty; it serves a critical purpose: storing the built-in font set. CHIP-8 includes sprite data for rendering hexadecimal digits 0 through F, and by convention, these are loaded into this lower memory region. We will explore the font set in detail in a future lesson.
2. Program and Data Space: 0x200 to 0xFFF
The remaining memory, from address 0x200 (512 in decimal) up to 0xFFF, is where the CHIP-8 program, or ROM, is loaded. Consequently, the Program Counter (PC), a special register that points to the next instruction to be executed, is initialized to 0x200.
When you load a game file (a ROM), its contents are copied byte-for-byte into memory starting at this address. The space between the end of the loaded program and the end of memory (0xFFF) is then available for the program to use as general-purpose data storage.
The video "Learn Emulation with CHIP-8!" by hexdump provides a practical perspective on this process.
Watch the section from where to load the program, which explicitly confirms that ROMs are loaded into memory starting at address 0x200.
To solidify your understanding of these memory regions, the following reading provides a concise summary.
Building a CHIP-8 Emulator [C++] - Austin Morlan
This article by Austin Morlan provides a clear, well-structured description of the CHIP-8's core components. We will focus on the memory section.
Please read the section titled 4K Bytes of Memory. Pay close attention to the three-part breakdown of the address space and the specific roles and address ranges assigned to each part.
The article you just read mentions a slight variation in where the font set is stored (0x050-0x0A0) compared to other sources. This highlights that while the general layout is standard, minor implementation details can differ between emulators. For our project, we'll stick to loading the fonts at the very beginning of memory for simplicity, which is also a common convention.
Conclusion
In this lesson, we have established the foundational memory architecture of the CHIP-8 system. This is the canvas upon which our entire emulation will be built.
Here are the key takeaways:
- Total Memory: CHIP-8 has 4096 bytes (4KB) of RAM, addressed from
0x000to0xFFF. - Interpreter Area: The first 512 bytes (
0x000to0x1FF) are reserved. In modern emulators, this space is primarily used to store the built-in font set. - Program Space: Programs (ROMs) are loaded into memory starting at address
0x200. Execution begins from this address. The remaining memory is used for the program's data.
Now that we understand the layout of the main memory, our next lesson will move inside the "CPU" to explore its internal workspace: the registers. We will learn about the general-purpose data registers, the special-purpose index register, and the program counter that drives the flow of execution.