Skip to content
💾 A minimal 64 bits kernel (Operating System that cannot "operate" a lot of things). // Work In Progress
C Assembly Makefile Other
Branch: master
Clone or download
Latest commit 049cb2e Dec 25, 2019
Type Name Latest commit message Commit time
Failed to load latest commit information.
.circleci Update ci check Jan 6, 2020
docs Update docs Dec 22, 2019
grub PoC to execute a binary stored in the init ram disk Jan 6, 2020
initrd PoC to execute a binary stored in the init ram disk Jan 6, 2020
libs Update liballoc lib Dec 15, 2019
src some more fixes Jan 6, 2020
test Add tests for strcat() Jan 6, 2020
userland/init Move init to userland directory (#23) Dec 23, 2019
.astylerc (astyle) indent switch/case Dec 10, 2019
.gdbinit Add default gdb config Dec 16, 2019
.gitignore Refactor initrd Jan 6, 2020
Dockerfile Update Makefile(s) (#15) Dec 17, 2019
Doxyfile Rebuild doxygen docs Dec 11, 2019 Create May 22, 2017
Makefile Add tests and fix a bunch of things Jan 6, 2020
linker.ld Fix linker Dec 10, 2019



willOS is a minimal 64 bits kernel (not really an Operating System because it cannot do a lot of things currently). Some screencasts are available in this Twitter thread.

Setting up a development environment

The following dependencies are required to build this project:

  • gcc (build-essential)
  • nasm
  • ld
  • grub-mkrescue (part of grub2-common)
  • xorriso
  • (optional) qemu

This project targets x86_64 architectures, so you likely need a cross-compilation toolchain.

Docker (recommended way)

Use Docker with the provided Dockerfile:

$ docker build -t willos/toolchain .
$ docker run --rm -v $(pwd):/app willos/toolchain make


Install Homebrew, then run the following commands:

$ brew install nasm
$ brew install xorriso
$ brew install qemu

You need to tap hawkw/x86_64-pc-elf to install the cross-compilation toolchain:

$ brew tap hawkw/x86_64-pc-elf
$ brew install x86_64-pc-elf-gcc

You need to tap hawkw/grub to install the GRUB utility:

$ brew tap hawkw/grub
$ brew install grub --with-x86_64-pc-elf --HEAD

Hat tip to Eliza Weisman for the taps!


See the circle-ci config.

Building willOS

To compile the kernel (ELF 64-bit), run:

$ make kernel

To build the ISO (this is the default target), run:

$ make iso

To compile the OS in DEBUG mode, build the ISO, and start qemu with the OS loaded, run:

$ make debug

Note: in DEBUG mode, logging uses the serial port COM1 to write various debugging information. qemu is configured to write the output of this serial port to /tmp/serial.log.

To compile the OS in normal mode, build the ISO, and start qemu with the OS loaded, run:

$ make run

Early boot sequence

  1. The BIOS loads the bootloader (GRUB) from the ISO
  2. The bootloader reads the kernel executable and finds the multiboot header
  3. The bootloader copies the .boot and .text sections to memory (to addresses 0x100000 and 0x100020)
  4. The bootloader jumps to the entry point (at 0x100020)
  5. Various checks are performed to make sure we can continue the boot process
  6. Page table and paging are configured and enabled
  7. Load a 64-bit Global Descriptor Table
  8. Reload all the data segment registers
  9. Call the C kmain() function


willOS is released under the MIT License. See the bundled LICENSE file for details. In addition, some parts of this project have their own licenses attached (either in the source files or in a LICENSE file next to them).

You can’t perform that action at this time.