Working with the instructor’s dotfiles on the server is great and all, but there’s a few things you can do loccally that you can’t do on the school server:

  1. Use QEMU’s X environment to test VGA. If you’re like me, and want to get color working in JOS, you want to use QEMU’s X display. But to my knowlege, there is no easy way to do that from the server.
  2. Work offline. What if you don’t have internet available? You won’t have a way to connect to the shcool server, and therefore work on the lab.
  3. Work with no latency. In my experience, the school server is fairly laggy and inconvenient to use. It’s much nicer to develop locally, where your keys don’t take a noticeable amount of time to appear on the screen.
  4. Use your own editor. vim is nice, and it’s my editor of choice, but some others prefer VScode, Atom, and the like.

Getting Started

By default, most distributions of gcc do not provide the i386 architecture. We need i386 since that’s the archtecture of our virtual target CPU. The JOS makefile looks for a compiler that does support the architecture - but usually doesn’t find it. So, we need a version of that compiler that does. Before we get started, make sure you need to do this. If make inside the JOS directory works out of the box, you don’t!

Let’s first make a directory where we will put all the programs that will be needed to compile for i386.

mkdir ~/.i386-toolchain

Additionally, let’s make a directory where we can download and extract various tarballs, if only for a while. I usually consider my “downloads” folder a workspace where that can be done.

cd ~/Downloads

Let’s start by downloading and building GNU binutils, followed by gcc.

Building binutils

Let’s download binutils v2.32 (latest at the time of writing):

curl -O
tar -xzf binutils-2.32.tar.gz
cd binutils-2.32

Now, we will run the configure script to generate a working Makefile. We can’t just run configure with no parameters - we need to specify a custom install location (our i386-toolchain folder), and the target architecture that we want to build for (i386, of course). It’s easiest to keep these in variables:

export TARGET=i386-elf
export PREFIX=~/.i386-toolchain

We’re ready to run the configure script:

./configure --prefix=$PREFIX --target=$TARGET --disable-nls --enable=languages=c

This generates a Makefile, which we will promptly use:

make -j8 && make install

This should install binutils to the toolchain directory.

Building gcc

The latest version of gcc at the time of writing is v8.3.0. Let’s similarly download and untar this:

curl -O
tar -xzf gcc-8.3.0.tar.gz
cd gcc-8.3.0

I’ve run into issues compiling gcc without using a separate build directory, so I recommend you do that:

mkdir build && cd build

We will now run a similar configure script, with one addition: we specify the languages we want to use.

../configure --prefix=$PREFIX --target=$TARGET --disable-nls --enable-languages=c

Ah, but we don’t want to just run make - we just want the compiler and the standard library (libgcc, which gcc tries to link to JOS and everything else). Thus, our make command is as follows:

make all-gcc all-target-libgcc -j8
make install-gcc install-target-libgcc

Finally, we can move into our local copy of JOS. I assume you have it cloned - I’m sure you don’t need my help to do that. There’s a configuration setting that we have to set to make sure the Makefile uses the correct compiler. This is inside conf/


If you run make inside of the JOS directory, the kernel should compile!


A lot of the dotfiles the professor provides are very nice. The one I find most useful is the .gdbinit file and the dashboard it comes with. Fortunately, even without having access to the script Dr. Jang provides in the server’s network filesystem, we can set up most of his dotfiles. It’s easy enough - they’re hosted on his GitHub! For simplicity, let’s clone these files in the same location as the canonical script does:

git clone ~/.cs444

Personally, I only use the gdbinit script. If you don’t have an existing one, we can link it in:

cd ~
ln -sf ~/.cs444/gdbinit .gdbinit

That should do it!


With this, we’ve set up a compiler for i386 and pulled some dotfiles recommended by the professor. I hope this makes for easier development - with whatever tools you prefer, locally!