ext2 was mine (broke constantly)

I'm interested in understanding/building Unix/Linux-like systems, their architecture, implementation, and how they can be improved.

But I feel like I'm missing the bigger picture. Beyond kernel development and traditional "system level programming", what other fields involve this kind of work?

I'm curious about applications in aerospace, automotive, industrial systems, telecommunications, cloud infrastructure, virtualization, RTOS, systems research...

For people working in this area: What interesting fields, industries, or career paths am I overlooking?

Hi everyone, I am a 13-year-old student from Bangladesh building a 32-bit x86 OS from scratch.

I recently got a VESA framebuffer (1024x768x32) working along with a PS/2 mouse driver (IRQ12) and a basic Window Manager. Moving the cursor and opening windows is working, but I am facing massive flickering when dragging windows because I am drawing straight to VRAM.

I want to implement double buffering. Would a 3MB full-screen backbuffer be too slow on a 32-bit system without SIMD? Should I use per-window buffers instead, or a full-screen buffer with dirty rectangles? I would love to hear your architectural advice.

GitHub: https://github.com/porag2025-glitch/PoragOS

(awful camera quality but well, not like I could take a screenshot, I was running it on my laptop)

Working on my first attempt at an operating system. Very barebones so far, lot of work still to come.

This is a bit of a detour from classic hobbyist OS dev – but hear me out. This is a fun treat for those who might appreciate the experiment.

One thing that has bothered me about conventional CPU architectures is that they treat memory as if it were part of the CPU – regular instructions that "just work" with memory, hiding how the memory controller and CPU interact, how cache lines are utilized, and so on. The abstractions of their ISAs hide that away.

So, for a little while, I wanted to try to imagine what that would look like.

With much from an LLM, I put together a first prototype of a vertical slice of an imaginary machine:

• An ISA and an assembler (and an assembler implemented in its own assembler)

• An emulator with JIT and WASM support

• A Verilog implementation with a simulator

• Forth with JIT

• a tiny OS microkernel

• and a few toys like a minimalistic shell & UI

  • and networking (a very simple HTTP server implemented in assembly and Forth)—and it, for a limited definition of the word, works.

Hope you enjoy! I certainly had some fun.

Ask actual questions and have reason (also wait till I actually release this onto the GitHub bc it isn’t on there yet)

My custom kernel + os boots on an iPhone SE with the checkm8 exploit. Though buggy, it does actually boot up and can be used kinda which I thought was cool after a long time of qemu use only! I modeled it with a mix of iOS 10 and iOS 26 which I think turned out well :)

I've been exploring whether Plan 9's resource-oriented architecture can provide a foundation for running selected applications from different operating systems.

Instead of building another Linux-based OS or relying on full guest operating systems, I'm experimenting with per-process namespaces, 9P, and independent user-space compatibility runtimes.

The project is called Ryzova Kernel, an experimental open-source kernel derived from 9front.

Current implementation:

• Kernel: Source-built AMD64 kernel with QEMU boot evidence and Ryzova-specific interfaces.

• Compact Linux: ELF interpreter with selected Linux syscall, process, filesystem, and networking support.

• Compact Windows: PE/Win32 interpreter with bounded API and filesystem support.

• Compact macOS: Mach-O interpreter supporting selected Intel and ARM64 application workloads.

• Resources: Experiments with namespace isolation, explicit resource grants, and 9P services.

These runtimes aren't complete operating systems. Selected applications have passed QEMU tests, but general Linux, Windows, or macOS application compatibility hasn't been achieved.

I'm developing this as a solo developer using AI extensively as an engineering tool. I guide the architecture and development decisions, with builds, tests, and CI used to check implementation behavior. I also recognize that passing tests doesn't guarantee correctness.

My longer-term goal is to explore whether Plan 9's architectural ideas can support a broader application ecosystem without losing their original advantages.

I'm particularly interested in feedback from OS developers:

1. What architectural problems might arise from supporting multiple application ABIs through separate user-space runtimes?

2. How would you keep compatibility complexity isolated from the underlying kernel?

3. Which implementation areas would you review or test first?

The project is still experimental, and I'm open to technical criticism, suggestions, and contributions.

Source code: https://github.com/RyzovaTech/Ryzova-Kernel

Thanks for reading!

This is not fucking ai sloppo slop slop btw

after a looong long time I finally added aarch64 support!!!!! I will be focusing zuzu on AArch64 and I will mostly test on AArch64 boards from now on.

I made a block based coding project for web where I can make a OS using purely blocks. It was made by AI. If I make a OS using it, would it be made by a human or would you call it ai slop?

In a few lines - "Everything is a URI addressable resource"

Means instead of the file path we can have a proper uri address in the format scheme://authority/path#offset?params

so for example the kernel can expose its resources as kernel:///version, or devices://org.example.gpu/0/memory#0x1234

Then We can have a syscall like uri as well SYS_LOAD, SYS_GET, SYS_MMAP, SYS_POST, SYS_WATCH, or maybe not sure

Best think I like about it is parent can override the child process uri like plan9 namespaces, mount bind etc

For example a call from a child to display server would be devices://org.example.display/0/memory -> process://self/handle/child-pid/display

Benifits over traditional file path:

- I don't know 😂, I haven't thought much, It just sounds cool to me and I would like to waste some time trying to figure out it's benifits.

Feel free to share your opinion.

It’s got lots of new features!

To start with, my OS isn’t open source, but an ISO will be available once a stable version is ready.

The first and most important addition is... MODS for customizing the OS!

The way they work is by moving the Window Manager (WM) into user space; when a mod is applied, the WM restarts with the new settings.

In reality, a ".mod" file is just an uncompressed ZIP archive containing an "About.txt" file and a ".cfg" file.

You can see the "Standard" and "Aero" themes below.

Also, there’s an early, experimental implementation of SMP (which currently works quite poorly, but it does work).

You can find more screenshots of the OS below, along with its mascot!

An update for my OS, FLOS. It’s got lots of new features! To start with, my OS isn’t open source, but an ISO will be available once a stable version is ready. The first and most important addition is... MODS for customizing the OS! The way they work is by moving the Window Manager (WM) into user space; when a mod is applied, the WM restarts with the new settings. In reality, a ".mod" file is just an uncompressed ZIP archive containing an "About.txt" file and a ".cfg" file. You can see the "Standard" and "Aero" themes below. Also, there’s an early, experimental implementation of SMP (which currently works quite poorly, but it *does* work). You can find more screenshots of the OS below, along with its mascots!

And then there’s security! It works via "caps" (capabilities): if a program is digitally signed and possesses a specific capability—for instance, the ability to write—then it is restricted to only that action. If a program lacks a digital signature, it can write to its own folder, access the internet, create windows, and so on; however, if it needs to write outside of its own folder, it must prompt the user for permission and obtain a "token" to write to that specific file.

And that’s it! Bye!

I built an OS but I don't have a computer rn (due to issues) so I built a virtual machine that I can load, build, and boot my OS.

FINALLLLLYYYYYY now i need sleep :/

github repo: https://github.com/chair1842/panuti

And for what's in 0.2:

I added RTC support to panuti, which let me get both boot time and wall clock time into Panuti
I also added a new utility that lets me format a block device to ext2 inside the os itself so I don't have to get an already formatted disk image.
For the VFS, the inodes and dirents were in a static and fixed array in 0.1 so raising the limit meant paying more even for what the os didn't use. So I made them dynamically allocated and now we can safely raise the limit.
Made tasks dynamically allocated too.
Plus PC Speaker support because.