I tried emulator development

I have some FOMO whenever I see something about programming that’s not web programming.
For some reason, I feel the need to study it because ~~I don’t touch grass~~ I like to believe it’s a way to evolve my skills.

There are some great courses out there, like nand2tetris. It’s really good but I’m too lazy to commit to a full course just to play around. So I did the most recommended thing on the r/EmuDev subreddit: build a CHIP-8 emulator, following Tobias V. Langhoff’s guide.

He doesn’t give away implementation code, but he has great tips and simplifies the specification a lot.

Emulating the Components

CHIP-8 has the following components:

Memory: 4 KB of RAM
Display: 64×32 pixels (or 128×64 for SUPER-CHIP), monochrome (black/white)
Program Counter (PC): Points to the current instruction in memory
Index Register (I): A single 16-bit register used to point to memory locations
Stack: Used for subroutine calls (16-level deep)
Delay Timer: 8-bit timer, decremented 60 times per second
Sound Timer: Same as delay timer, but beeps while non-zero
Registers: 16 general-purpose 8-bit registers (V0–VF)

This sounds hard at first, but don’t overthink it.
In practice, it’s just a bunch of variables and arrays, like this:

1
private byte[] display = new byte[64 * 32];
2
private int PC;
3
private int I;
4
private int[] stack = new int[16];
5
private byte[] memory = new byte[4096];
6
private int[] V = new int[16];
7
private int delayTimer;
8
private int soundTimer;

Memory Layout

When the emulator starts, memory is divided into sections (with specific address ranges):

1
+---------------------------+ 0xFFF  (4095)
2
| Display memory (optional) |
3
+---------------------------+ 0xF00
4
| Stack / scratch area      |
5
+---------------------------+ 0xEA0
6
| Program data / code       | <-- where ROMs are loaded
7
| ...                       |
8
+---------------------------+ 0x200
9
| Fontset (sprites 0–F)     |
10
+---------------------------+ 0x050
11
| Reserved (interpreter)    |
12
+---------------------------+ 0x000

These memory addresses (like 0x200 for program data) can be emulated easily in our memory array.
Each index stores one byte.

We then load an array of bytes (the ROM) and store it starting at address 0x200:

1
public void loadGame() throws IOException {
2
    byte[] program = Files.readAllBytes(Paths.get("roms/9-pong.ch8"));
3
    arraycopy(program, 0, memory, 0x200, program.length);
4
}

That’s it! our ROM is now sitting right where CHIP-8 expects it to be.

CPU Cycle and Reading Instructions (the Assembly-Like Stuff)

The CHIP-8 CPU follows the fetch–decode–execute flow. In Computer Architecture classes, we learn that CPUs run in cycles.
We need to emulate this here and guess what? It’s simple.

1
final int CLOCK_HZ = 700; // ~700 cycles per second
2
final long NS_PER_CYCLE = 1_000_000_000L / CLOCK_HZ;
3

4
long lastCycle = System.nanoTime();
5

6
while (true) {
7
    long now = System.nanoTime();
8
    if (now - lastCycle >= NS_PER_CYCLE) {
9
        fetchOpCode();
10
        decodeAndExecute();
11
        lastCycle += NS_PER_CYCLE;
12
    }
13

14
    Thread.sleep(1); // prevent 100% CPU usage
15
}

For the fetch step, we need to read the memory location where the Program Counter is pointing.

1
private void fetchOpCode() {
2
    int pc = programCounter.getCurrent();
3
    opcode = ((memory[pc] & 0xFF) << 8) | (memory[pc + 1] & 0xFF);
4
    programCounter.next();
5
}

And for the decodeAndExecute step, it’s just a bunch of bit masking and one gigantic switch statement.

Look at this beautifully ugly switch statement

1
private void decodeAndExecute() {
2
    int X = (opcode & 0x0F00) >> 8;
3
    int Y = (opcode & 0x00F0) >> 4;
4
    int N = opcode & 0x000F;
5
    int NN = opcode & 0x00FF;
6
    int NNN = opcode & 0x0FFF;
7

8
    switch (opcode & 0xF000) {
9
        case 0x0000:
10
            switch (N) {
11
                case 0x0: // 0x00E0: clear screen
12
                    display.clearScreen();
13
                    break;
14
                case 0xE: // 0x00EE: return from subroutine
15
                    programCounter.jump(stack[--sp]);
16
                    break;
17
            }
18
            break;
19
        case 0x1000: // 1NNN: jump
20
            programCounter.jump(NNN);
21
            break;
22
        case 0x2000: // 2NNN: call subroutine
23
            stack[sp++] = programCounter.getCurrent();
24
            programCounter.jump(NNN);
25
            break;
26
        case 0x3000: // 3XNN: skip if VX == NN
27
            if (V[X] == NN) programCounter.next();
28
            break;
29
        case 0x4000: // 4XNN: skip if VX != NN
30
            if (V[X] != NN) programCounter.next();
31
            break;
32
        case 0x5000: // 5XY0: skip if VX == VY
33
            if (V[X] == V[Y]) programCounter.next();
34
            break;
35
        case 0x9000: // 9XY0: skip if VX != VY
36
            if (V[X] != V[Y]) programCounter.next();
37
            break;
38
        case 0x6000: // 6XNN: set
39
            V[X] = NN & 0xFF;
40
            break;
41
        case 0x7000: // 7XNN: add
42
            V[X] = (V[X] + NN) & 0xFF;
43
            break;
44

45
        // ...and yes, there’s more.
46
    }
47
}

Our goal is simply to implement each instruction according to the specification. Yeah, it’s tedious.

Final thoughts

Developing emulators requires way too much work.
You really have to care about what you’re emulating, that’s the only thing that’ll keep you going.

I don’t plan to do this again, unless I retire and decide I want to suffer.