
Build a 64-bit riscv operating system from scratch, from bootloader to kernel, through process management, system calls, and a working user shell, with step-by-step guidance.
Describe how an OS connects users and applications to hardware, manages resources like CPU and memory, and provides interfaces through shells, cues, or APIs while contrasting monotasking and multitasking.
Explore the kernel as the heart of the operating system, managing CPU, memory, and devices, and compare monolithic, microkernel, modular, and exokernel designs; NoFix adopts a microkernel.
Discover what RISC-V is: an open-source instruction set architecture designed to be simple and extensible, with user, supervisor, and machine modes and 32 general-purpose registers, used in research and education.
Learn to debug the Novix kernel with GDB and QEMU in debug mode, set breakpoints on boot and kernel main, and inspect registers and memory using os-debug.sh and os-gdb.sh.
Master bare metal programming by writing software that runs directly on hardware with no operating system, implementing memory management, input and output, and your own printf and malloc.
Learn OpenSPI, the open source supervisor binary interface for RISC-V that enables kernel to request machine mode services via SPI calls like PutC, GetC, and timer.
Explore memory management in Novix on RISC-V, including RAM versus ROM, clearing the BSS, setting up the kernel stack, sizing RAM, and implementing a simple heap with malloc and free.
Explore paging in the RISC-V Novix kernel with 4 kilobyte pages and 3-level page tables. See how virtual addresses map to physical memory via identity mapping and debug outputs.
Explore how no fixed file system in RISC-V leads to using a tar-based initrun filesystem, embedded in the kernel, parsed to load idle.elf at boot.
Add date and time support by combining build-time timestamps with runtime ticks and a timezone offset to enable file system timestamps, event locking, and task synchronization.
Build Your Own 64-Bit RISC-V Operating System From Scratch — Step by Step.
Ever wondered what happens when a computer starts up,
how an operating system is born from a single line of code?
In this hands-on course, you’ll build your own 64-bit RISC-V operating system completely from scratch.
No magic. Just you, your compiler, and the Novix microkernel — growing line by line.
What You’ll Learn :
You’ll start from a clean Linux virtual machine and set up a modern RISC-V development environment using Clang/LLVM, QEMU, and VS Code.
Then, step by step, you’ll design and implement every layer of a real operating system ,
from bare-metal boot code to a fully working shell.
This course is designed to make low-level programming approachable. You will learn the boot process, linker scripts, and how to write kernel code in C and assembly. Along the way, we will implement UART communication, interrupts, and essential drivers. By following along, you will gain both the theory and the practical experience needed to truly understand how an operating system works under the hood.
No prior OS or hardware experience is required. With only basic C knowledge, you can follow step by step and end up with a working RISC-V 64-bit operating system of your own.
By the end of Part 1, you will have built:
A 64-bit RISC-V microkernel that boots and runs on QEMU
UART communication for console input/output
A working scheduler and process management system
Core system calls like fork(), exec(), wait(), and exit()
Memory management and a custom heap allocator
A functioning userland shell that runs commands such as ls, ps, mem, date, and echo
A complete argument-passing system between kernel and user space
Debugging and memory tracking tools to detect and clean up leaks
The skills and confidence to explore advanced OS concepts
Advanced Logging System
What Makes This Course Unique :
Unlike theoretical OS courses, this one is 100% hands-on.
You won’t just read about concepts — you’ll build them yourself.
Every module starts with clear explanations, then moves into real C and assembly code,
fully explained and tested live. Each function is described in detail.
We designed Novix OS to be minimal yet powerful — a platform for true understanding.
By the time you reach the final chapter, you’ll not only have a working shell, but you’ll understand why it works.
Looking Ahead :
This course is just the beginning.
In Part 2, we’ll extend Novix OS with real servers — a file server, network stack, and windowing system, plus advanced IPC and scheduling.
Your journey from kernel to complete operating environment starts here.
(c) NovixManiac — The Art of Operating Systems Development
“We don’t just teach operating systems.
We teach how to think like one.”