Tilck: An Educational Linux-Compatible Monolithic Kernel for Low-Latency Systems

What Tilck Is and Who It Is For

Tilck is an educational monolithic kernel designed to be Linux-compatible at the binary level. The README describes it as a playground for kernel development that retains the ability to compare how the same usermode binaries run on the Linux kernel. This binary compatibility is what distinguishes Tilck from most educational kernels, which require custom-written applications.

Because Tilck implements enough Linux syscalls to run programs built with a standard gcc-musl toolchain, it can run the BusyBox suite directly without porting it. The README notes that building programs for Tilck requires only a gcc-musl toolchain from bootlin.com. The kernel currently targets the i686 and RISCV64 architectures.

The primary audience is engineers and students who want to learn kernel internals by reading and modifying a small, well-structured kernel, or who are researching deterministic, low-latency kernel designs for future embedded use.

Binary Linux Compatibility and the Verification Advantage

The core design choice in Tilck is binary-level Linux compatibility. The README explains the consequence: if a program works correctly on Linux, it must work the same way on Tilck (minus unimplemented features). This makes Linux the ground truth for correctness. When a syscall behaves differently on Tilck than it does on Linux, that difference is a bug.

The README describes this as a rare feature in the realm of educational kernels. Most educational kernels ship with custom applications because they implement a non-Linux ABI. Tilck avoids the substantial porting effort that this requires. The trade-off is that Tilck's design is shaped partly by the Linux syscall interface rather than being a free-form experiment.

Tilck implements approximately 100 Linux syscalls. It is a preemptable monolithic NIX kernel, and the README notes that almost everything architecture-specific is isolated, meaning most kernel code compiles for any architecture and can run as part of unit tests without target hardware.

Building Tilck from Source

Tilck uses CMake as its build system, with a wrapper Makefile for convenience. The Makefile in the repository root is described as a commodity fake Makefile that allows building from the project root rather than entering the build/ directory first.

The Makefile itself documents the prerequisite: before building, the toolchain must be prepared:

./scripts/build_toolchain

After the toolchain is ready, generate the CMake build files:

./scripts/cmake_run

Then build with:

make

The Makefile provides additional targets: make gtests runs the test suite, make config or make menuconfig launches the configuration tool, and make rem (short for rebuild_img) removes the FAT partition and disk image and rebuilds them. CI is run against i386, riscv64, and x86_64 build configurations on Debian, Fedora, and Arch Linux toolchains, based on the workflow table at the top of the README.

What Tilck Deliberately Does Not Include

The README includes a "What Tilck is NOT" section that is unusually direct. Tilck is not an attempt to rewrite or replace Linux. It is not suitable for a desktop operating system: the README states that no X server works on Tilck and that working in that direction is completely outside the project's goals. It does not target multi-user servers.

At the syscall level, Tilck does not yet implement networking or persistent storage. These are documented as future plans rather than current features. The planned networking support is described as potentially limited to UDP plus IP at the start, and storage support may cover fat32 and ext2 filesystems.

The README is explicit that Linux is not complex because of poor implementation: "Linux is great given the problem it solves." Tilck offers fewer features in exchange for simpler code, smaller binary size, deterministic behavior, ultra low-latency, easier development and testing, and extra robustness. The comparison is framed as different goals rather than competition.

Tilck vs FreeRTOS, Zephyr, and Embedded Linux

The README's future plans section positions Tilck in the gap between Embedded Linux and real-time operating systems like FreeRTOS or Zephyr. FreeRTOS is a widely used RTOS for microcontrollers with a cooperative or preemptive scheduler, designed for very constrained hardware (kilobytes of RAM). Zephyr is a more feature-complete RTOS with a broader architecture portfolio, also designed for microcontrollers and small embedded processors.

Tilck occupies different territory: it is a monolithic kernel with Linux-compatible syscalls that can run existing Linux programs, but it is designed for ultra low-latency and deterministic behavior rather than for the feature breadth of Embedded Linux. Embedded Linux (running the full Linux kernel on small hardware) requires more memory and offers less timing determinism than a purpose-built RTOS.

The README notes that Tilck already boots and runs on QEMU with just 3 MB of RAM. An ARM port is planned for future work, and the README mentions Raspberry Pi 3 or 4 as a milestone target for networking and storage support once the ARM64 port is completed.

Testing Infrastructure, License, and Maintenance

The README describes the test infrastructure as ambitiously trying to be almost enterprise-level. CI runs against i386, riscv64, and x86_64 with toolchains from Debian, Fedora, and Arch Linux. The repository includes a tests/ directory and the Makefile exposes a gtests target. The kernel has a debug panel documented in the README.

The repository structure shows docs/ for documentation, kernel/ for kernel source, modules/ for loadable modules, scripts/ for build tooling, tests/ for the test suite, and userapps/ for userspace applications. A CLAUDE.md file is present in the root, which is used by AI development tools.

Tilck is licensed under BSD-2-Clause, a permissive license with no copyleft requirements. The last push to the repository was on 2026-09-19. The repository has no GitHub releases; the master branch is the working state. The NOTICE file in the repository root lists third-party attributions.

Editorial conclusion

Tilck is the right project for engineers who want to study kernel development with real Linux programs as a correctness baseline, or who are exploring low-latency and deterministic kernel design for embedded targets. Students and researchers who want to understand monolithic kernel internals will find that binary Linux compatibility makes it easier to verify that individual syscall implementations are correct. Those who need a production kernel, networking, storage, or desktop support should use Linux, as Tilck explicitly excludes those goals. Before building Tilck, run ./scripts/build_toolchain to prepare the required gcc-musl toolchain, then ./scripts/cmake_run to generate the build files.

Frequently asked questions

Official sources

1. Issues
2. License: BSD-2-Clause
3. README
4. vvaltchev/tilck on GitHub