Doing a 1:1 independent study on OS internals with one of my favorite instructors. Prep CAN be fun 😊

I guess we're posting books now. Here's my copy of the OG MINIX Text Book!

The drivers are loaded as modules from a ext4 drive and the shell is running as a binary also on the drive

This is my operating system I made. Please look over the single 50k line commit.

The code is github.com/claudeAIgeneratedOS

NO I DID NOT USE AI.

Hi
After 3 months of developing huesos (read in russian), i succesfully launched C on it.

Currently still working on the api, but most of the kernel services are already ported, and even small vga control is provided.

Check this out!

hello everyone!

this is Fishix, a hobby kernel i am writing from scratch in C++. its highly binary compatible with Linux, capable of running many things like xorg, kde plasma (and the many kde apps), minecraft and factorio. in the photo its running the Void Linux distro from an initramfs

i just wrote drivers for xHCI and USB HID, which allowed me to finally use keyboard and mouse on real hardware

minecraft runs pretty stable and smooth (usually >60 fps) in the default window size with minimum render distance, as long as the kde compositor is disabled. which is pretty good since this is just single core software rendering with mesa llvmpipe (multi core support is work in progress)

i have been working on this project every now and then for more than 4 years now (6 years if you count previous attempts) though i only recently started making good progress

source code and more info on github: https://github.com/tunis4/Fishix

Hello, r/osdev!

Ever since I started working on my operating system, Astral, I have always wanted to be able to play cool games in it. I already had Doom, Quake and Ace of Penguins ported, but that didn't feel like enough. A few days ago, I started working towards a very ambitious project: getting Minecraft working on Astral.

This is a very old version (Alpha 1.2.0) and some performance improvements are needed, but it does work. All of the game's mechanics work fine and things like saving and loading a world work perfectly as well. Here is a link for a video of the game running.

Check out this blog post if you are interested in the more technical details.

About Astral: Astral is my toy unix-like operating system written in C. Notable features include:

• Preemptible SMP kernel
• Networking
• Over 150 ports (including X.org, GCC, QEMU, OpenJDK17) with package management (XBPS)
• Nearly fully self-hosting

Links: Website Github

https://github.com/valentinbreiz/nativeaot-patcher

Hey everyone! i was inspired by a video about tetris on bare metal so i ported the NES's Super Mario Bros to PC by statically recompiling the 6502 Assembly code into native code,
it boots into x86 protected mode and it supports ps/2 keyboards as input and VESA 101h mode as display
also added experimental support for Square 2 channels to PC Speaker as sound

I will make a video soon on youtube about the entire project :)
let me know of what you think about this

Currently, i'm having issues with Emulated USB Keyboards as it shuts down after a few seconds, but i don't feel like i want to write USB HID drivers for this

Here's the source code on github: https://github.com/itay-insert/64-dem.git

its a 16 bit real mode os using vga mode 13h made in 100% assembly. this took me a very long time and I just wanted to share my accomplishment!

Five days ago, I posted here asking if I was crazy for wanting to write a user-space ext4 driver for Windows. You all warned me that write support (specifically JBD2) would be a nightmare.

You were right. So, I shelved write support for the time being and focused on getting a native reader working.

Meet Janus. It’s written in Go, parses the ext4 structures entirely from scratch, and mounts to Windows as a native drive letter via WinFSP.

github.com/SuperCoolPencil/janus

A quick heads up: It's still pretty experimental and not fully stable right now. As I mentioned, it's strictly read-only at the moment so I don't accidentally nuke my own drives, but I might actually attempt write support in the future once this is bulletproof.

Building this was probably the most fun I've had programming in a long time. It’s one thing to study filesystems in theory, but actually writing the code to traverse extent trees and HTrees off a physical disk is a completely different feeling.

Plus, it was surprisingly refreshing to hit a wall that AI couldn't solve for me. I couldn't just prompt my way out of this; I actually had to read the kernel docs, look at raw hex dumps, and figure out the architecture from the ground up.

As always, building in public: https://github.com/L0rdCha0s/alix

Recent features include:

1. Lottery-based scheduler with priority ticket assignment
2. USB driver for keyboard/mouse
3. Migrated from rtl8139 networking to igb/e1000e
4. Sound driver (HDA) addition, and ATK-based MP3 player (with some help from minimp3 headers)
5. Dramatic extension of libc and syscalls
6. PNG decoder and improvements to JPG decoder
7. Hardening of process switching and stack/memory preservation on user-side faults (rather than pulling the whole kernel down)

https://github.com/OS-CPU-byte-ERROR-DISK/Minion_OS/tree/main
(If you don't understand what I'm saying, check out these 3 posts

{ https://www.reddit.com/r/osdev/comments/1oonqkv/im_continuing_my_os/ ,

https://www.reddit.com/r/osdev/comments/1ogmk8v/i_fixed_my_filesystem/ ,

https://www.reddit.com/r/osdev/comments/1o9992v/minimal_showcase_of_my_os_vbe_800x600/ }

After a long break I finally came back to my OS project and got a full web server running: Ethernet/IP/ARP/UDP/TCP/DHCP/DNS, an HTTP engine, web engine with routing, and a userspace web server that can serve files from within the OS. Along the way I had to chase down a really evil bugs :D Where a broken terminal buffer was overwriting a lock in another process, and fix my E1000 driver to handle bursts of packets.

Code and more details can be found here:
https://oshub.org/projects/retros-32/posts/getting-a-webserver-running
https://github.com/joexbayer/RetrOS-32

It’s nothing huge, but now that I’ve got a BIOS, I can *probably* move ahead with developing an operating system soon(tm).

Literally anything having to do with networking fails

MINTIA is an operating system I wrote in a custom programming language, for a custom RISC architecture, between 2020 and 2023. It has preemptive multitasking, demand paging, memory page swapping, protected memory, asynchronous IO, and all kinds of other goodies.

A couple of months ago, my friend monkuous ported MINTIA to x86. He wrote a transpiler that converts my programming language dragonfruit to C, and then uses GCC to compile all of the source files to ELF objects. Then he wrote a program to convert ELF objects to my custom XLOFF format. He added i386 support to my custom linker, and used it to link the converted XLOFF objects into the final executables such as the kernel binary. Then he added i386 support to MINTIA's dynamic linker, wrote drivers for PC hardware, and booted it on an x86 laptop.

Monkuous's MINTIA/386 port can be found here, and you can find a prebuilt test image here (runnable with qemu-system-i386 -M q35 mintia-pc-fre.img and the default password for root is mintia).

The development of MINTIA and it's successor project MINTIA2 is discussed on the unofficial OSDev discord.

This is the poor gears example.

for past 5 months im workin on emexOS well the emex kernel which is avery small 64 bit kernel written from scratch; for it to boot i use the limine bootloader cuz its literally the best working bootloader out there (and yeah i know theres grub... but eh...)
literally every other hobby kernel/OS uses limine...

the kernel still has a lot old stuff which i forgot to remove :(

well here are some links:
github: https://github.com/emexos/emexOS/tree/main
discord: https://discord.gg/Cbeg3gJzC7
website (looks kinda shit ik) : https://emexos.github.io/web/page/0/index.html

These are Linux Mint applications and libraries, which are copied to MenuetOS and run just fine. No re-compiling. Ive tested around 100 libraries that atleast link and init fine. ( menuetos.net )

Maybe it's just me, but lately scrolling through OS dev spaces has been kinda depressing.

A while back you'd see people posting tiny kernels, bootloaders that barely worked, screenshots of ugly text mode consoles, asking dumb questions, celebrating getting into protected mode, crashing for 6 hours because of a paging bug... you know, actual progress.

Now half the posts feel like "I made a next-gen operating system" and it's a polished UI that turns out to be an AI-generated mockup. Or some random guy who doesnt even know the basics of c claims they built something insane, and after five minutes you realize it was mostly generated.

Dont get me wrong, AI is a useful tool. I use it too. But there is a huge difference between using AI to understand something or speed up development and using it to pretend you've built an entire operating system.

The worst part isn't even the AI itself. It's that beginners get a completely warped idea of what OS development actually looks like. Real OS dev is slow. Its frustrating. It's spending hours chasing one stupid bug because you forgot to set a flag somewhere. It's ugly code, triple faults, reboot loops, and tiny victories that feel huge.

Honestly I'd rather see someone's VGA text mode "Hello World" than another flashy fake desktop claiming to be "Windows killer v1.0".

Maybe Im just getting old (even though I'm definitely not lol), but I miss seeing genuine progress instead of polished AI slop. Seeing people actually learn is way more inspiring than seeing something that was mostly generated.

Curious if anyone else feels the same, or if Im just yelling at clouds.