Emulating CHIP8 As Fast As Possible

Goal #1: Fetch → Decode → Execute

With that in mind, I set out with the goal of developing a CHIP8 emulator with the caveat of ensuring I apply the basic CPU cycle principle to my implementation (fetch → decode → execute). This isn’t really atypical, but is notable for CHIP8 due to the fact that it isn’t a “real” ISA—there aren’t any CHIP8 CPUs, historically. It was created as a platform intended to be emulated. Thus, some implementations are looser than the typical fetch, decode, and execute cycle. Therefore, I felt it was relevant to set as a goal.

This ended up looking like the code block below. The function returns as parameters was for fun, really not necessary. Realistically, the instructions can be placed on the global “bus” (the global instruction variable) and all functions can have 0 parameters and void returns.

uint16_t fetch() { /* ... */ }

uint16_t decode(uint16_t instr) { /* ... */ }

void execute(uint8_t instr_t) { /* ... */ }

int main(int argc, char** argv) {
	while (PC != exit) {
		execute(decode(fetch()));
		// ...
	}
}

Goal #2: Specification Only

A secondary goal was that I didn’t want to use anything but the CPU specification to implement the main emulator logic. I wanted to attempt the implementation with as little support as possible, to up the challenge a bit.

Goal #3: I Miss C

Lastly, I hadn’t used C or C++ in more than a year due to my full-time job being a primarily web-development role, so this was an opportunity for me to get back up to speed on my C knowledge. Before I started this project, I redid one of my projects from college: a CLI tokenizer. I can’t overstate how nice of a project this is to spin up on a language quickly. It’s not so involved that it would take you a week or more, but it is just involved enough that you will be dealing with a lot of quirks for any given language.

Specification Sheet

First, there is the holy grail of CHIP8 implementation resources, Cogwod’s technical specification. This is pretty much the community go-to base resource for implementing a CHIP8 emulator. If you want the greatest challenge and/or you already have a background in CPU architecture, I’d recommend trying to implement only using that document.

High Level Guide

Next, there is the oft recommended guide from Tobias V. Langhoff’s. This guide does a great job of breaking down the concepts into more digestible bites while not totally spoiling the implementation for you. I’d recommend trying to implement with Cogwods and this guide if you have little to no background knowledge on CPUs and/or you would like a moderate challenge.

Thorough Code Breakdown

Lastly, there is a full, thorough implementation guide from Austin Morlan. Do note that this guide is using C++, not C strictly. However, most concepts carry over. If you want to go through the motions of putting together an emulator before trying something else, or if you get stuck while implementing, this guide has thorough explanations for each piece of the specification.

Loading the ROM

This was the first piece of the emulator I decided to implement. I grabbed the first file from Timendus’ CHIP8 Test Suite and saved it to my repository as a baseline for checking the implementation as I go. Unfortunately, pretty much every test requires the graphics portion of the project to be completed in order to view the test results. However, while the drawing functionality wasn’t ready yet, I used VS Code’s built-in debugger to watch each register as instructions executed.

Any external I/O was placed in a peripherals.c file, including the “ROM drive”.

Memory

The memory for a CHIP8 emulator is pretty much as simple as it gets in the world of emulators—a fixed-length array of size 4096 bytes. In my case, this was allocated at runtime with the following instruction:

uint8_t mem[4096];

Simple enough, right? Besides that, I also initialized our “register file”, or the set of registers native to the CHIP8 platform (‘V’ is used thanks to CHIP8 convention):

uint8_t V[16];

It’s not necessary to go through how I initialized each and every variable, but other “memory” related variables included the stack pointer and the stack, the program counter, delay and sound timers, the memory register, the screen buffer (more on this later), and the keyboard buffer. I also opted to emulate the “bus” with an instr_bus global variable.

The CPU

This is the “meat” of the emulator. This piece is what the specification from Cogwod I linked above defines. It’s also more or less the least interesting, thanks to the fact that the implementation is relatively standard. The only moderately distinct implementation feature I adopted was completely bit-wise operations.

I chose to subtract from the delay and sound timers in the “decode” phase of the cycle. Technically, with my current implementation, the delay timer wouldn’t work all that great thanks to the fact that I chose to speed up the base clock of the CPU to make keyboard entry and graphical output more functional/fluid. This is something I’ll likely fix in the future. I will possibly include this as a fix before I expand the CHIP8 code I have now into a web assembly project/tool.

The only other interesting feature of the CPU implementation is for the 0xD, or draw, instruction. That piece I will cover in the next section on graphics.

The Graphics

The only part of the graphical implementation that is directly related to the CHIP8 specification is the instruction used to draw to the video buffer. Everything else graphics related is drawing the video buffer with SDL2.

uint8_t screen[8][32];

switch(instr_t) {
	// ...
	
	case 0xD:
	/* drw / draw sprite from I at (Vx, Vy)*/
	V[0xF] = 0;
	for(int i = 0; i < (instr_bus&0x000F); i++) {
		int index_x, index_y, offset;
		
		index_x = V[x]>>3; // which byte to access
		index_y = (V[y] + i) % 32; // height of byte
		offset = 8-(V[x]%8); // offset of wrapped byte
		
		// collision detection:
		if((screen[index_x][index_y] & (mem[I+i]>>(V[x]%8))) ||
		   (screen[(index_x+1)%8][index_y] & (mem[I+i]<<offset))) {
			V[0xF] = 1;
		}
		
		// write to buffer
		screen[index_x][index_y] ^= (mem[I+i]>>(V[x]%8));
		screen[(index_x+1)%8][index_y] ^= (mem[I+i]<<offset);
	}
	break;
	
	// ...
}

void draw_screen(uint8_t screen[8][32], SDL_Renderer* renderer) {
  SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
  SDL_RenderClear(renderer);
  SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);

  for (int i = 0; i < 32; i++) {
    for (int j = 0; j < 8; j++) {
      for (int k = 0; k < 8; k++) {
        if (screen[j][i] & (0b10000000 >> k)) {
          SDL_Rect rect;
          rect.x = ((j * 8) + k) * SCALE;
          rect.y = i * SCALE;
          rect.w = SCALE;
          rect.h = SCALE;
          SDL_RenderFillRect(renderer, &rect);
          // O avg = 32 * 64, no larger than any other implementation.
        }
      }
    }
  }
  SDL_RenderPresent(renderer);
}

The Sound

I more or less stopped development on the project at this point. I wanted to implement sound, but it was an effort that was far from the initial point of this project (to develop my first emulator). However, I still gave it a shot and got something, but its mostly just static noise. Funny enough, this is thanks to the fact that I am taking a modern sound system (SDL2) and attempting to make it fit this use case (monotone beeps) which seems harder than if I just wanted to play some audio from a file (like most modern use-cases in games and such).

Here’s the code I could make out, based on a kind soul on Stack Overflow:

const int AMPLITUDE = 28000;
const int SAMPLE_RATE = 44100;

void audio_callback(void* user_data, Uint8* raw_buffer, int bytes) {
  Sint16* buffer = (Sint16*)raw_buffer;
  int length = bytes / 2;  // 2 bytes per sample for AUDIO_S16SYS
  int* sample_nr = (int*)user_data;

  for (int i = 0; i < length; i++) {
    double time = (double)sample_nr[i] / (double)SAMPLE_RATE;
    buffer[i] = (Sint16)(AMPLITUDE * sin(2.0f * 3.1415f * 441.0f *
                                         time));  // render 441 HZ sine wave
  }
}

void play_beep() {
  int sample_nr = 0;
  SDL_AudioSpec want;
  want.freq = SAMPLE_RATE;
  want.format = AUDIO_S16SYS;
  want.channels = 1;
  want.samples = 512;
  want.callback =
      audio_callback;
  want.userdata =
      &sample_nr;
  SDL_AudioSpec have;
  if (SDL_OpenAudio(&want, &have) != 0)
    SDL_LogError(SDL_LOG_CATEGORY_AUDIO, "Failed to open audio: %s",
                 SDL_GetError());
  if (want.format != have.format)
    SDL_LogError(SDL_LOG_CATEGORY_AUDIO, "Failed to get the desired AudioSpec");

  SDL_PauseAudio(0);  // start playing sound
}

void stop_beep() { SDL_PauseAudio(1); }

As I mentioned previously, this implementation basically isn’t working. I’m sure I’ve managed to mix some part of this up, since I couldn’t find great docs on it. If you have some suggestions on how to fix this code up, please do let me know in the comments!

Timendus Test Suite

Special thanks to Timendus for their test suite. It’s a great resource for more CHIP8 tests than you would ever need. After running the main few to confirm full functionality (keypad, opcodes, and flags tests), I downloaded a few games to test.

Compatibility (and Demo)

Compatibility is a little hit or miss, unfortunately. This may be thanks to the variety of CHIP8 extensions out there and some improper labeling. Regardless, for most games that I tested, they worked as expected.

Thanks for sticking around and reading through this! Hopefully this was helpful, insightful or really anything of value to you. Feel free to leave a comment down below if you have a question or suggestion!

Before you go, below is a video of a Breakout remake for CHIP8 I used to test (choppy video is only due to the GIF format, the actual render is a little better). Sorry in advance for accidentally leaving my cursor on the screen: