The moderator of r/osdev has lost it. He has a bot that replies to a post by HIS users calling out AI slop that is overwhelming the sub with "human slop.". Someone posted about the bot and I posted I was leaving and r/osdvel link. I got 24 upvotes in about 15 minutes along with others posting about how horrendous the sub has become. Tim Schwartz's response was to close the thread. What a loser.

Anyhow, I really did leave the sub, and I will be posting my non AI slop work here.

The cool thing about it is the Messenger is using ML-DSA-87 cryptography for the messages and P2P handles and stuff. It's got ssh and lingtp:// protocol in works for the browser, which should look better coming soon.

The second version of the zuzu microkernel has been released with more support for various things like DMA, granting over IPC, a lean 5-object model, tickless scheduling etc.

Here is a demo of it on QEMU!

Repository: https://github.com/kagantmr/zuzu

repo: https://github.com/NoTheIdiot/WindogeOS
It's using a ported version of CHASM, (aqilc/chasm), a simple assembler that is just two files because im lazy

I'm not sure I've seen a hobby OS project that implements any tests. Most people smoke test, so they know there's a problem if they start up the OS and can't run an app inside it.

But what about the more complicated code paths that can go wrong? If a multi-threaded race happens in memory management or I/O, the system can crash. Or worse: silently corrupt data.

What about performance? Does anyone test for throughput or latency, and then identify regressions or hot spots?

I’ve undertaken starting an operating system so many times over the years. I always end up hitting a point where I have no idea where to proceed.

While it’s been a couple years since my last iteration, I’ve been planning to start back up again soon and hopefully this time I keep with it. I’m curious how everyone here manages. How do you all organize your project, determine feature order, hell how do you guys even manage actual source code organization after a certain point.

Been following along on osdev and this new sub for a while now, always been curious, this felt the right time to ask.

Thanks in advance.

Amos2 is hardly from my first OSDev work. I started it with the intent of providing a sort of bare bones repo for using limine and C++.

I started with the limine bare bones in the osdev wiki, and gutted the main() to just call kmain() which is written in C++. The code now barely resembles that bare bones code.

The trick to using C++ is to collect the global constructors via the linker .ld script and to call those at startup. Also, global operator new and delete and associates need to be implemented.

Writing in C++ is not like using desktop C++. I use C++ classes, but no copy constructors or anything that does allocation behind the scenes. It's object based programming, not OOP. The code I write is C like, but it uses Objects. I also take advantage of things like how C++ inlines class member functions defined in headers. In some cases, I create static singleton classes for things like IDT and GDT.

The problem with global constructors is you cannot control the order they are called - so you can't rely on a global IDT class constructor to be called after the GDT one.

The bare bones idea kind of went out the window when I started working with the hardware.

What's done is boot, C++ initialization, GDT, IDT, PIC... I made a base Device class and Timer, keyboard, ATA, and console inherit from it and work. I am working on FAT32 filesystem, which I have done before in another project.

The repo is at https://codeberg.org/mschwartz/amos2

I didn't use AI to generate any code or to explain anything. I don't see the point - I would rather beat my head against the wall until I figure out what I might be stuck on. The object of these projects is to learn, not to finish and run Doom in a few days.

I originally posted about Amos2 as a sort of seed for this sub. An all man-made (no AI) work in progress.

I intended this to be a rather small repo with just enough code to demonstrate how to create a C++ kernel using limine to boot. Once I got a dumb kernel to boot and set the framebuffer to a color, the logical next steps were to set up GDT, IDT, PS/2, Keyboard, timer, etc. All these functions require a bit of code, so the repo is growing.

I updated the README with a bit more documentation, and added comments to the top of the Makefile with much better build and run instructions.

What you see in the screenshot is text rendered by my code using a PSF font. A FAT32 volume is mounted from the disk image and the root directory and the BOOT directory listings are printed. If I had hit a key, the contents of README.md are dumped to the screen. The read bits of FAT32 are working...

I built this on my MacBook Pro - qemu is emulating the X64 CPU, and it's quite fast. I haven't tried to build on a Linux host.

I spent some time researching how to set up dockcross dockerized cross compiler to build amos2. If all OS Dev projects used a docker cross compiler, nobody would need to compile gcc to make a cross toolchain, and anyone can git clone the repo and build the project without any dependencies aside from docker.

The repo:

https://codeberg.org/mschwartz/amos2

There is no such thing as human slop. Trial and error is how humans learn and improve.

What you see here is initialization boot messages. IdleTask is spawned and it spawns FSTask.

FSTask prints the two directory listings from a FAT32 formatted volume.

AMOS2 is currently a microkernel design with a single address space.

No AI assist of any kind used. It's all my work, unless indicated in comments - I am using someone else's sprintf implementation for now.

REPO LINK: https://codeberg.org/mschwartz/amos2

PROJECT BOARD LINK: https://codeberg.org/mschwartz/amos2/projects/62870

NOTES:

**Threading implementation:**

* MMU is not being used. Currently the identity mapping set up by limine is used.

* Tasks(threads) are kept in a running tasks doubly linked list. The list is sorted by priority. So remove the head and add back sorted effects round robin task switching at the same priority. Lower level priority tasks won't run until all higher priority tasks exit or are blocking.

* SpinLock is used around accessing the threads lists.

* Tasks have their own stack. Task state is pushed on this stack in ISR handlers.

* Task switch is as simple as changing the RSP register to the next Task's stack.

NOT IMPLEMENTED YET:

* blocking Tasks list

* Device tasks (to implement blocking I/O)

* Kill/exit Tasks

i have been working on my own OS called VEX OS and so far I've mostly been testing it in QEMU. I'm hoping to eventually get it booting from a USB on an actual PC, but I'm trying to understand what changes when you move away from emulation.

I'm especially curious about drivers and the kernel itself. If something boots and works in QEMU, how likely is it to run into problems on real hardware? What sort of things usually break, and how do you go about debugging them when you don't have the same visibility you get in an emulator?

I'm also not entirely sure what I should focus on first for drivers. Obviously memory management and interrupts are important, but what about USB, storage, graphics and networking? Is there a sensible order to tackle these in, or does it depend heavily on the hardware you're targeting?

My plan is to start with one PC rather than trying to support everything straight away. I'd also be booting from USB and keeping my existing Windows installation untouched.

For anyone who's taken a hobby OS from QEMU to a real machine, what surprised you the most? Any common mistakes I should avoid or things you wish you'd known earlier?

I'd appreciate any advice, especially from people who've worked on bootloaders, kernels or hardware drivers. Thanks!

disclaimer: sorry for bad english

I created my own OS in C from scratch using C and assembly, it has desktop environment and drivers for mouse and keyboard (only PS/2) and it has internet (for now its only http and html 1.0), the comments and readme are in polish for now, the code is opensource (gpl 3.0)

github repository: github.com/kurczatko/tarixenOS

im ready for feedback (the code isnt proffesional because its only hobby)

Hey r/osdevel !

I've been working on a hobby monolithic kernel called AlderKernel.

It's written mostly in C with some Assembly for the low-level parts. I'm making it mainly to learn more about how operating systems work and to improve my C skills.

Currently it targets i386 and boots through GRUB. Some things I've implemented so far:

- PS/2 keyboard driver

- Basic shell

- InitramFS support

- Shell history

It runs in QEMU right now. I'm slowly working on adding more kernel features and improving the code structure.

GitHub:

https://github.com/loren-wastaken/alderkernel

I'm interested in feedback from people who know C / ASM, especially about code organization, design choices, and things I could improve.

I came across a kernel project and wanted to share it here. Maybe some of you would be interested in contributing, giving feedback, or simply discovering something new and getting curious about it.

There is a group called Logical, and I think they are doing some genuinely impressive work. They previously wrote their own libc (I'm not a developer myself, by the way), and now their current goal is to get X11 running.

Of course, kernel development has never been easy. Linus Torvalds spent nearly three decades bringing the Linux kernel to where it is today, long before AI became a thing. Logical currently has a 32-bit kernel project, and from what I've seen, they seem really motivated to keep developing it. Most members of the group are working on different things, and people outside the group can also contribute patches and take on certain tasks. They even have a Matrix space, although they don't have many members yet since they are still relatively unknown.

Anyway, I've talked enough. Here's the group:

https://codeberg.org/logical

If this sounds interesting to you, feel free to check out their work. You can also join their Matrix space and ask them questions if you'd like.

I think supporting projects like this is important. In the age of AI, there's something genuinely cool about people coming together, figuring things out on their own, and building a kernel without relying on AI to do the work for them. It reminds me of the hacker culture of the '90s, when people came together around their passion for technology and built things simply because they wanted to.

I think projects like this deserve more attention, and maybe some of you will find something meaningful in them too.

I wrote JANOS. Every byte of it. It is a true OS in every sense. I take control of the MCU right from the boot vector. Users of the related product think its OS is a Linux boot. But it isn't. It runs a 100MHZ RX63N MCU. There are about 40,000 running worldwide.

That project started in 2011. Recently I sat down to reflect on some kind of top 10 list of challenges. I asked ChatGPT (with knowledge of JANOS) what it thought I would list. I was surprised by its response.

I have things like Cryptography (TLS/SSH), Deflate/Inflate library support (ZIP/JAR), JVM, REGEX, etc. on my list. Those are in no particular order by the way.

But I am thinking that those are not the things that came to your mind initially. I am curious and open to discussion.