Open-source project
vvaltchev/tilck avatar
vvaltchev/tilck

tilck: a Linux-compatible kernel with no releases and no toolchain job for x86_64

A Tiny Linux-Compatible Kernel

3,139 stars139 forksCBSD-2-Clause

At a glance

What is it?
tilck is an educational monolithic kernel that is Linux-compatible at binary level, runs BusyBox instead of shipping its own applications, and boots on 3 MB of RAM. The status table gives x86_64 a test job but no toolchain job, and the repository publishes no releases at all.
Who is it for?
tilck fits someone who wants to read a kernel, run the same userspace binary against two kernels and compare the results, which is what the binary level compatibility buys. It does not fit anyone looking for a system to deploy.
Can I use it commercially?
Yes. BSD-2-Clause is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository received new commits within the last day.
What is it written in?
Mainly C, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • vvaltchev/tilck3,139 ★ · +7
Star history
Repository2026-09-242026-11-15
vvaltchev/tilck3.1k3.1k

7 Stars in the last 52 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

x86_64 gets a test job and no toolchain job

The status table at the top of the file has three columns, i386, RISCV64 and x86_64, with x86_64 marked as a build target. The Tests row has a link in all three columns. The three toolchain rows do not. Debian, Fedora and Arch Linux each carry links for i386 and RISCV64, and each one records N/A against x86_64. So the matrix covers three distributions across two architectures, six combinations in total, and x86_64 participates only in the test run. That is the shape of the supported set in one glance: RISCV64 and i386 are exercised against three toolchains, x86_64 is compiled and tested, and nothing checks whether it builds from any of them. A separate CircleCI directory sits at the repository root alongside the GitHub workflow files these badges point at, so more than one pipeline arrangement is present.

There are no releases, so the kernel is built from source

The repository has no GitHub releases. Not an old set, not a pre-release, none. Combined with the last push on 2026-09-19 and an unarchived repository, the practical consequence is that there is no artifact to fetch and no version to pin, and every user compiles it. The root Makefile makes that arrangement explicit in its own opening comment, where it describes itself as a fake Makefile whose only purpose is to let people build from the project root instead of entering the build directory first. Almost every target in it forwards to make in that subdirectory. The one that does not is the toolchain prerequisite, which does not build anything and instead stops with a message telling you to build the toolchain by running a script first.

The toolchain generation is parsed out of a text file and a miss stops the parse

The build reads one value out of a configuration file and treats it as a hard requirement, like this:

make
TC_NAME := $(shell sed -n 's/^TOOLCHAIN_DIR_NAME=//p' other/toolchain_conf)
ifeq ($(TC_NAME),)
$(error TOOLCHAIN_DIR_NAME missing from other/toolchain_conf)
endif

Two things are worth noticing. The extraction happens while the Makefile is being parsed, so a missing value is an error before any target runs rather than a failure partway through a build. And the comment above it calls that file the single source of truth for which toolchain generation to look for, naming four consumers: the bash bootstrap, a Ruby package manager, CMake and this Makefile. So a generation bump moves four install paths at once, which is why the value is parsed rather than typed in five places. The rest of the file is thinner than that. Only three of its targets are declared phony, while two others share an identical recipe and a further two share a third, and the image artifact plus a fat partition directory are named directly in the delete step.

userapps/ and sysroot/ sit next to a claim that no applications are needed

One of the stated advantages of the design is that the kernel has no need for its own set of custom written applications, unlike most educational kernels, and that it simply runs mainstream Linux programs such as the BusyBox suite. Building a program for it needs only a gcc-musl toolchain, and compatibility is at the binary level. Now read the tree. There is a `userapps/` directory and there is a `sysroot/` directory, both at the repository root. Whatever the current contents are, the directories exist, so the absence of a custom application set is a claim about practice rather than about layout. It is a smaller discrepancy than it looks, since a sysroot holding musl targets is what makes third-party binaries buildable at all, but the README wording claims more than the tree shows.

Networking and storage are written down as plans with details undefined

The forward-looking sections are unusually tentative, and the wording is worth preserving rather than smoothing over. Adding basic networking and storage is called part of the plans, with details explicitly not defined yet. Networking might be limited to UDP over IP at the beginning, on a limited set of network cards. Storage will not cover every kind of block device, and a few filesystems, maybe just fat32 and ext2, will be implemented in the kernel, with FUSE considered. The sentence carrying that list is also missing a verb, which tells you how lightly the section was edited. The named hardware milestone is networking plus storage for a specific system on a chip such as a Raspberry Pi 3 or 4, and the file is explicit that this could happen only after a port to ARM64. That port has not happened; RISCV64 and i686 are what run.

Three megabytes of RAM and about a hundred syscalls

Two numbers are given concretely, and they are the ones worth carrying away. The kernel can boot and run on a QEMU machine with just 3 MB of memory today, and it implements about a hundred Linux syscalls as a preemptable monolithic NIX kernel. The architecture story supports both: the kernel is not x86-centric even though that was its first target, almost everything architecture-specific is isolated, and consequently most of the kernel code can be compiled for any architecture and run as part of the unit tests. Against those, the comparison with Linux lists six things offered in exchange for fewer features, among them smaller binary size, extremely deterministic behaviour and ultra low-latency. Five of the six are unmeasured. The one measurable claim is the memory figure, and the test infrastructure is described as trying to be almost enterprise-level.

Desktop use is ruled out in one sentence and a discussion link

The file has a section headed by asking what the kernel is not, and the second item is blunt: it is not suitable for a desktop operating system. The stated reason has two parts. No X server works on Tilck, and the extra features that would be needed are considerable, but the direction itself is described as completely outside the project's goals, with a link to a discussion numbered 81. The first item in that same section is the other thing it is not, namely an attempt to rewrite or replace Linux. What it claims instead is partial compatibility, adopted so existing programs and toolchains can be used, and the file turns that into a correctness argument: a program that works correctly on Linux must work the same way on Tilck, minus unimplemented features. It also flags that result as a starting point rather than a destination.

A NOTICE file, a Neovim config and a second CI layout at the root

The root holds twenty-nine entries and several of them have no obvious connection to a kernel. A `.nvim.lua` sits beside a `.vscode/` directory, so two editor setups are configured in the repository. A `.devcontainer/` directory and a `.dockerignore` describe a container workflow, and `CLAUDE.md` sits next to `CMakeLists.txt` and the Makefile. There is both a `LICENSE` and a `NOTICE`, while the licence recorded for the repository is BSD-2-Clause, a two-clause form that does not call for a NOTICE file, so the two do not obviously belong together. The rest of the layout maps onto the build: a `boot/` directory matching the project's own bootloader, then `common/`, `config/`, `include/`, `kernel/`, `modules/`, `other/`, `scripts/`, `sysroot/`, `tests/`, `tools/`, `userapps/` and `docs/`.

Editorial conclusion

tilck fits someone who wants to read a kernel, run the same userspace binary against two kernels and compare the results, which is what the binary level compatibility buys. It does not fit anyone looking for a system to deploy. Verify four things first. Confirm you can build from source, because there are no releases to download and the root Makefile exists mainly to forward into a build directory. Decide which architecture you are on, because x86_64 carries a test job while the toolchain matrix covers only i386 and RISCV64. Treat the networking and storage sections as intent rather than inventory, since both are written as plans with details explicitly undefined. And read the stated scope limits before assuming a gap is a bug, since the project rules out desktop use and plans ARM only as a future port.

Frequently asked questions

What is vvaltchev/tilck?

An educational monolithic kernel designed to be Linux-compatible at binary level, running on i686 and RISCV64. It implements about a hundred Linux syscalls, is preemptable, and is not x86-centric, with architecture-specific code isolated so that most of the kernel can be compiled for any architecture and run as part of the unit tests.

Which programs run on vvaltchev/tilck?

Mainstream Linux programs such as the BusyBox suite, rather than a set of custom-written applications as most educational kernels ship. Building a program for it requires only a gcc-musl toolchain from bootlin.com, and compatibility is at the binary level, so the same userspace binaries can be run against Linux and against tilck for comparison.

Does vvaltchev/tilck have any releases?

No. The repository has no GitHub releases, so there is nothing to download and no version to pin, and the kernel is built from source. It is not archived and was last pushed on 2026-09-19.

Does vvaltchev/tilck support ARM or Raspberry Pi?

Not yet. RISCV64 and i686 run today, and a port to the ARM family is named as a future step, with the Raspberry Pi 3 or 4 milestone described as possible only after an ARM64 port happens. The kernel might also be adapted to run on MMU-less CPUs, since low memory use is central to its design.

Can vvaltchev/tilck run a desktop?

No, and the project says so directly. It states that no X server works on Tilck, that the extra features required would be considerable, and that working in that direction is completely outside the project's goals, linking to a discussion on the point.

How is vvaltchev/tilck built?

From the repository root, where a Makefile exists mainly to forward into a build directory. It reads the toolchain directory name out of other/toolchain_conf, stops at parse time if that value is missing, and tells you to build the toolchain by running ./scripts/build_toolchain first. CMake is invoked through ./scripts/cmake_run when no CMakeCache.txt is present.

Official sources

  1. Issues
  2. License: BSD-2-Clause
  3. README
  4. vvaltchev/tilck on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/vvaltchev-tilck.svg)](https://hysenlabs.com/projects/vvaltchev-tilck)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/vvaltchev-tilck.svg)](https://hysenlabs.com/projects/vvaltchev-tilck)

Was this useful?