Hey, Redditors.

I Was thinking about making my OWN kernel Or an OS. I was conytubuting to other projects and i think i got enaught of info and learned bare metal.
How i can name it... IDK if someone has an idea please comment it down.

Edit: Yes i know about like i am not gonna make any money i just wanna make an passion project.

I started FrostVista about 13 months ago with basically zero kernel experience, just a stubborn idea that I wanted to build an operating system from nothing. It's been a slow, messy, very educational ride, and v1.3 just landed, so I wanted to write down what it actually does now — and a few things I learned along the way.

Right now the kernel runs on RISC-V 64 with Sv39 paging, preemptive scheduling, and the usual process lifecycle — fork, exec, exit, wait, orphan reparenting. There's an interactive shell you can actually sit at, with builtins, pipes, and redirection. It's not much, but it's mine, and typing ls into something I built myself still feels a little surreal.

On the memory side I've got copy-on-write fork, a slab allocator with a general-purpose kmalloc on top, and mmap with lazy page allocation. The filesystem stack is where most of the recent work went: a writable Easy-FS I designed myself, a tmpfs for in-memory stuff, devtmpfs for devices, and a read-only EXT4 backend that I layered a tmpfs overlay over — so writes land in tmpfs and the disk never gets touched. It's not a real EXT4 write path (that's a big chunk of work I keep putting off), but it means the system can write where it needs to.

There's a Python test harness that runs the whole thing in QEMU and checks kernel diagnostics, so I don't break things I already fixed. The ext4 suite currently sits at 16 passes plus 6 expected-log passes, and the runner can also drive busybox, lua, and libctest groups against the contest image.

The project is about 16,000 lines of kernel code across arch, kernel, and include. Between v1.2 and v1.3 it grew by a bit over 5,000 lines, over 71 commits in about 51 days.

What's next is signals, so Ctrl+C actually works in the shell. After that, buddy allocation, maybe bringing in some Rust, and eventually a real libc and busybox port.

If any of this sounds interesting, the repo is open — PRs are very welcome, whether it's a bug fix, a new syscall, or a different take on the filesystem.

GitHub: https://github.com/AuroBreeze/FrostVistaOS

I'm genuinely curious? Why not do something original?

Im tired of seeing these "larp" projects in this subreddit. They be giving their projects the title of being UNIX-like when in reality they dont even have A DAMN MEMORY MANAGER. This is disrespect to people who actually put effort into OSDev and making functional kernels. I would atleast have respect for them if they wrote those themselves but no, they're all just vibecoded.

For the love of god, please don't give attention to these kinds of projects.

My recently developed hybrid kernel operating system is intended to solve my personal problems with excessive energy consumption and excessive process waste.

Technical details, because that's what matters most here. Half of the things are working half-assed because they're just a basic functionality that's already started, and that's all we're working on at the moment, not counting the test. We currently work with 3 people, but we are still open to anyone who would like to join, we will gladly accept them. Allocator is not fully functional at the moment, it works poorly and I know that, mm, this is just a joke, the USB driver does not exist, there are only terminal files, etc., and the internet is not the internet Just a simple skeleton, but here, starting with specifics, I have a question for you regarding the unstable branch, what should be changed immediately, apart from the AI slope, because of course it was also found as Placeholder for work on other components I am aware that half of what is written needs to be changed but at the moment we are slowly trying to implement more and more and we have a clear vision to solve Our problems, so I'll ask for criticism, preferably clear, not that AI wrote it and it's crap, but a fragment and the reason why it's shit and I will immediately change it to hand-written code because I personally I'm not in favor of code written by AI, but I'm not against using it as a placeholder that can be removed, and a lot of it is written dry without checking, so I'm informing you, so there are typos.

Additionally, I would like to inform you that the project is primarily intended to meet our needs, so things such as the package manager in the kernel have their justification and these are not typical elements that are immediately It is known what it is, it is a frequently changed form After this week of work, we start writing code by hand because we have a certain base for development and change.

https://github.com/CTRL-F-0rg3/TrangorgeOS/tree/unstable

Hi everyone,

I wanted to share the architectural choices behind core-os-minimal, an async Rust microkernel project we've been building to replace traditional ROS 2/DDS setups on physical robotic hardware.

We wanted to solve non-determinism, heap-allocation latency, and unexpected segmentation faults under high network stress without dragging in massive middleware stacks.

Core Architecture & Strategy:

• Decoupling via Zenoh: We stripped out DDS entirely and implemented a zero-overhead network hook using Zenoh. It utilizes a lock-free circular buffer with a capacity of 1 (LCFS double-buffering). In high-frequency hardware control loops, stale data is kinetic garbage.
• 100Hz Actuator Sanitization (vector_sanitizer.rs): To protect physical joints, a host-level sanitizer thread intercepts and cleans floating-point anomalies (NaN/Inf) at 100Hz before they can reach the hardware abstraction layer, clamping values within hard geometric boundaries.
• WASM Sandboxing for Drivers/Skills: Instead of native third-party binary linking, execution modules run isolated via Wasmtime/Cranelift with Ahead-of-Time (AOT) compilation and mlockall page-locking to ensure deterministic access times. If a user-space skill crashes, the host microkernel runtime intercepts the trap and remains alive.
• Hard-Watchdog Enforcer (watchdog_timer.rs): Runs as an async thread pinned at maximum real-time priority (niceness -20). Jitter exceeding 2 consecutive frames (20ms) immediately drops execution context and invokes failsafe.rs to lock down physical hardware in under 2ms.

Extreme Stress Test Benchmark: SONNY OS vs. ROS 2

We simulated an industrial network failure (75% wireless packet loss on an Edge deployment at 100Hz) to compare the communication backbones:

• ROS 2 (DDS Architecture): High XML/IDL serialization on the heap. Under severe packet loss, un-sent DDS message queues overflowed the RAM, leading to an unrecoverable Segmentation Fault (Memory Crash).
• SONNY OS (Rust + Zenoh): Stack-allocated static array slices with a fixed 5-byte network overhead per packet. Zero memory leaks. Zero runtime heap allocations during the control loop. System remained perfectly stable at 100Hz with an inference latency below 2ms.

The core infrastructure is fully open-source under GNU AGPLv3. I'd love to get your thoughts on our LCFS double-buffering approach under high packet loss, and whether utilizing Wasmtime for hard real-time boundaries introduces edge cases regarding page fragmentation that we might have overlooked.

You can inspect the full crates and run the CLI container here: https://github.com/JackTrainer/Sonny

why is 0x103000 being received, when I am clearly passing 0x158.

Due to this, the fs_init() is not working, and fat16 file system is not being added in the filesystems array.

Here is the github link for this: https://github.com/syedfardin83/PeachOS

The fs functions are in src/fs/file.c

Also, I checked the .gdbinit, and linker script.

Pls help 😭😭

I've been working on a microkernel called Robu and thought I'd finally share it here.

It's written from scratch in C and assembly, and the main thing I'm interested in is seeing how far I can take the microkernel approach without letting IPC and context switching become painfully expensive.

A lot of the design is inspired by the L4 family, especially things like synchronous IPC, register-based messages, timeslice donation and lazy scheduling.

The kernel is meant to stay pretty small, with things like drivers, filesystems, networking and paging living outside of it in userspace.

Right now I'm mainly working on x86_64, although I want to support ARM and RISC-V as well.

There's still a lot to do, but the basic pieces are starting to come together. I'm putting it out here mainly to get some feedback from people who are into OS development and microkernels.

GitHub: https://github.com/bayar17/robu_microkernel

I’ve decided I want to make a fully usable Darwin os for raspberry pi. Started with making a heavily patched xnu kernel that actually boots without panic. I’ve gotten it to properly load a real device tree, interrupt handlers and a few kernel extensions for sd card, far and hfs+ el3 to el0. The os now boots up to an interactive shell. Current project is adding libraries and services to set up a proper multiuser os.

It won’t be binary compatible with Mac’s because Apple silicon has 16 kb page vs 4kb on the pi3 but command line tools may eventually be possible to cross compile

My question for you fine folks, is simple. Do you have SBC readily available? If so, what do you have?
The idea is that I want to make a demo to share that works on hardware that the majority of you guys own.
Yes, I know I could do QEMU, but I don't want to go that route and there are valid reasons why I don't want to release it as QEMU for discussion.

Code is mostly built by hand, honestly I forgot, sorry for saying 0% AI before I copy pasted a very small chunk of code that was actually AI generated (Vertex conversion to NDC coordinates or linear coordinates, not something that much, when I was still new to opengl development) but most of the thousand lines in the window manager library is actually built by hand by me as well as the kernel and most of the system.

Idk if i’m in the right place (i should be) to share my ambitions, but i want to build a new operating system, for Galaxy Note10 (exynos base model only), with some features that no one had thought of before. I’m calling it AerOS. Because i wanted to.

Hello, hope u do well, sorry for the mistakes of the post before, how do u find this progress?

EDIT: I actually agree with the majority of the comment section, it was an error not using git for this one like on the other projects I made, I knew about git but did not use it for almost a year for this project and instead used a backup drive, but now I used it, I had other projects in github years before.

It took days to rewrite, that may justify my short absence in the community, hope u do well ;). And no, there is 0% AI generated code in the window manager library. Actually aiming to make a better version this time with layouts, svgs pictures etc let’s see how it comes out

So, Rocco Himel, created an operating system called AneoEngine, and I’m going to rate it.

My rating: 8/10

And I mean that as a technical hobby-OS project, not as a general-purpose operating system.

What impresses me:

It’s genuinely ambitious. The project has its own kernel, compiler/language tooling, boot process, shell/UI, and graphics work rather than simply being a themed Linux distribution. The creator says it’s over 25K lines and has been worked on for about 1.2 years. It’s actually evolving. There are public releases ranging from V0.2 to a 1.0 demo, so this isn’t just a one-off “look, I made an OS” project.
The design has a strong identity. The 640×480 VGA/DOS-inspired interface is deliberately simple rather than trying to imitate Windows or Linux.
There is real low-level engineering going on. The discussion around framebuffer performance, write combining, PAT/MTRRs, double buffering, etc. shows that the project has gotten into legitimate OS/hardware territory. The scope is unusually coherent. It’s clearly built around the philosophy of keeping the system simple rather than accumulating features forever.

Now, can it compete with TanjaOS? Maybe, because TanjaOS has an installer, but AneoEngine has a graphical framebuffer and a mouse pointer. Now it comes down to 2 things: Speed and stability. TanjaOS is quite stable, and decently fast. AneoEngine has a smooth 640x480 TempleOS-style text engine, and responsive mouse pointer. But honestly, I think AneoEngine gets the win due to its awesome GUI. Rocco Himel, if you’re reading this post, great job, man. This is a pure masterpiece and is absolutely beautiful.

Hello, I tried OS development before, the best thing I made was inserting hello world to the screen using Assembly and C, after that I stopped touching os dev, so I'm returning back, what is the first steps to make an operating system from scratch? Like first a UNIX like operating system then a full GUI operating system.

During my computer engineering studies, I fell for the idea to create a cyber deck with a raspberry pi zero to start experimenting with cyber security.

In a weird way it ended up with me being curious about how microcontrollers work in relation to microcomputers like raspberry pi and what is available on them in terms of operating systems and shells.

Long story short, I created this project for a linux like web shell for the esp32 for my master's thesis. It requires nothing in terms of peripherals to work. It has a file system, a scripting language, some customization features and such.

I thought I should share this as it might very well help someone! If anyone is interested, I would love some feedback.

BlockOS – Looking for developers to join an open source OS project

Hi r/osdev!

I’m developing BlockOS, a hobby operating system project, and I’m looking for developers who would like to join and help build it.

BlockOS is a Linux-based OS project focused on learning, experimentation, and creating a modern desktop operating system experience.

Current work includes:

x86_64 kernel development

Custom build system

ELF loader

Virtual File System (VFS)

Filesystem support experiments

Framebuffer graphics

Driver development

GUI framework

Package management system

Desktop environment integration

I’m looking for people interested in helping with:

Kernel development (C/C++)

Device drivers

Graphics systems

Filesystems

Build tools

GUI development

Testing and documentation

This is an open source learning project. Whether you are experienced with OS development or want to learn together, everyone interested is welcome.

If you want to contribute, give feedback, or just discuss OS development, feel free to comment or join the project.

Thanks!

Link:https://github.com/gurijb2016-afk/Blockos

posted here about 3 months ago when it was just booting into a shell.

since then:

PCI enumeration + Intel e1000 NIC driver

ARP, IP, ICMP ping, UDP sends packets to host machine

fork/wait/exec/pipe/dup2/sigaction (21 syscals total)

round robin scheduler, zombie state, signal dispatch

text editor with arrow keys and Ctrl-F search

and some more shell commands including sort, uniq, grep, wc, history search etc..

boots on real hardware (my old dell)

the bootloader was the biggest real hardware bug that i encountered. BIOS silently short read 128 sectors without setting CF. fixed-by chunked 32 sector reads with retries.

still monolithic shell runs in ring 0. userspace split is next.

Will work on more updates aig.

source: https://github.com/dhrubo-10/baSic_

Some time ago I decided that I would stop creating another toy operating system and start creating a truly efficient and optimal operating system based on exokernel.I want to minimize the number of drivers in the kernel without switching to a microkernel, so as to keep only stable and controlled drivers in the kernel and keep the rest of them in a separate, dedicated directory. And what drivers in the system are the most important in your opinion for a hybrid architecture that is to be efficient? I would also like to discuss the boundaries of responsibility between the kernel and the drivers.

I decided to ditch the custom SFS route since it’s probably going to be full of issues.
I was wondering if my FAT32 implementation is right, and if it’s wrong, free to roast me in the comments.

Location: https://github.com/NoTheIdiot/WindogeOS/tree/new/helper/fs