There is a whole usenet that exists (comp.os.misc and alt.os.development) and you can get free usenet access with Eternal September, we should revive it.

Hi Everyone, I recently made a 32-Bit OS, But idk how to progress forward

I made it as a hobby project since i wanted to do it since i was 7 (14 now)
I Have a kernel, a terminal, But i dont know what else to add
Thanks

Wine! Yes it runs Windows programs (not a lot due to my incompatibilities but still).

This was a painful port to get working. Wine is so unfathomably big - I had to patch the shit out of my kernel's signalling routines to add support for sigaltstack/ucontext/whatever else Wine threw at me (along with SCM_RIGHTS which wasn't that bad). Debugging it was a nightmare of mmap/VM fault issues. But it works!

Wine is running here off of an X11 translator for Celestial known as xbanan made by my good friend u/Bananymous (please see his operating system banan-os for some even cooler ports like WebKitGTK). xbanan can even be ported to your OS if you didn't go with a backend like X11 or Wayland.

On another note, it truly is a joy seeing Wine running in my silly custom compositor environment with the rest of my silly userspace.

The GitHub is here (the patches I have made are coming soon after they get a massive cleanup to be proper):

https://github.com/sasdallas/Ethereal

As always, this is NOT A LINUX BASED PROJECT, nor is it vibecoded. AI policy is in the README. Happy to answer questions.

Because I don't want to change a given part of the code all the time, I often focus on a specific segment for quite a long time to make it solid, but then after a few months or a few years I won't be able to use it.Problems because the most important thing for me is to work on the USB driver and hardware development for the next months/years, as well as further development for a real computer. https://github.com/CTRL-F-0rg3/TrangorgeOS/blob/main/kernel%2Fsrc%2Fcpu%2Fshelduler%2Fentities%2Ftask.rs

Happy Labor Day to those in the USA.

last week I did a test to make sure my fledgling kernel still runs on VirtualBox:

It did, and I learned one thing that I didn't see in QEMU. If you notice line 4 of my pmmap (physical memory map) I have a new type of memory Type 3. This is a type of memory that is reserved, but is available AFTER you've processed your multiboot info, and hopefully saved it someplace else. This google search listed all the memory types for me "multiboot 2 physical memory map memory types"

The second thing I learned is that the memory map you get from multiboot2 can have overlapping memory ranges, this is kind of important to know.

Finally, I got my physical memory manager tested, and it seems to work. I am currently working on my Virtual Memory Manager. Once I get it working, I will publish my code on github. Hopefully by the end of the week.

As always, I hope this helps some newbie sometime in the future

Hi everyone,

I have created a small online group for people who want to understand computers by building operating systems from scratch. I want people to share the joy and passion for building an OS.

I humbly invite you to come join the group and share your experiences, learning and also help and interact with others.

Here is the link to the group: https://groups.google.com/g/nijnaam-operating-system-group

P.S. I want to experiment by creating a group. I strongly believe that a culture is what that separates everything.

Thank you.

Hey everyone,

​I’ve been thinking about this idea for a bit and wanted to throw it out here to see what you guys think.

​To be clear off the bat: my issue with Windows isn't its file system structure. Windows' biggest problems come from the corporation behind it—bloatware, forced telemetry, ads in the Start menu, and deciding your hardware is "obsolete" whenever they feel like it. The actual file layout (C:\, Program Files, Users) is just something millions of people are already used to.

​So, purely as an architectural thought experiment (or a fun custom OS project): what if we took the Linux kernel and built a user-space around a Windows-inspired directory hierarchy, but kept it completely open-source and bloat-free?

​I’m not talking about patching the Linux kernel to rewrite VFS or force backslashes—we can stick to forward slashes / so we don't break parsers for no reason. Instead of sticking to the traditional FHS (/usr, /var, /etc), what if the root looked something like this:

• ​C:/ (mapped/symlinked to root)

• ​C:/Linux/kernel32/ (for system libraries like libc.so, replacing /lib64)

• ​C:/Linux/System/ (for core binaries, replacing /bin and /sbin)

• ​C:/Program Files/ (where apps like Firefox or KDE live in their own self-contained folders)

• ​C:/Users/username/ (home directory)

​Obviously, throwing pre-compiled Ubuntu .deb packages at this would completely choke because every binary expects hardcoded POSIX paths like /usr/bin. But if you built a toolchain (using Buildroot or Yocto) to set a custom ELF dynamic linker path (ld-linux.so) pointing to C:/Linux/kernel32/, compiled glibc, and pointed your RPATH configs there, you could compile native Linux software to run directly inside this layout.

​Kinda like what GoboLinux did with /Programs/, but borrowing the C:/ layout so Windows refugees feel right at home without dealing with Microsoft's corporate garbage under the hood.

​Would this be a massive pain to compile and maintain for thousands of packages? Absolutely. But technically speaking, as long as the user-space and toolchain agree on where binaries and shared objects live, the kernel wouldn't care at all.

​Has anyone messed around with custom FHS alternatives like this before? How hard of a wall would you hit when patching build scripts for complex packages like Firefox or KDE?

Hello,

I am currently actively developing the “Dragon” microkernel. However, what sets it apart from Linux and other kernels is, of course, its microkernel architecture, and secondly, the fact that it is written and verified using SPARK Ada (gnatprove).

But that doesn’t mean kernel services have to be written in SPARK Ada; I’m already close to finishing a C SDK so that anyone can write a service. The only downside is that this service isn’t the most secure compared to a gnatprove-verified kernel, but the microkernel architecture makes up for it.

I think the main reason I'm developing this microkernel is to create a proven kernel that can be used in some way on user machines, not just on high-security systems.

Dragon is currently in a very early stage of development (I released the MVP yesterday and fixed two bugs)

If you like the idea, here’s the GitHub link: github.com/tigerlang/dragon

I built a Linux distro that does almost nothing

I wanted to see how little userspace I could get away with while still having a real, bootable Linux system. So I made FastFetchLinux.

It uses a custom BIOS bootloader, Linux 6.6.156, and my own ffinit written in x86 assembly.

The userspace has:

• No BusyBox
• No coreutils
• No bash/sh
• No package manager
• Direct syscall-based functionality
• i686 support
• ~20 MiB RAM usage

ffinit runs as PID 1 and doubles as the shell, with all commands built in. Fastfetch is the only separate userspace binary.

BIOS
 ↓
Custom bootloader
 ↓
Linux 6.6.156
 ↓
ffinit
 ↓
Fastfetch

It has exactly five commands:

fastfetch
ls
install-disk
forcepanic
poweroff

There's no practical reason for any of this — I just wanted to see how far "just enough userspace to boot Linux" could be pushed. The funny part is that it actually works.

Source: https://github.com/outofsyncsh/fastfetchlinux

Curious what people here would strip out or change to shrink it further.

My threading model has one kernel stack per CPU core, each process has its own CR3/page table in its process struct, then it is spawned with just one thread (TID 0 under its PID), a TID is just a thread ID, from there each Thread gets its own timeslice and would run like so:
- Process 1 runs thread 0
- Process 2 runs thread 0
- Process N runs thread 0
- Process 1 runs thread 1
- Process 2 runs thread 1
- Process N runs thread 1

And so on (it will loop back to thread 0 if the last thread in a process is ran). I just wondered if the design was actually decent or not. Of course a simple Round Robin setup is not perfect for things like this and some extra complexity does end up in the kernel, but overall I like it so far, though I dont see many obvious flaws other than the fact that tasks are not "ranked" for how much of a timeslice they get.

Going to preempt this by saying I used a lot of AI for rapid iteration, but mostly sharing this for the conceptual exploration of it.

I wanted to try a hypothesis. Usually clustering computers for high thoroughput operations is impractical due to several reasons. Some of which firmware bound, and some hardware bound.

With OuroborOS I am trying to answer the question: Can I wire together several machines over a custom ethernet protocol or through other cables (even considering using an HDMI for raw data streaming with a custom collector PCB in between) in such a way that the master node can view the peripheral nodes as part of its own system.

Just curious what people think about this

https://github.com/Randozart/OuroborOS

I am working on upgrading my kernel initialization messages so I can just have a nice view of what it is doing when initializing. I am using my print functions to do this, but the issue is that my print functions depend on the memory manager to be done initializing, but I want debugging messages when initializing the memory manager too, which I can't do because of the circular dependency.

This is my specific case, but I also want to ask generally, do you guys have an elegant solution for this problem? Up to this point I have been using init flags so that the subsystems can use a different path that does not create dependencies during initialization, but I want to hear any cool solutions from the community that are better designed than this.

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.

Should i make a custom way of rendering text lile flanterm for limine, cuz i dont like having the 8x16, using their ANSCI or whatever it's called, i dont know what to do with my kernel either way i have a shit load of free time

Can aanyone help me figure out how i can make my flanterm with limine properly render a 16x32 file from a font.o file, i cant not use 8x16 becausse the size of tet would be too tiny :(

That's my operating system built from absolutely scratch without 3rd party library, AI or anything else. It is written in Assembly and C(Bootloader for BIOS 100% Assembly). I wrote it in 6 months. Well, it doesn't have functionalities yet, but still in development. I wrote keyboard,VGA driver and First-fit MAlloc/CAlloc. It is my first project ever, i gained c and assembly knowledge here. It wasn't university homework, just raw curiosity.

Built from scratch in x86 assembly and C, the OS core uses no paging, runs on a single core, and has no third-party libraries. ~8,000 lines of code compile in ~2s into a 100 KiB boot image (icons included, LZ4-compressed onto the medium), and it boots on actual BIOS hardware - floppy or CD. Doom and the other applications are separate loadable programs.

Edit:
I was building this for a while, and wanted to share with the rest, and there is a lot to share.
I wanted to answer techincal questions and was really looking forward to.

Toxicity of those who commented (first four comments at least) is a confirmation and a reminder for me and I believe for the others to minimize such desire. Such people while living in dissaray and in hate, prove to deserve to be there, nothing more. For the rest of you, enjoy.

Links:
Try it in the browser:
https://branchpredict.com/post-play-doom-on-a-100-kib-os

Raam is an x86-64 Unix-like operating system for my HP Pavilion Laptop 15 machine. I am writing it completely from scratch using FASM assembly.

Source tree: https://github.com/robstat7/Raam

Raam Raam Ji 🙏🙏🙏 (greeting with God's name)

I'm developing a very simple Kernel with some goals, namely: being beginner-friendly and developer-friendly.

What’s already done:

• Bootloader: Limine for support of ready-made headers
  
• Basic video framebuffer support with some graphic tools
  
• Partial SMBios support, with Qemu tools to create a custom SMBios
  
• RAM support not complete: PMM working, VMM not working, raw RAM working
  

Future goals:

• Working RAM
  
• PCIE controls and GPU command
  
• Elf loader
  
• Scheduler
  

Please help me, I don't know what to do. If it helps, I use Arch with x86_64-elf-gcc compiled via yay.

Here’s GitHub: https://github.com/Alessio-Valluzzi/Trikernel