Minimal x86 Kernel Zig

[WD-42]

Here's one for Risc-V that's a little more fleshed out, also in Zig: https://github.com/Fingel/aeros-v/blob/main/src/kernel.zig

[feb]

That one actually looks more like a real kernel with services like memory management, syscalls, processes and context switching. Nice work.

[6r17]

I'm very surprised it's *that* short - handling one in rust i'm surprised by the very low amount of code to get that up. Thanks or sharing that was a first time reading some Zig for me !

[pmarreck]

what you’re experiencing is more or less why I am building some stuff in Zig instead of Rust

[karlosvomacka]

it doesn't have a bootloader.

[kunley]

Why to spread confusion and call it bare metal when it's run under QEMU? Then it's not bare metal at all.

In order to be run on bare metal it's needing another bootloader which the documentation only barely mentions.

More on the naming: why to call it kernel?

[toast0]

Almost every OS needs a bootloader; but not every OS needs to develop one. Certainly there's some exceptions where there's not really separation between the two functions, but it's not common and most hobby OSes have the distinction unless they're single sector OSes.

The booloader and the kernel are separate stages; they're both interesting, but pick the part that interests you and work on that. With the multiboot standard and existing loaders like ipxe and grub, if you want to write a kernel, there's no need to write your own bootloader.

Otoh, if you want to write your own bootloader, you can do that too, there's plenty of existing kernels to boot.

And yeah, this kernel does nothing. But it would be a reasonable start to a kernel that does things, although you would need to write all the things.

Bare metal in qemu is a little fishy, but it's easier to take a screenshot of qemu than to take a screenshot of a full computer. I would expect this to run on a full computer as long as it supports BIOS booting, and then it would be a bare metal boot and halt kernel.

[lelanthran]

> In order to be run on bare metal it's needing another bootloader which the documentation only barely mentions.

Maybe it's an in-group vs out-group thing: those in the group (i.e. have attempted this in the past) don't care about what the first stage bootloader is; you'll just use some existing bootloader (I used grub).

If you're in the out-group, you feel cheated that you still need a bootloader.

[ajxs]

The kernel is Multiboot compliant, so it's already compatible with real bootloaders. Creating a disk image with a real bootloader wouldn't be much extra code, but if your point is just to demonstrate a 'bare-bones' Zig kernel, is it really necessary?

[eddd-ddde]

You still need a bootloader to run the Linux kernel.

[cies]

I agree, I'd not call this a kernel. It does not allow any software to be run on top of it. It just prints text to screen and halts.

Even saying it "runs" on QEMU is a far stretch: it "halts", that's all it does. :)

(it does run on hardware as per other commenters in this HN convo)

[csense]

Very neat. To clarify, Qemu can boot it, but I'm pretty sure you need some bootloader (e.g. Grub) to boot it on a physical system.

[toast0]

Looks like it's multiboot compliant, so you can pick your favorite multiboot loader. ipxe, grub, pretty sure there's some other ones out there.

As it's multiboot, it should likely run on v86 too. It's always fun to have an in browser demo of a little OS like this.

[anta40]

If you want to use Grub, this tutorial works (see "Booting the kernel"):

https://wiki.osdev.org/Zig_Bare_Bones

Yes, just tried it.

[flopsamjetsam]

From the GitHub page:

> It boots on an x86 (i386) machine via the Multiboot 1 protocol

Yes, it does need a compliant bootloader on virtual or physical hardware.

[lopespm]

OP here, thanks for all the comments! In the meanwhile added the capability to build a bootable ISO with a GRUB menu https://github.com/lopespm/zig-minimal-kernel-x86

[drnick1]

What's the point of doing this in "Zig" instead of C, the traditional choice for this kind of thing?

[toast0]

Because you can is a pretty traditional reason.

Zig is supposed to be an improvement upon C, so doing C things with it seems reasonable.

Kind of neat that there's no need for a separate assembly file although there is inline assembly. Might get better (or worse) syntax support for separate assembly files? But it doesn't make a big difference until there's more features that need it (interrupts, threads/processes and maintaining their stacks, syscalls, starting other processors, etc)

[AndyKelley]

bitpacked structs, good enums, arbitrary sized integers, optionals + non-nullable pointers, fast compiler, zig fmt, unit testing, ability to use standard library and the rest of the third-party ecosystem on freestanding, std.ArrayList, std.AutoArrayHashMap, std.MultiArrayList, std.crypto, more productive type system, comptime, SIMD, slices, labeled switch continue, error handling, custom panic handler, stack traces on freestanding, error return traces, zero bit types, the build system, package management, aligned pointers, untagged union safety, multi-object for loops, inline switch cases, semantically guaranteed inline functions, inline loops

[kunley]

I guess one of good reasons is easy cross-compilation.

But also, I can see some amount of weird hooray optimism in this project, like: totally confusing claim that the thing is bare metal when it's still being run under an emulator; also, calling it a kernel is a huge overstatement

[kennykartman]

Because Zig is the future, Rust has clearly failed and C is simply obsolete in 2026. The rest doesn't even matter.

[jandrewrogers]

Zig is essentially a substantially improved and enhanced C, both in character and intent. There is a lot to recommend it for applications where you might otherwise use C.

[mitchellh]

Fun?

[flohofwoe]

In this case, better tooling and consistency. E.g. the small block of inline assembly would already be trouble for some C compilers.

[pmarreck]

because Zig is simply a better C, often faster (normally at least as fast), but with way more safety guarantees or at least things preventing the vast majority of traditional C footguns from happening

[6r17]

What's the point writing another kernel in C ???

[moonlion_eth]

because zig is lower level than c

[boricj]

I wrote something similar a while ago: https://github.com/boricj/hang-os

It handles interrupts/traps and targets the aarch64 QEMU virt platform. It also features a HAL.

[aryalaadi]

thats not a kernel

[benatkin]

Indeed, it's freestanding, the repo name doesn't have the correct term, but the source file does near the end: https://github.com/lopespm/zig-minimal-kernel-x86/blob/main/...

Also baremetal where the metal is virtual. LLVM uses this term for when an OS isn't available https://github.com/llvm/llvm-project/tree/main/libc/src/stdl...

[ajxs]

See also: https://wiki.osdev.org/Zig_Bare_Bones

[anta40]

Both tutorials work fine on latest stable zig (0.15.2)

[xx__yy]

Thanks for sharing

[gethly]

wtf? 10 lines of hello world code is not a kernel.

[messe]

Minimal slop.

[xx__yy]

Gold! I see Zig, I upvote!

[smallstepforman]

Well, in the real world we need at least polymorphism and operator overloading, but that is against the core Zig philosophy, so serious GameDev ignores it (which ironically one would think is the biggest core market for low level systems programming). Hence why new GameDev development still chooses C++, and Andrew’s project fails to gain a significant boost in users.

[throwaway27448]

Why choose intel? Let's build bootable software in 2026

[xx__yy]

I'm not that cluey, but from the README it sounds like it can be compiled for a bunch of arches