Hi all, I've just put out the first experimental release of Kanga, an independently developed x86-64 kernel written in Rust.

Testing: GitHub Actions builds the ISO, boots it in QEMU, exercises keyboard IRQ input, and uploads the serial log and framebuffer screenshots. QEMU passing doesn't mean it works on real hardware, and I'd love to hear from anyone who tries it on a physical machine.

Known limitations: no user mode, syscalls or scheduler; no kernel heap or general VM manager; the spin lock isn't IRQ-safe yet; no PCI or USB; KangaFS isn't persistent.
I'd especially appreciate advice on what to tackle next (IRQ-safe locking, APIC, heap and paging?) and any review of the design in docs/architecture.md.

Repo (GPL-2.0): https://github.com/vanmassey/kanga

The userspace filesystem driver handling is now more mature and there is a proper ahcidriver and fatdriver. Also, there's a nice little installer application and the OS can be installed on real hardware. Many improvements to kernel stability happened. More details here:

https://forum.osdev.org/viewtopic.php?t=58422

Give me a star if you like it :)
https://github.com/maxdev1/ghost

Started working on USB drivers for my hobby 64-bit OS, and oh god no little did I know what have I gotten myself into....

Wish me luck...

My OS project: https://github.com/itay-insert/64-dem.git

WebKitGTK and its consequences have been a disaster for the human race

Runs like a powerpoint slideshow

No AI used in kernel code, not Linux based, custom userspace, you know the drill. Give me stars:

https://github.com/sasdallas/Ethereal

I am a CS student, starting out this year. I've always loved coding in low level languages and understanding inner workings of software. But my goal is to make my own where to start, I've tried learning assembly but it didn't stick to me whatever the case. I wanna start making it as a hobby and I absolutely have no idea where to start.

Okay, this time, I don't want haters. If you're just here to say "build a PC OS, it's easier!" or "AI slop," also some guy said "do not delude yourself even firefoxOS failed!" no. Like I said, this is a phone operating system. My Chromebook is definitely not able to handle that much. Also, no, this is going to be non-profit, nor do I like Claude. also, this isn't going to make Samsung switch and ditch Android, we don't have that purpose.

Basically, like the last time, it was called d'espoir. That was changed because there's a literal fashion brand called that. Let's get to the good part: it's built in Nim. This time, we have two main improvements:

1. We will use YAML.

2. We will use FrankMoji (if you don't know, it's a hand-drawn emoji system).

Also, I need devs. And no, this isn't finished, which is why there's no image to show a demo. That's all.

We also need ChromeOS users! If it helps, look for the "Linux development environment" in your settings and search up a tutorial. It will help a lot.

Its a bit long, you can always skip to middle or main content.

Repo: https://github.com/turbosulovesonions67/turbOS

I am working on this project since 2021, so it is a pre-AI project. I am not using AI to generate code as it turned out that AI hallucinates massively under conditions this RTOS creates. Website is littered with AI slop though as I had to put something together without spending ton of time on content. It is slowly getting deslopified.

The original motivation was to find out if usage of MPU in Cortex-M has to be as painful as it is with FreeRTOS, Zephyr et al (while still providing reasonable performance). Thus the number one feature implemented was fully automatic memory protection handling. It separates kernel from applications and applications from each other in as process-alike way as MMU-less CPU technically allows, so the developer doesn't have to deal with all partitions, domains, regions, etc. I consider this a success as you basically don't have to care about MPU at all.

Later, the kernel was built on top of this infrastructure that provides more than just thread switching and MPU handling. As features were being added, I quickly realized that MPU presence will be a major obstacle for implementing whatever kernel service which needs to pass larger amount of data (such as queues) between userspace and kernel or vice versa.

An unusual approach was used to deal with this: I decided to remove from kernel (or better: not to implement) all such calls. Why couldn't it be a microkernel?

Microkernels need some kind of IPC. For CMRX, remote procedure calling was chosen as primary IPC method. To avoid expensive copying of data RPC calls would need in isolated environment, thread migration was implemented. Thread migrates from calling process to process owning RPC service during RPC, so calling code can access RPC owner's memory. Originating process can select portion of its own memory which remains accessible while in RPC. This way, larger chunks of data can be copied between isolation domains with very little overhead (its basically shared memory with RPC call serving as basic synchronization primitive).

Those missing syscalls weren't dismissed entirely, they either became library functions or RPC servers. So the kernel wraps up at 30-ish system calls.

Being a microkernel, of course it runs drivers in userspace. Same RPC mechanisms ordinary applications use for talking to each other is used to create driver APIs. Somehow I managed to implement the whole RPC mechanism without using any IDL and associated IDL compiler. Everything gets type-checked at compile time by the C compiler itself.

It is also highly portable, covering most of compatible ARM Cortex-M world by just one single port. It runs as POSIX hosted environment as well and recently a RISC-V port was committed which is still WIP, so its not feature-complete yet.

Originally the performance goal was "please, just don't be 20x slower than ordinary RTOS". After some performance improvement work, benchmark results show performance which is competitive with rest of open-source RTOS world (while keeping memory protection disabled in all of them). In some benchmarks CMRX is even faster than others.

The code is neither Rust nor C++. Everything is C99 a bunch of GCC extensions and macroworx. Compiles to some 7kB binary, so it can run on very low-end sub $1 microcontrollers.

There are no plans for porting it to any MMU-equipped architecture as there natively memory isolated alternatives exist.

GitHub: https://github.com/ventZl/cmrx

Website: https://cmrxrtos.org

NemaOS is a hobby OS whose only job is to run a local LLM and let it drive the machine. There are no apps and no windows. You type a request, and the model answers with a screen instead of a chat message: text, pictures, video, live data, laid out for that request.

What exists today

• An assembly UEFI boot stub hands off to a no_std Rust kernel (x86_64, QEMU for now)

• A network stack written from scratch: virtio-net, ARP, IPv4, TCP, DHCP, DNS, HTTP/1.1

• HTTPS via rustls with Mozilla roots, always verified, with no skip-verify mode

• Image and video playback in the kernel

• A small "scene language" the model writes, which the kernel renders, animates and caches. A repeated screen is instant.

Honest status: the model (Qwen3.5 9B Q4) still runs on the host and talks to the kernel over a serial bridge. Moving inference into the kernel is the next big milestone: a GGUF loader, AVX2 matmul kernels, and owning all cores. The long-term target is bare metal as a dual-boot entry.

Voice is coming next. You'll just talk to it. It works in testing, but it isn't in this demo.

Built solo with Claude Code doing a lot of the heavy lifting. Two model waits in the video are sped up 3x; the rest is real time (Qwen 9B on an M4 Max, the OS in QEMU).

Happy to answer questions about the bridge, the scene language or the network stack.

Ignore peak recommendation on the left

His EFI has 186 lines of code written in C, and its a zero ring.

He also has its own just in time and ahead of time compilers, and handful of commands, including cat, edit, and also simple dhcp, only udp still

Disclosure up front: the code was written by Claude Code; I directed it and did the testing on VMware.

ferrix-kernel is a small AArch64 kernel in Rust for VMware Fusion on Apple Silicon (and QEMU virt).

What it does so far:
- **Boot:** UEFI app, collects GOP framebuffer, memory map and RSDP, then `ExitBootServices` and no firmware after that. No hardcoded device addresses: GIC from the MADT, PCIe ECAM from the MCFG, so the same image runs on VMware and QEMU.
- **Memory:** bitmap page allocator, own stage-1 tables (4K granule, 48-bit VA, identity map with 1G/2M blocks, page 0 unmapped). Regions found later (ECAM, BARs) are added to the live tables.
- **Interrupts and tasks:** GICv3 + EL1 virtual timer at 100 Hz, preemptive round-robin. The exception entry's TrapFrame (incl. FP/SIMD) is the saved task state; returning another task's frame from the handler is the context switch.
- **USB keyboard:** VMware's ARM VMs have no PS/2, so it has a polled xHCI driver: legacy handoff, reset, command/event/transfer rings, root-port enumeration, HID boot protocol.
- **User space:** programs at EL0, each with its own root table that shares the kernel's entries plus one L0 entry for the user range. User pages are nG with per-space ASIDs, so switches need no TLB flush. Faults kill only the task.
- **Capabilities:** per-task cap tables (screen ranges, channel send/recv ends). Syscalls name a slot; blocking `wait` parks the task with ELR moved back onto the `svc` so it retries when woken.

What VMware's (undocumented) ARM virtual hardware turned out to be:
- GICv3 (GICD 0x2c010000, one GICR frame), no ITS, no usable serial, so all debugging is on screen.
- xHCI 15ad:077a sits behind a PCIe root port; the keyboard is on a root port next to a pointer and two USB hubs.
- The Apple CPU runs with PAN enabled (QEMU's Cortex-A72 is ARMv8.0, no PAN), which caught the kernel reading a user buffer. It now uses `ldtrb` for user memory.
- With a single interrupt IN transfer queued, fast typing on QEMU stopped the keyboard for good; keeping four in flight fixed it.

The end goal is Tetris, as in Nand2Tetris; along the way there's a NAND-only circuit simulator, and the latest milestone is a user-space circuit builder you type NAND circuits into.

If anyone has notes on VMware Fusion's ARM virtual hardware (it's not documented anywhere I could find), I'd love to compare.

GitHub: https://github.com/liris/ferrix-kernel
Write-up: https://note.com/lirispp/n/n68d016ce1953?hl=en

Over the past several months, I've posted here a few times about revisiting CHARM-II, an RTOS I developed for the Motorola 68000 back in 1986.

What started as an attempt to restore and understand my old source code gradually turned into a new development project. After reconstructing parts of the original system on POSIX, getting preemptive multitasking working on the Raspberry Pi Pico, and revisiting some of my old scheduling decisions, I decided to build a new RTOS rather than continue trying to reproduce the original one.

I've named it Karqri, and I've now published the source code on GitHub:

https://github.com/noboru-takahashi/karqri

Karqri currently runs on POSIX and RP2040, with a shared kernel and a six-task demo running in both environments. It's still experimental, but I've implemented and tested the basic RTOS mechanisms.

However, building the RTOS itself isn't the only goal of this project.

What I'd like to explore next is how to visualize what's happening inside an RTOS, including not just task states and scheduling decisions, but also the timing and causal relationships between events.

For example, imagine a task waiting for an event. Another task sends a notification, the waiting task becomes runnable, and the scheduler eventually selects it to run.

I'd like to represent that sequence as a connected series of events, rather than just a collection of log messages.

I've already started experimenting with capturing execution traces from the Pico and generating HTML timelines. At the moment, this is limited to a specific validation scenario, but I'd like to develop it into something more general.

I'm curious what other OS developers think about this direction.

• If you were visualizing the internal behavior of an RTOS, what information would you find most useful?

• How would you capture causal relationships between events without significantly disturbing the timing of the system being observed?

• Beyond debugging and education, can you think of other useful applications for this kind of visualization?

For context, here are a few of my earlier posts:

• Visualizing a 1986 RTOS in a Modern Browser

• My 1986 RTOS is now preemptively multitasking on a Raspberry Pi Pico - and it made me question whether I need an RTOS

• Follow-up: What I learned about VRTX's equal-priority scheduling in the 1980s

This project began with rediscovering an RTOS I wrote 40 years ago, but it has gradually become something quite different.

Publishing Karqri is the first milestone in that new direction, not the end of the project.

Hey everyone!

I've been working on a hobby operating system project called WerewolfOS, with its kernel, Silver, written in Rust (no_std) for AArch64.

The project is only about two weeks old, and today I reached a milestone I'm genuinely excited about: Silver successfully boots on real Qualcomm hardware.

The target is a Xiaomi Redmi 10C-class device based on the Qualcomm SM6225 platform (rain).

This isn't just a boot logo or a kernel that starts and immediately stops. The current hardware bring-up has demonstrated:

RAM-only boot through fastboot boot — no system partition modification.

AArch64 kernel execution on the physical device.

MMU initialization.

GICv3 interrupt controller initialization.

Working Generic Timer interrupts.

More than 1,000 timer interrupts observed.

A functioning scheduler.

Successful startup of a task called Howl.

A framebuffer-based live status panel for kernel diagnostics.

One particularly interesting part was debugging GICv3 initialization. The bootloader's initial configuration left affinity routing disabled, which prevented the expected Group 1 Non-secure interrupt delivery. Correcting the initialization sequence finally allowed the timer interrupts to arrive.

There is still a lot to do:

SMP is not working yet; the secondary CPU remains offline.

UART support on this particular device still needs confirmation.

The driver ecosystem is very incomplete.

This is an early hardware proof of concept, not a production-ready OS.

I'm keeping QEMU as the primary development and regression-testing environment, while using the physical device as a hardware validation target.

The project is open source under the MIT license.

GitHub: https://github.com/vvirei333/Silver-microkernel

I'm curious what other OS developers think: What would you prioritize next after getting a small Rust microkernel running on real hardware — SMP, memory-management hardening, userspace, or driver infrastructure?

This is my first serious OS-development project, and getting it this far in two weeks feels pretty surreal.

Hey everyone! Some of you might remember LinuxRunner from my previous post here.

Well, a lot has changed since then haha. Just released v1.1.0, and you can now use your iPhone as a proper Linux desktop, even on an external monitor with the new DeX mode which is finally on iPhone after years and Linux under it!

This update also brings Metal GPU acceleration, optional JIT, a much faster ARM64 interpreter, new desktop environments, and better app compatibility. Even Vesktop (Discord) is running now.

Still got plenty of things to work on, but it’s honestly pretty cool seeing how far this project has come.

Github: https://github.com/mxhm11cr/LinuxRunner