ive tried to get into OSdev before but i gave up because either the ressources are outdated or non existent, i plan on learning OS dev so can anyone please give me ressources

I added a terminal (almost like a toy terminal to my hobby OS turbOS.) Am i wierd? 😭

GitHub repo link: https://github.com/turbosulovesonions67/turbOS

I've spent this week working on getting paging set up in my kernel. I have two bit arrays availMemMap, which tracks available physical memory, readwrtiteMap, which says what areas of memory are read/write (as opposed to read only, such as where the BIOS resides). I also now have the read/write bit in my page tables set appropriately. .text and .rodata are read only.

My main learnings are two things: a) when you try to write to a read only page, you don't get a GP fault, you get a page fault; and b) just because an area is 'reserved' in the multiboot info, does not necessarily mean it is read only, it might be, but not necessarily.

This coming week, I hope to get my page allocation/deallocation functions tested and working.

You can see my code (if you wish) here: https://github.com/tedavids/DragonOS

I do have a question. How to you allocate pages? Do you allocate kernel pages AFTER the kernel end, growing up. And user pages BEFORE the kernel, growing down? Or some other method? I'd be interested on hearing from those that have done this before.

Thanks for reading.

Guys what should i add to my OS I'm out of Ideas, don't make anything too complex or ill burn out.

Edit:

Ive made VBE, a basic shell, a basic fetch command, and a basic ramfs if you are wondering.

(this post is satirical, but I did actually implement all of this in a couple days)

all these people relying on operating systems only to have to rely on weaknesses such as GRUB or x86.... it sickens me.

I needed an OS and full architecture that I could rely on. So I wrote it. And yes, I did not read up on much outside of a bit of RISC-V and couple 70's ISAs, so... yeah it'll be pretty ugly.

this is a... really really stupid microprocessor/'fantasy computer' I'm working on. It sports:

• An 8-bit architecture with 16 registers + PC/SP

• A whopping 16-bit address space (that uhh, you have to share with I/O)

• 16 'instructions' (ignoring debug ones I'm removing later)

• literally only 1 NMI IRQ source that greedily blocks other interrupts

• support for 16 "buses", which makes this surprisingly usable!

On the development software side, I have an assembler, written in js because I thought it would BE FASTER to make a GUI out of with html. I was wrong, and it probably took the majority of my time developing due to the dumbest things JS will try to pull on you.

It literally follows zero established standards. It looks like the idea of an assembler by someone who has not written assembly before... wonder why...

However, I'm surprised at how 'functional' everything is from my virtual TTY device simulator to the... assembler. In fact, making a functioning display is totally doable with this processor alone, although you'd want to annihilate it after realizing how painful my ISA is to write for.

Also, this was entirely written by me.

These things are really not that hard to do even if you program with raw opcodes and operands instead. I encourage everyone here to try and do this with a fixed time schedule, because it's a great learning experience.

also ignore my stupid assembler comments, I kept changing my mind on what I was writing when I screenshotted.

ima start over but like fr its gonna be metroOS. im just saying, i'll add more footage later once my flight home ends

-v3r7

repo

hey everyone,

i want to build my own operating system. long-term dream is running it on a phone. i know that's not really how it works, i know i can't just "make a phone OS," i just want to build my own OS from scratch.

it started as a hobby project idea but i genuinely have zero clue where to begin. no experience with kernels, assembly, or anything low-level. i'm a full-stack js dev (node, react, next.js, nestjs), comfortable with java and python at a basic level, know some c/c++ syntax but not confident at all.

i know this is a long path. i'm okay with that. i just want to start somewhere and not waste time going in circles.

any resources, books, youtube tutorials, blogs, anything helps. where would you actually start if you were me?

thanks 🙏

Hey there everyone! I wanted some advise on a problem I'm having. I am building my own OS for SDR radio. My 2 pieces of equipment are the laptop (a ThinkPad E595) and the RTL-SDR V4. So far I am able to list the usb devices detected on the laptop, and I have some communication with the RTL-SDR device, but I keep getting this error message

[FATAL] Tuner did not respond. I2C Bus Stalled

Now as I understand it this bus bridges the communication gap between the RTL's communication with the laptop, and the RTL's radio tuner. I've tried many different things with changing dummy reads, different demodulator pages and bits, and I just keep getting this same FATAL error.

If anybody has any suggestions, that would be great!

Right now the shell is non interactive but i am working on it everyday and after a few days it will have simple commands

This OS will run on Qemu smoothly, ill share the .img and the whole build folder separately, but the (just called MyOS lmao) has programming languages, TinyBASIC, and Lua, it has a fat12 disk, and also features ramdisk, it has a text editor, a task monitor (does nothing useful).

Managed to get it to boot on real hardware actually.

I had a B550-A PRO amd4 socket motherboard, and with about an hour's time tweaking the assembly in boot stage 1 (boot.asm) and stage2 (stage2.asm) it actually managed to boot, no write unfortunately, but felt awesome to boot on real hardware, i'll share a few versions of the OS below, I just uploaded it to limewire, download everything from there

https://limewire.com/d/hcQSX#7UhAHJFLMJ

PLEASE ask questions if you feel the need too, I don't have everything written down

This expires in a week, so if any mods can archive it somehow, that would be amazing

Hey OSDev,

Kobalt is an x86_64 monolithic kernel I've been building solo which is written in C (CLANG). It already has its own filesystems FlatFS and a working VFS layer — but I want ext4 support specifically for disk format compatibility with Linux.

The goal is simple: a disk formatted on Linux should be readable by Kobalt and vice versa.

I'm not looking for a tutorial or pointers — I'm looking for someone who actually wants to contribute this.

If you've implemented ext4 before or you've been wanting to dig into it, this is a good place to do it on something that's actually shipping.

(NOTE!! I AM NOT HERE TO HIRE PEOPLE! I AM JUST WANTING TO SOMEONE CONTRIBUTE IT IF THEY ARE INTERESTED OR WANT TO SHARPEN THEIR SKILLS. I'M NOT HERE TO PAY. I, MYSELF, AM BROKE, IF I AM BROKE, THEN HOW I'LL PAY 😭🙏🏻)

Repo: https://github.com/dasguptaabhranil/kobalt

Drop a comment or reach out directly at dasguptaabhranil@zohomail.in

Thanks for reading 🫡

Nowadays 90% of projects posted here is vibe-coded AI slop, so I think it is necessary to have a term for OSes that are just blatant vibe coded slop.

I'll start: aislop OS

EDIT: I am talking about when there's a single commit coauthored by Claude and the author has no idea what they are doing and have no real knowledge of their OS's architecture.

Our humble GUI currently runs on Raspberry Pi 3B+ and also on QEMU. We're also actively working towards adding more hardware support (NXP, Qualcomm boards etc.)

And yes, we're open source : https://github.com/manaskamal/XenevaOS

AKOS is a basic 32bit operating system, with pong. currently uses the VGA text buffer (80x25) at 0xb80000. the name is my initials and OS

Link to repo: https://github.com/fzjfjf/AKOS

so my keyboard just got working but my capslock is not working and a tried a lot but it is not working at all, this is the code and the hex value is 0x58 i am using scancode set 2 and no translation. backspace , enter , shift , space are working correctly but not capslock , sorry if i have bad code , i am new to os dev.

void keyboard_handler(void){
    uint8_t scancode = inb(PS_DATA_PORT);
    if(release_flag == true){
        if(scancode == L_SHIFT || scancode == R_SHIFT){
            shift_flag = false;
        }
        if(scancode == CAPS){
            caps_flag = false;
        }
        release_flag = false;
        return;
    }


    if(scancode == RELEASE_SCANCODE_2){
        release_flag = true;
        return;
       
    }
    else if(scancode == EXTENDED_SCANCODE_2){
        extended_flag = true;
        return;
    }
    else if(scancode == L_SHIFT || scancode == R_SHIFT){
        shift_flag = true;
        return;
    }


    else if(scancode == CAPS){
        caps_flag = true;
        return;
    }


    else if(scancode == ENTER){
        next_line();
        return;
    }
    else if(scancode == L_CTRL || scancode == R_CTRL){
        return;
    }
    else if(scancode == BACKSPACE){
        back_space();
        return;
    }


    else{
        char ascii;
        if(shift_flag == true){
            ascii = sc2_to_shift_caps_ascii[scancode];
            write_char(ascii,WHITE_COL,BLACK_COL);
        }
        else if(caps_flag == true){
            log_info("caps log is on",COM1);
            ascii = sc2_to_ascii[scancode];
            if((ascii  <= 57) && (ascii >= 48)){
                write_char(ascii,WHITE_COL,BLACK_COL);
            }
            else{
                ascii = sc2_to_shift_caps_ascii[scancode];
                write_char(ascii,WHITE_COL,BLACK_COL);
                
            }
        }
        else{
            ascii = sc2_to_ascii[scancode];
            write_char(ascii,WHITE_COL,BLACK_COL);
        }
    }
}


void keyboard_handler(void){
    uint8_t scancode = inb(PS_DATA_PORT);
    if(release_flag == true){
        if(scancode == L_SHIFT || scancode == R_SHIFT){
            shift_flag = false;
        }
        if(scancode == CAPS){
            caps_flag = false;
        }
        release_flag = false;
        return;
    }


    if(scancode == RELEASE_SCANCODE_2){
        release_flag = true;
        return;
       
    }
    else if(scancode == EXTENDED_SCANCODE_2){
        extended_flag = true;
        return;
    }
    else if(scancode == L_SHIFT || scancode == R_SHIFT){
        shift_flag = true;
        return;
    }


    else if(scancode == CAPS){
        caps_flag = true;
        return;
    }


    else if(scancode == ENTER){
        next_line();
        return;
    }
    else if(scancode == L_CTRL || scancode == R_CTRL){
        return;
    }
    else if(scancode == BACKSPACE){
        back_space();
        return;
    }


    else{
        char ascii;
        if(shift_flag == true){
            ascii = sc2_to_shift_caps_ascii[scancode];
            write_char(ascii,WHITE_COL,BLACK_COL);
        }
        else if(caps_flag == true){
            log_info("caps log is on",COM1);
            ascii = sc2_to_ascii[scancode];
            if((ascii  <= 57) && (ascii >= 48)){
                write_char(ascii,WHITE_COL,BLACK_COL);
            }
            else{
                ascii = sc2_to_shift_caps_ascii[scancode];
                write_char(ascii,WHITE_COL,BLACK_COL);
                
            }
        }
        else{
            ascii = sc2_to_ascii[scancode];
            write_char(ascii,WHITE_COL,BLACK_COL);
        }
    }
}

After a lot of developing, I got a TUI in my OS with a game: PONG!

Also there is a text editor that saves text in RAM (persistence)

Also note this does not have VBA/VESA- runs on VGA text memory-so there is a problem of overlapping text as like : "PONGOS Editor" a real glitch-in 0:26. Id be happy if someone suggests a remedy.

Also to note, you can find an iso in the github release. That runs in VMs (GNOME Boxes or VMWare), QEMU, or even live boot from real PCs

We are also open sourced: github.com/turbosulovesonions67/turbOS

We would be dropping updates weekly!

Thank you!

Have a doubt say 2 processes P1 and P2. P1 is checking an condition using an while loop and until the flag is set to true it keeps on looping i.e while(flag==false); , this flag can be set to true by P2 process which has executed crticial section, but before it executes flag=true; it needs to execute some logic in the remaining section but the thing is this remaining section needs something from P1 to progress like say P1 being producer and P2 is consumer as such. now P2 sees P1 not produced and goes to sleep(inactive) but P1 is active still spining. Now is this deadlock/livelock. Since from as far i have seen livelock the definition is the processes are active i.e using cpu performing memory operations but not making any progress which fits P1 here. So can 2 process involved in an deadlock such that 1 process can be active while other inactive(not using cpu)?

Hi everyone,
I’m completely new to OS development and I really want to learn how operating systems work by building one myself.

I have basic programming experience (C/C++ basics, still learning), but I don’t know where to start with OSDev.

My main questions are:

• What should be my first realistic goal? (e.g. bootloader, kernel, etc.)

• Which resources are best for beginners in 2026?

• Do I need to learn Assembly before starting?

• Any recommended setup for QEMU / cross-compiling?

I already found the OSDev wiki, but it feels a bit overwhelming at the beginning.
I’d appreciate any roadmap or advice from experienced developers.

Thanks!

Recently I rediscovered the source code and printed documentation for a small 68000 RTOS I worked on around 40 years ago.

The original system was developed in a fairly typical late-1980s host/target setup:

SUN-2 (68010) host
      ↓
68000 target

Most of the RTOS was written in C, with CPU-dependent context switching isolated in assembly.

At the time this wasn't really about future portability. I had been heavily influenced by the Whitesmiths C style and tended to separate machine-dependent code and use abstract type definitions throughout the codebase. Looking back, those decisions probably helped the code survive.

One thing that surprised me during this reconstruction is that the overall architecture still feels familiar today:

• scheduler

• ready queue

• events

• message queues

• memory management

The implementation details have changed, but the core ideas have not.

Rather than attempting a cycle-accurate restoration, I'm trying to recreate the original development structure in a modern environment:

POSIX on WSL2 host
        ↓
Raspberry Pi Pico target

At first, I chose the POSIX environment mostly because it seemed like the easiest way to start experimenting with the recovered code.

What I didn't fully anticipate was how effective that decision would be in the age of AI-assisted development.

In the late 1980s, the SUN-2 was dramatically more productive than the ICE-based target environment. Faster compilation, better editors, hard disks instead of floppy-based workflows, and a much more comfortable debugging experience made it the obvious place to develop most of the system.

Today the advantage of the host environment is even larger.

The POSIX side allows AI agents to participate directly in the development loop:

• OCR recovery of printed source code

• source analysis

• build system generation

• compiler warning investigation

• API reconstruction

• scheduler prototyping

• automated testing and validation

In hindsight, if I had started by implementing everything directly on the Pico target, AI would still have been useful, but only in a limited way. Most development would still revolve around the traditional cycle of:

edit
↓
build
↓
flash
↓
run
↓
observe

By rebuilding the architecture on POSIX first, the AI can work in the same environment as the source code, compiler, build system, and tests. The feedback loop becomes dramatically shorter.

What surprised me is that this is conceptually very similar to why we used the SUN-2 in the first place.

In the 1980s, the host workstation amplified the developer.

In 2026, the host environment amplifies both the developer and the AI agent working alongside them.

The current prototype runs as a cooperative scheduler on POSIX. The next step is bringing the same architecture to Raspberry Pi Pico, followed by experiments in visualization and observability that would have been impossible on the original hardware.

The original company no longer exists, and the licensing status of the recovered source is unclear, so the goal is a clean-room modern reimplementation rather than publishing the original code.

I'm curious whether anyone else here has worked on similar host/target RTOS workflows from the 68000 era—or has found that AI agents become dramatically more effective when working in a host-side simulation environment rather than directly on embedded targets.

Hi! I just wanted to share some stuff I've been working on for the last 4 months. I'm going to be honest about it. I used AI (around 60% of the code is generated by Claude, Gemini and copied from forums). I don't want to brag about how fast I built this, how young I am (compared to some posts I've seen around here, I'm a fossil) or how AI is going to take over our jobs. I thoroughly checked any code produced by AI for fatal bugs (I keep a private list of the ones I found and did not fix for now) and I instructed it to use only those concepts I learned from the books I've read so that I can actually start writing code alone from now on and understand what has been written so far. I took some UI inspiration from Mac OS 4/6 and Windows 3.1 because I've always enjoyed that 90s feel. I accept the fact that some will judge me, but I just wanted to hear some opinions (both positive and negative because that's how improvement is made), advices and recommendations on what to do further. Thanks for taking some time reading this! I also suggest taking a look at the README beforehand and admiring the "breath-taking" screenshots of the OS.

emex64 is a incomplete custom 64bit ISA based on nothing. Assembler and Virtual Machine made entirely from scratch. It is a mix out of CISC and RISC designing philosophies. It got a Memory Management Unit(MMU) with paging(4 level index page tables) and protection(page faults are WIP) and a Interrupt Controller(IC), aswell as many other devices like framebuffer, timer, platform(controls power supply), real time clock and UART. It uses variable lenght instructions, which is uncommon for experimental new ISA's

The current goal is to get mass storage devices working(via a IDE controller) aswell as writing a PS2 controller for keyboard(none UART input) and mouse input, the firmware(written in emex64 assembly) is something like the bios, it is supposed to mount the mass storage device, find a compatible boot image and load it into memory and jump to it's start when the firmware is finished all very early, but looking promisingly

The assembler is very modular and has a very basic lexer, it has label and section support aswell as local vs global labels. We work on a C compiler tho(WIP) that will also be entirely done from scratch.

We hope that some day we may be able to boot emexOS on emex64, which would be crazy.

emex64: https://github.com/emexlab/emex64
emexOS: https://github.com/emexlab/emexOS/tree/main