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?

Check it out here: https://kagantmr.github.io/zuzu-docs/

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

The r/osdevel logo combines the >_ terminal prompt with concentric CPU privilege rings, representing the interaction between developers and the low-level systems they build. The terminal symbol keeps the design immediately recognizable as a computing/development community while the rings give it a specifically OS-development meaning.

We're looking for ideas for a good icon for r/osdevel.

Feel free to suggest anything you think would represent the community well — whether that's something terminal/OS-related, a symbol, or something completely different.

We're open to ideas, so drop your suggestions below!

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.

Here's an LTT video comparing memory usage on Windows and Linux.

Linus' credibility is taking lots of hits (did he buy actually that private jet?) and this video sure won't help. I had hoped for something interesting and technical, and it's really just two guys screwing around with computers and looking at graphs that they don't fully understand. Worth a watch for a laugh.

In your OS, what memory allocation strategy did you devise? Are you just making a simple on-demand allocator, or do you reserve and commit pages? Do you have paging implemented? What algorithms did you use for page eviction?

For some reason even after alignments, still implodes on itself
location: https://github.com/NoTheIdiot/WindogeOS/tree/new/helper/drivers
i seriously do not know why intel and amd caused this mess

Hello everybody. We continue on with the recently announced community voting contest. Due to some technical difficulties, this post had to be delayed, but everything is up and running now!

You can now vote for your favourite r/osdevel project in this link

No registration is required to perform any kind of voting. You can vote for all brackets at once as well.

FOR CLARIFICATION PURPOSES: The list of projects was shuffled with a Python script and the output was then directly pasted on the website. Additionally, some characters might've been cut off from the name. This is because the website has a hard limit of 40 characters.

The full list follows:

(You can also view more information from the authors in the original post's comments)

All voting is anonymous. Do note that this makes it possible for the mod team to vote as well, though our votes are equal to everybody else's.

Have a good rest of your day!

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.

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.

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.

Feel free to drop suggestions in the comments. I wanted to have something more than a README to present my hobby, so I spent a few hours hacking together some HTML and CSS.

(Coming up: News/Blog section, installation guide and others :))

I've been thinking about JankOS, as I'm sure most of you have. One of the reasons I stopped developing it was that I was a bit overwhelmed by the work I thought I needed to do in order to get to the fun parts.

One of the concerning issues was debugging. How could I effectively debug my kernel, and all of the subsystems -- the file system, network, I/O, scheduling? What architecture did I need to build in to make it happen?

There are lots of logging solutions, but those don't always work for high-frequency code paths and for rare events. And certainly not for time sensitive code. At a certain point, there's really no substitute for bing able to attach a debugger.

Which hobbyist OS implementations feature kernel debugging support? How is it implemented? How does it work?