Skip to content
<open-source>
Oeiuwq Faith Blog OpenSource Porfolio

nuta/kerla

A new operating system kernel with Linux binary compatibility written in Rust.
Source code at GitHub https://github.com/nuta/kerla
nuta/kerla.json
{
  "createdAt": "2021-05-18T12:32:54Z",
  "defaultBranch": "main",
  "description": "A new operating system kernel with Linux binary compatibility written in Rust.",
  "fullName": "nuta/kerla",
  "homepage": "",
  "language": "Rust",
  "name": "kerla",
  "pushedAt": "2024-11-11T00:45:43Z",
  "stargazersCount": 3451,
  "topics": [
    "operating-system",
    "operating-system-kernel",
    "rust"
  ],
  "updatedAt": "2025-11-24T16:52:54Z",
  "url": "https://github.com/nuta/kerla"
}

Kerla

Section titled “Kerla”

![screenshot]!(screenshot.png)

Kerla is a monolithic operating system kernel written from scratch in Rust which aims to be compatible with the Linux ABI, that is, it runs Linux binaries without any modifications.

  • Implements *NIX process concepts: context switching, signals, fork(2), execve(2), wait4(2), etc.
  • Supports commonly used system calls like write(2), stat(2), mmap(2), pipe(2), poll(2), …
  • No disk support for now: initramfs is mounted as the root file system.
  • Pseudo file systems: tmpfs and devfs.
  • smoltcp-based TCP/IP support.
  • Implements tty and pseudo terminal (pty).
  • Supports QEMU and Firecracker (with virtio-net device driver).
  • Supports x86_64.
  • Docker-based initramfs build system.

Check out my blog post for motivation and my thoughts on writing an OS kernel in Rust.

[!IMPORTANT]

This software is no longer maintained. If you are interested in a modern OS written in Rust, check out my new project Starina.

Demo: SSH into Kerla!

Section titled “Demo: SSH into Kerla!”

You can play with Kerla over ssh. Your login is not visible from others (except me): we automatically launch a dedicated microVM on Firecracker for each TCP connection.

$ ssh root@demo.kerla.dev

If you found bugs or missing features, let me know on GitHub issues :)

Running a Docker Image (experimental)

Section titled “Running a Docker Image (experimental)”

You can run a Docker image as a root file system (not as a container!) on Kerla Kernel instead of our initramfs built from initramfs directory.

For example, to run nuta/helloworld image (Dockerfile), try the following command:

$ make IMAGE=nuta/helloworld run
...
[   0.029] syscall: execve(439398, 4393b8, 4393c8, 8, 2f2f2f2f2f2f2f2f, 8080808080808080)
[   0.030] syscall: arch_prctl(1002, 4055d8, 0, 20000, 0, ff)
[   0.031] syscall: set_tid_address(4057f0, 4055d8, 0, 20000, 0, ff)
[   0.033] syscall: ioctl(1, 5413, 9ffffeed0, 1, 405040, 9ffffeef7)


 _          _ _                            _     _ _
| |__   ___| | | ___   __      _____  _ __| | __| | |
| '_ \ / _ \ | |/ _ \  \ \ /\ / / _ \| '__| |/ _` | |
| | | |  __/ | | (_) |  \ V  V / (_) | |  | | (_| |_|
|_| |_|\___|_|_|\___/    \_/\_/ \___/|_|  |_|\__,_(_)

This feature is in a very early stage and I guess almost all images out there won’t work because:

  • They tend to be too large to be embedded into the kernel image.
  • They might use unimplemented features (e.g. position-independent executables used in Alpine Linux).

Building and Running the OS

Section titled “Building and Running the OS”

See Quickstart for instructions on building from source, running on emulators, etc.

Current Roadmap

Section titled “Current Roadmap”

Roadmap - Run a Node.js Web Application on Kerla on Firecracker on AWS

Compatibility

Section titled “Compatibility”

See here for the current status.

Contributing

Section titled “Contributing”

Send me bug reports, feature requests, and patches on GitHub for example:

  • Implementing missing features: majority of existing Linux applications won’t work due to the lack of features.
  • Writing documentation: I think Kerla could be good material to learn how an operating system kernel works.
  • Trying to experiment with Rust-y ideas: for example currently I’m interested in GhostCell.

License

Section titled “License”

See LICENSE.md.

Section titled “Related Work”

Emulating Linux ABI is not a novel work. Some UNIX-like kernels like FreeBSD and NetBSD already have their own Linux emulation layers. Windows has a well-known feature called Windows Subsystem for Linux (WSL) which enables running Linux binaries seamlessly. WSL 1 implements the feature by ABI emulation. WSL 2 runs the real Linux kernel using the hardware-accelerated virtualization (Hyper-V).

Aside from general-purpose operating systems, there’re some attractive projects related to the Linux ABI emualtion. OSv is a unikernel which runs unmodified Linux binaries. rCore is a teaching operating system which implements the Linux ABI in Rust. Noah suggests an intriguing approach to run unmodified Linux binaries on macOS.