IPADS OS Course Lab: building a real microkernel from the first instruction

The premise is that an operating system is something you build

The repository is the course content of the IPADS laboratory at Shanghai Jiao Tong University, and the argument it opens with is that an operating system is not just a course you have to memorise but a system you can build by hand. The stated aim is to understand a computer system from the perspective of an operating system developer, from the ground up. The README is explicit that it does not want to treat the operating system as a black box to be recited, but to put the reader in the developer's seat. The path starts from the first instruction executed after the machine powers on and works upward, so that a real microkernel is brought to life step by step: how it takes over the hardware, how it manages memory, how it lets programs run concurrently on multiple cores, and how isolated processes cooperate. Each step raises the questions a developer actually faces, which abstraction this layer offers upward, and which mechanisms of the layer below it depends on.

Four principles, and the debugging habit behind them

The README sets out four commitments. Starting from the mechanism rather than the definition, asking not only what something is but how it is implemented, with the answers in the source of a real kernel. Working bottom-up, from bits and bytes, instructions and processors, up to the kernel and the applications above it, so that each layer rests on the one below. Debugging like a developer, with QEMU, GDB and objdump as everyday tools and reading source described as a basic skill. And running on real hardware, targeting AArch64 so the code can be emulated in QEMU or run on a Raspberry Pi development board. The debugging principle is the one that distinguishes the course from a lecture series, since the README asks you to read source, set breakpoints and look at registers, and the supporting resources include a toolchain tutorial covering tmux, GDB, objdump, make and QEMU, plus a source code analysis section that walks through the key parts of ChCore section by section.

ICS is the foundation, the OS labs are the point

The README describes one path and two courses. Computer System Basics, or ICS, is the foundation, modelled on CS:APP, and it works out how a program actually runs on a machine, how data is represented, how instructions execute, how memory is allocated and how machines communicate, with the README noting that the same systems perspective is then applied to modern workloads such as large model inference and AI agents. The operating systems course is the main act. Built on the lab's own ChCore microkernel, which the README links to a USENIX ATC paper, you fill in the parts of an operating system that boots on AArch64, manages memory, schedules threads, provides inter-process communication and supplies a file system. The README makes a concrete claim about the payoff: after finishing, you can run a Pokemon game on a Raspberry Pi with your own ChCore kernel, call DeepSeek, and run a small model such as Qwen-1.5B locally.

What the repository actually contains

Four directories carry the content, and each is a different kind of content. ICS-PPT holds the course slides for the foundation course, written as lectures in Python so that one source can be rendered as web slides, as PowerPoint and as LaTeX textbook chapters, which is an unusual and useful arrangement for anyone who wants the same course in two formats. ICS-Labs holds the experiments for the foundation course, the ones that lay the groundwork for the operating systems work. OS-Labs holds the operating systems experiments built on ChCore, and it also contains the Pages directory with the source of the online lab manual. OS-PPT holds the operating systems course slides as PDF. Alongside these are the online manual itself, which covers environment setup, experiment instructions and discussion questions, the source code analysis pages, the toolchain tutorial, and a course text titled Principles and Implementation of Operating Systems, by Chen Haibo and Xia Yubin among others, published by the Machinery Industry Press.

Running a lab: three make targets and a Raspberry Pi under QEMU

The quick start is a clone and three make targets.

git clone https://github.com/SJTU-IPADS/OS-Course-Lab.git
cd OS-Course-Lab/OS-Labs/Lab1

The three make targets are, in order, build to compile the kernel, qemu to run it on a Raspberry Pi emulated under QEMU, and grade to score locally. The OS labs depend on Docker, and the README recommends opening the OS-Labs directory in VS Code and entering the dev container, which gives a complete preinstalled toolchain. There is a Windows caveat, since those users must enable developer mode and clone with the core.symlinks option set, and the manual has a page on platform-specific notes for getting the experiments started. The requirements the README lists are AArch64, a Raspberry Pi 3 or later, QEMU, the C language, and Docker, and the badges reflect the same list.

Three licences, and the one to read carefully

The licensing is the detail to notice in a repository full of content adapted from elsewhere. The code is under the Mulan Permissive Software License, version 2. The ICS experiments contain a lab framework derived from CS:APP whose copyright belongs to R. Bryant and D. O'Hallaron and is used with the permission of Professor David O'Hallaron, while the parts IPADS modified are under Mulan PSL v2. The operating systems experiment documentation is under the Creative Commons Attribution-NonCommercial-ShareAlike 4.0 licence, which is the term that matters most if you plan to use the lab content in a commercial course or a paid training product, since non-commercial use is a condition rather than a preference. The repository is not archived, the last push was on 2026-10-20, and the tags show v25.03.1 from February 2025 and v24.09.1 from October 2024, so the versioning follows the academic year.

Editorial conclusion

The IPADS OS Course Lab fits a student who wants to understand an operating system by constructing one, and who is prepared to read real kernel source, set breakpoints and read disassembly. It does not fit a learner who wants a survey of operating system concepts, since the labs assume you will debug at the register level. Verify first that you can run QEMU or have AArch64 hardware available, work through the ICS labs before the OS ones because the README is explicit that ICS is the foundation, and read the licensing note before you reuse the lab content, since the code, the CS:APP derived framework and the documentation are under three different terms.

Frequently asked questions

Official sources

1. Issues
2. Project website
3. README
4. Releases
5. SJTU-IPADS/OS-Course-Lab on GitHub