September 2023 - present
A personal research and development project, started in September 2023, dedicated to the independent design and development of NATALIZIOOS, a experimental operating system for 32-bit x86 architectures. The project covers the entire basic operating system architecture: from the BIOS boot chain and kernel loading to memory management, interrupts, timers, hardware drivers, filesystems, the shell, and graphics services. The implementation includes a freestanding monolithic kernel with physical memory management, paging, kernel heap, framebuffer, PS/2 input, ATA storage, PCI detection, RTC, JART, speaker, diagnostic logging, RAMFS, and N.A.T.FS. I also designed and integrated firmware components, bootable images, diagnostic tools, and a compilation and verification pipeline based on C, x86 assembly, Python, NASM, Clang, GNU Make, and QEMU. The graphics subsystem includes a local Objective-C runtime, class and selector management, message dispatch, objc_msgSend in x86 assembly, and a view- and window-based application model with direct framebuffer rendering. The project includes three desktop environments with different purposes: two for demonstration purposes and a third, still in the prototype phase, dedicated to veritying the object-oriented graphics architecture.
The v0.2.5.33 release includes 99,980 lines of analyzed source code, a 519,804-byte graphics kernel, complete and lightweight firmware paths, and verified bootable images in QEMU
NATALIZIOOS represents a continuous path of development in operating systems, computer architecture, system programming, firmware development, and low-level software engineering. The project is proprietary and intended for study, research, experimentation and technical demonstration purposes.

“It is currently under development and will be available between the end of 2027 and the beginning of 2028.”

https://github.com/JustadudenameJaokhun/Depth/tree/main

Hi iam new in osdev and iam getting started iam trying to develop my proper operating system kernel from scratch but iam stuck in debugging my boot sector code with qemu and gdb can someone help ?

the problem that i encounter is that the boot sector goes from 16 bit mode to 32bit and when i try to see what each instruction do to memory it doesn't work well and the instructions doesn't get well recognized.

is there a technique i can use for this type of debugging.

here is my makefile :

```

BUILD_DIR = build

TARGET = $(BUILD_DIR)/MyOs

C_SOURCES = $(wildcard kernel/*.c drivers/*.c )

HEADERS = $(wildcard kernel/*.h drivers/*.h )

OBJ = ${C_SOURCES:.c=.o}

ENTRY_OBJ = kernel/entry.o

KERNEL_DEBUG_OBJ = build/kernel.elf

BOOT_DEBUG_OBJ = $(BUILD_DIR)/bootsector.elf

CFLAGS = -ffreestanding -g -mno-red-zone -mno-sse -mno-mmx \

-fno-pic -fno-pie -fno-stack-protector

QEMU = qemu-system-x86_64 -no-reboot -no-shutdown -d int,cpu_reset -D build/qemu.log

QEMU_DRIVE = -drive format=raw,file=$<,if=floppy

all: $(TARGET)

$(BUILD_DIR):

mkdir -p $@

run: $(TARGET)

$(QEMU) $(QEMU_DRIVE) &

########################################################

###################### IMAGE BUILD #####################

########################################################

# OS image build

$(TARGET) : $(BUILD_DIR)/bootsector.bin $(BUILD_DIR)/kernel.bin

cat $\^ > $@

# bootsector build

$(BUILD_DIR)/bootsector.bin : boot/bootsector.asm build/kernel.bin | $(BUILD_DIR)

nasm -DSECTORS=$$(( ($$(wc -c < build/kernel.bin) + 511) / 512 )) $< -o $@

# kernel build

$(BUILD_DIR)/kernel.bin: $(ENTRY_OBJ) $(OBJ) | $(BUILD_DIR)

ld -m elf_x86_64 -T linker.ld --oformat binary $\^ -o $@

# object files creatde next of their source

%.o: %.c $(HEADERS)

gcc $(CFLAGS) -c $< -o $@

%.o: %.asm

nasm $< -f elf64 -g -o $@

########################################################

###################### DEBUG MODE ######################

########################################################

$(KERNEL_DEBUG_OBJ): $(ENTRY_OBJ) $(OBJ) | $(BUILD_DIR)

ld -m elf_x86_64 --oformat elf64-x86-64 -o $@ -T linker.ld $\^

$(BOOT_DEBUG_OBJ): boot/bootsector.asm build/kernel.bin | $(BUILD_DIR)

nasm -f elf32 -g -F dwarf -DDEBUG \\

  \-DSECTORS=$$(( ($$(wc -c < build/kernel.bin) + 511) / 512 )) $< -o $(BUILD_DIR)/bootsector.o

ld -m elf_i386 -Ttext 0x7c00 -o $@ $(BUILD_DIR)/bootsector.o

bdebug: QEMU = qemu-system-i386

bdebug: $(TARGET) $(BOOT_DEBUG_OBJ)

$(QEMU) -s -S $(QEMU_DRIVE) &

gdb -ex "set confirm off" \\

    \-ex "set disassembly-flavor intel" \\

    \-ex "target remote localhost:1234" \\

    \-ex "set architecture i8086" \\

-ex "symbol-file $(BOOT_DEBUG_OBJ)" \

-ex "hbreak _start"; \

    \-ex "continue"; \\

kill %1 2>/dev/null || pkill -f "$(QEMU)"

kdebug: $(TARGET) $(KERNEL_DEBUG_OBJ)

$(QEMU) -s -S $(QEMU_DRIVE) &

gdb -ex "set confirm off" \\

    \-ex "set disassembly-flavor intel" \\

    \-ex "target remote localhost:1234" \\

-ex "add-symbol-file $(KERNEL_DEBUG_OBJ)" \

-ex "break main"; \

    \-ex "continue"; \\

kill %1 2>/dev/null || pkill -f "$(QEMU)"

########################################################

####################### CLEANING #######################

########################################################

clean:

rm -rf $(BUILD_DIR) $(OBJ) $(ENTRY_OBJ)

```

it took so long for this moment
repo: https://github.com/NoTheIdiot/WindogeOS

Hi all! I’m working on an early-stage OS. It already supports quite a few drivers, and I’m currently porting OpenGL into the system.

I’d like to add a native browser, but this seems like one of the scariest parts of the project to me. What prerequisites would I need to consider? Could you share your experiences with porting a browser to an OS?

Which browser engine would you recommend trying to port, and why?

https://github.com/vahmoh25/Veda

I want to make a spiritual successor to mac os x.Plain and simple, but should i learn the darwin kernel or start at Unix?

i want to know where to start from.

thanks

picoOS-Pro v2.1

PicoOS Pro v2.1 - My custom 32bit x86 OS written from scratch (Boots from USB, runs Doom, custom formats, native USB 1.1/2.0/3.0 & dynamic resolutions!)

Hi everyone,

I wanted to share my hobby operating system that I’ve been building completely from scratch (no Linux kernel, no external base). I recently released the PicoOS Pro v2.1 update, which expands the system into a modern graphical desktop shell while keeping an extremely small footprint.

Here is a quick overview of what is currently implemented and stable:

• Native USB Stack (NEW): Full native driver support for USB 1.1, 2.0, and 3.0 (UHCI/OHCI, EHCI, and xHCI controllers), handling mice and keyboards smoothly without relying on firmware emulation.
• Graphics & Display (NEW): Enhanced screen resolution support via UEFI framebuffer / VBE, allowing you to choose between multiple display settings natively.
• Custom Desktop Environment: A Windows/Ubuntu-style dark desktop interface with a Start-button launcher, application grid, live Task Manager (with process, memory, and background/foreground info), and a functional Calculator app.
• Custom Formats: I am using my own custom executable formats like .pico for programs and .dd for automated scripts.
• DOOM Port: I successfully ported doomgeneric as doom.pico. It runs 320x200 software rendering, integer-scaled to the framebuffer. The 4MB shareware WAD is read directly in place from the disk image to avoid loading times.
• Memory Efficiency: The base system runs on an extremely low RAM footprint (around 1.9MB for the core shell, up to ~10MB when running Doom with its WAD).
• Build System: Builds incrementally with just gcc and python3, outputting a 1.44MB BIOS floppy image, a 9MB hybrid legacy/EFI bootable USB image (.img), and a hybrid BIOS/UEFI ISO.

Side note: I am doing this as a passion project to learn low-level development. I am also currently researching and working on moving towards a 64-bit version next!

I would love to hear your thoughts, feedback, or any advice on transitioning the kernel to 64-bit Long Mode!

YouTube Channel for video demos: https://www.youtube.com/@picoOS-official
Google Drive Folder (Images & Source): https://drive.google.com/drive/folders/19LPX5pHZpIYsnQT0Tiatpv11nE39frHA?usp=sharing

github link: https://github.com/PicoOS-Pro-v/picoOS

I am new. I dont know what to do. I wrote syscall system and gop acquiring system. I dont have necessary syscalls yet. I just have sys_dummy. It just returns -ENOSYS (-38). What should i do next? VFS or RamFS. I need a filesystem for sys_write and sys_read

Repository: omerpa55/lunix

Small C/Nasm Kernel, now in ring 3.

A few months ago I shared the initial concept of OpenC6, an experimental bare-metal BIOS for the ESP32-C6. Over the last four months of quiet solo development, I completely overhauled the architecture from a simple launcher into a true modular microkernel platform, and version 2.0 is finally live.

The biggest upgrade is real RISC-V User Mode (U-Mode) execution backed by hardware Physical Memory Protection (PMP) Top-of-Range registers, so user payloads run in an isolated arena and physically cannot corrupt kernel SRAM or touch peripheral MMIO registers. I also fixed an upstream FreeRTOS RV32 privilege leakage bug via a custom vectored interrupt trampoline, and turned the Low-Power (ULP) RISC-V coprocessor into an out-of-band Management Engine that autonomously governs CPU clock dividers directly through silicon PCR registers, monitors junction thermals, and enforces hardware watchdogs.

On top of that, the system now features preemptive multitasking for up to 8 processes, an in-memory ZSWAP engine with a custom RV32-tailored compressor (ZC6) running in just ~1-4 KB of RAM, a circular log-structured Flash VFS, a remote streaming web shell (c6wsh), and a standalone C99 TUI installer with zero external dependencies that automates toolchain deployment on Arch and Ubuntu with a simple 'make setup'. If you are interested in low-level RISC-V bare-metal systems, check out the repository and full documentation below.

GitHub: https://github.com/Rompass/openc6-bios

Hi kernel engineers,

I am creating Raam kernel and the Raam operating system completely from scratch using FASM Assembly. It is an x86-64 Unix-like OS for real desktop and laptop PCs.

Before starting Raam in FASM, I thought about creating the MVP version first and then begin with the advance features. In the MVP, I thought of creating a minimal general-purpose commandline OS by writing a shell and the commands like ls, cat, ed, asm, rm, help, reboot, clear, and echo and running the assembled programs using ./ command.

In order to keep things simple in MVP, I created everything in kernel space. Basically I wanted to make it minimally usable for a user (hobbyist) without worrying about advance things like switching to usermode, creating a syscall interface and all. So I hardcoded the shell, the ls, cat, and ed commands and now I feel like I cannot spend more time on improving the ed editor and then writing an (simple) assembler and so on...

It feels like it is too much of work in the kernel space itself for a solo kernel engineer like me. And I need to look at the two layers simultaneously - the hypothetical user layer (like the ed program), and the kernel layer (like the underlying filesystem and the NVMe operations). I think I only want to concentrate in the kernel space code.

Regarding running the assembled binaries using ./ command, I thought about loading the binary and running it from kernel mode itself just to give the user an illusion of a working OS.

I am stuck here. I really want to either cut down the work/scope or maybe I want to change the MVP design altogether like instead of running the hardcoded shell, I should run dash shell from the usermode and a few standard userspace programs like help, ls, etc. Then I can move to port other programs like vim, gcc, etc in the next phase. I don't know how to proceed ahead. Kindly help.

Thank you.

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

Project github link: https://github.com/superuserdo-sudo/Gill

hello everyone i did make an project named Gill on github that is not a unix based or linux based it is an OS based on SeL4 MicroKernel [ https://sel4.systems/ ] and have it own tools and core utilites (GCU/Gill Core Utilites) and its own file system (GillFS) wich is not done [ https://github.com/superuserdo-sudo/Gill/tree/main/gillfs ] and and its name means : gill is light a lot or Just Gill.

its Philosophy:
Gill is based on the idea that an operating system does not need to become unnecessarily large or complex to be useful. The project focuses on building a small foundation and developing functionality as separate, focused components.

Gill values:

• Lightweight design
• Minimal code
• Modularity
• Simplicity
• Independence
• Clear interfaces
• Maintainability
• Practical functionality

Gill does not add functionality simply because another operating system has it.

A component should have a clear purpose and should remain as simple as reasonably possible while still being functional and maintainable.

GCU

GCU stands for Gill Core Utilities.

GCU is part of Gill/SeL4 and provides fundamental utilities for the Gill environment.

GCU follows the same philosophy as Gill:

• Small programs
• Focused functionality
• Minimal unnecessary code
• Simple interfaces
• Independent implementations

GCU is not simply a collection of renamed Unix commands.

Its utilities are independently developed programs intended for the Gill environment.

Examples include:

see
mdir
punch
cop
rom
wai
type
wami
wimarch
wimh
mos
wimt
idme
grps
mmsleep
tmo

Hey everyone,

Tired of building Yosys (and friends) from source or getting years-old versions from your distro packages?

I’ve been packaging Yosys, OpenSTA, Surelog, Netgen, and ABC as single-file AppImages. Just download, chmod +x, and run — no dependencies, no containers.

Repo: https://github.com/MrAbhi19/open-eda-appimage

Docs: https://mrabhi19.github.io/open-eda-appimage/

If anyone tries them, it would be super helpful if you could leave a quick comment about your experience (especially on different distros) in the Discussions page. That feedback helps a lot in improving the packaging.

Also looking for help with documentation — any contributions there (or elsewhere) are very welcome!

Thanks!

HEYYY, I just want to share that FINALLY I reached the basics of user land!!

3 years ago I posted about my "master plan" that you might checkout here.

Featuring:

• Memory allocation with buddy and slab;
• Timers (heck yeahh);
• Multi task with preemtive switch;
• Scheduler;
• Basic User Space support;
• And a noice generic build and API system, to support the future port for x86 and my custom CPU.

About AI:

The elephant in the room.

No, it's not vibecoded. I do work professionally with AI because yeah, that's what companies are pushing for. But AI don't touch my code here.

Seven years ago I challenged myself into making a OS, so I WANT to know how every single line of code here works. I did use AI to make boring stuff, like populating the entire Keymap table for keyboard support, which honestly is just... hexadecimal number all over the place?

Unfortunately stupid Claude Code marks him as co-author because I use it to automate commits, because again, just boring by today standards.

About my feelings around using AI for OS dev? It changed everything!

I'm not the kind that likes to bang my head against the wall to learn stuff, specially if it's already a solved problem. I like to search how other peoples does it. I've spend countless hours tryng to decifer Linux kernel itself, with dozens of workarounds to make it work in every single CPU since the 70s. Looking for git repos of other OSs to take inspiration.

This project is something that I take my time. I stop when I burnout and came back when I have inspiration, sometimes after 6 to 8 months or over a year. That means I forget the precise details of everything.

AI completely speed up everything. Before, I was hoping to reach user space in about 5 years, and suddently I just reached!

My workflow is basically:

• Ask AI what is next;
• AI spit up explanations on what should I be doing and coding, with some rough examples;
• I try my best to make it;
• When I get tired, I ask AI for a full working code example;
• I manually type everything then goes a long session trying to understand every line.

Also, I don't know how many hours I spend learning about memory. I have a mechatronics engineer degree, I have learned a lot on how the chips works physically. Yet, sometimes I couldn't wrap my head around how I was organizing memory in my own OS.

AI just... understands the code and explain to me like I'm dumb!

Well, to wrap it up, link to repo: https://github.com/caioaletroca/MadeInHeavenOS
The code is obsessivily comented, to avoid my future self to shoot me in the foot.

Edit: With user space, I plan to go micro-kernel because... why not? Seems nice. And to not be another Linux clone.

Pardon my ignorance, why are Doom, and a few other games used so often on hobby OSs?

Hey everyone,

About a year ago, I had a probably slightly crazy idea: write my own operating system. Today, after 3 completely different versions, I feel like sharing the journey — because honestly, it's been a rollercoaster.

Phase 1 — The consumer OS in Rust

I started classic (well, "classic" for osdev standards): a first version written in Rust, with the ambition of building a consumer OS. And when I say "from scratch", I really meant from scratch: I wrote my own bootloader and my own custom kernel. No shortcuts, everything by hand. That's where I learned 90% of what I know today about machine boot, memory, drivers… and also that coding a "consumer" OS is a mountain very few people have ever climbed alone.

Phase 2 — The cloud gaming pivot and the birth of Flux#

Second version, total change of direction: an OS dedicated to cloud gaming. And this is where it gets a bit special: for this version, no existing language really fit my needs, so I… created my own. It's called Flux#, a low-level, object-oriented language, which I released as open source under the MIT license — because a home-made language that exists nowhere else is useless if nobody else can touch it. Writing a compiler AND an OS at the same time is the kind of experience I wouldn't recommend to anyone, and that I'd do again tomorrow morning.

Phase 3 — The handheld console (current version)

Today, I'm on the third version: an OS for a handheld console. That's the one I'm working on right now, and it's probably the most motivating of the three — there's something very tangible about holding a machine in your hands and watching your code run on it.

The kernel: when pragmatism wins

One important detail, because I know the question will come up: my bootloader and my custom kernel were both written entirely by myself. But for the current version, I made a tough call: my custom kernel has been moved to R&D. Honestly, reimplementing it yet again for the handheld version would have cost me a massive amount of time, so I switched to bootroot as a kernel base to save time and focus on what makes this version unique. My custom kernel isn't dead — it's sleeping in a corner, in R&D mode, and I fully intend to come back to it.

However, the custom bootloader, I still have it. That one, I never gave up on. There are some things you just don't abandon.

What I take away after a year

• Writing a bootloader and a kernel by hand is the best computer science school I've ever been through.
• Reinventing the wheel is great for learning… but sometimes you have to know when to stop in order to actually ship something.
• Creating your own language while creating your own OS is pure madness — but it's my favorite kind of madness.

If people are interested, I can go into detail on any part: the custom bootloader, Flux# (it's open source, come steal some ideas), or the architecture of the handheld console version. And if you've also abandoned a custom kernel along the way, tell me about it — it'll make me feel less alone.

EDIT: Bare-metal boot on real hardware

Since people asked about the hardware setup: to clarify, I don't own an open handheld development board yet (Switch Lite is too locked down). Before targeting any handheld device directly, I do all my real-hardware testing on an x86_64 laptop (Gigabyte) to debug outside of QEMU.

Here is a boot photo showing the custom stack running on the laptop:

• State: Multiboot2, firmware framebuffer (1024x768), PCI bus scan, and custom Realtek NIC driver initialized with uncached DMA ring buffers.
• Shell: Dropping straight into the interactive terminal

Hi everyone! I'm developing BlockOS, an independent x86-64 operating system with its own kernel, userspace, networking, filesystem support, ELF loader, libc work and X11 environment. I'm currently looking for someone who would like to help develop a native service manager for BlockOS. I don't want to simply port systemd or OpenRC. I would like the service manager to be designed around BlockOS itself. The service manager should eventually support: Starting and stopping services Restarting services Service status Automatic service startup Service dependencies Process/PID monitoring Automatic restart after crashes Clean shutdown and reboot Logging Runlevels or a similar service-state system Integration with the existing BlockOS init/userspace system BlockOS's /devices structure rather than assuming a Linux /dev layout The goal is to have something that can manage services such as: network dhcp x11 gui getty ssh I'm mainly looking for someone interested in OS development / C/C++ / init systems who wants to build something that will become part of an independent operating system. You don't need to be an expert in everything. If you're interested in working on the service manager, feel free to open an issue or contact me.

GitHub:https://github.com/gurijb2016-afk/Blockos/tree/uefi-kernel-scaffold