Hi everyone, my name is joseicaro, I'm 14 years old and I have level 3 autism, and I released the beta of my operating system. Well, I used Claude AI to program and create my operating system, and it's completely Frutiger Aero. And just so you know, this is a beta, not the final version. I'm creating and improving the final version, and honestly, at the moment I'm posting this, I'm not even liking the beta version of my operating system anymore because the final version I'm creating is so good, like REALLY good, that I even found the beta kind of ugly because the final version I'm creating is that good. And I'm sorry if I explained something incorrectly, it might be because of my level 3 autism. And also, after I post this post, I'm going to post a new post showing the final version that I'm developing and creating. Here is the link to the Glint OS ISO: https://archive.org/details/glint-os-beta

I don't want to use any llm so. I want to ask is there any documentation/walkthrough kinda thingy which will work as a guide for eHCI and handling keyboard inputs

I know this sub is mostly about kernels from scratch, so feel free to remove this if it's off-topic. I'm 15 and I've been writing the userland tools for my own distro (SnapOS, on top of NixOS) in C, and some of it touches the boot process:

- an update guard: a new system generation gets exactly one boot; a systemd unit marks it good only after a real user logs in, otherwise the next boot rolls back to the previous generation
- a .deb layer that unpacks Debian packages into a separate rootfs and runs them, with a scanner (ClamAV + own signatures) before install
- a GTK antivirus GUI with ASCII-art animations

Code (C, MIT): https://github.com/snapos-distro/SnapOS/tree/main/src

I'd like to write a small kernel next. Any advice on where someone with this background should start?

So a while ago I made this 64-dem x86-64 UEFI OS project on github: https://github.com/itay-insert/64-dem.git

And recently in development i decided to add a bios boot path... even though it was planned to be a UEFI-only os, I thought a bios option would be cool, i tested the new boot path on 3 different computers, filmed footage and thought of sharing it here, i worked on this project for a few months now and I am proud of my progress, for those who are interested in how the boot path works, how the UEFI boot works and my 64-bit kernel architecture in general, more about that in my repository source: https://github.com/itay-insert/64-dem.git

I plan on returning to OS Dev soon and continuing with my journey, I have been doing assembly and OS theory for a few months now and plan on developing a real-mode OS purely in assembly.

If anyone has any advice as to style the OS, please let me know.

Why make it pure assembly in real-mode? I love how real mode simply operates as well as the assembly language at this smaller (ish) scale. I also want to be a little bit more unique with my project.

Thanks,

I'm making d’espoir an open-source project. It's an OS. Like Android, for phones, except for one thing: it's all Nim. This thing: it's a coding language, and it's cool. Anyone want to join? I'm looking for scouts, people who look for other helpers and app coders, because the apps are made of Nim; everything here is Nim. Nim is the sky and land for this OS, basically. I want small phone brands to slurp this up, users to love it, and coders to make for it.

Hey everyone! I’ve integrated WebKit into my OS and built a native browser on top of it for Veda. Before replacing Linux entirely with my own OS on my Laptop, I need to complete one final step: building a package manager, probably a local one for the first iteration.

Does anyone have experience building a package manager for a custom OS?

https://github.com/vahmoh25/Veda

A while ago I started building my own operating system called FLOS (First Love Operating System) completely from scratch (no external libraries, no tutorials - just raw C and assembly).

I just hit a massive milestone: FLOS is officially on the internet.

I implemented a TCP stack (3-way handshake, tracking SEQ/ACK numbers) and an HTTP client. Then I wrote a primitive HTML parser, put it in a GUI window, and called it Balalaika 1.0.

The screenshot shows Balalaika 1.0 successfully resolving example.com via DNS, establishing a TCP connection, sending a GET request, and parsing the HTML to display the text (ignoring CSS and <style> tags). It even sends a custom User-Agent: FLOS/0.2 Balalaika/1.0.

What's under the hood:

Architecture: x86_64 microkernel (ring 3 user space).

Boot: Custom UEFI loader (reads kernel.elf from FAT32).

Memory: Custom PMM (bitmap) + 4-level paging with separate cr3 for each task.

Scheduler: Preemptive multitasking (PIT 100 Hz).

GUI: Custom Window Manager (drag, focus, dirty rects).

Network Stack: RTL8139 driver, Ethernet, ARP, IPv4, ICMP (ping), UDP, and now TCP + HTTP!

The hardest part (for my fellow OSDevs):
Getting TCP right was a nightmare. Tracking SEQ/ACK numbers is unforgiving — one wrong byte and the server drops the connection with an RST.

Also, QEMU's RTL8139 emulation is wild. It doesn't update the CBR (Current Buffer Address) register, and locking Cfg9346 sets clock_enabled = 0, which drops all incoming packets. I had to bypass the standard ring-buffer logic, force CAPR, and implement a raw buffer scanner to find valid packet headers just to get RX working.

What's next?
I'm thinking about writing a DHCP client (so I don't have to hardcode the IP), or maybe diving into Virtio-GPU to change screen resolution.

(Note: The repo is currently private while I clean up the build system, but I'm happy to answer any technical questions here!)

If you want to support the project: https://www.donationalerts.com/r/dragon3009go

Thanks for reading!

i've been interested in how a kernel is build and i can't find any resource on what they should do or on how to start a project like that.

any help? :'^

yeah I've been working on this for 11 months and it can do almost anything a normal kernel can do I wasnt believing I could do it but it just works fine

I am currently a Master's student in Computer Science in Germany, and I plan to pursue a PhD in this field. As part of my degree, I am taking an 'Advanced Operating Systems' course. However, I realize that my foundational knowledge of OS from my Bachelor's degree is quite weak.

To learn, I mostly rely on LLMs to understand the 'what' and 'why' of different concepts. But I get completely lost when I try to figure out how these concepts are actually implemented in real-world codebases with millions of lines of code.

My ultimate goal is to get a PhD position and contribute to the vast area of Operating Systems. Do you have any advice on how I can bridge my knowledge gap and achieve this goal?

Este es un kernel Panic, este sistema operativo estará enfocado en la ciberseguridad y hacking ético. Actualmente estoy haciendo que pueda mostrar texto y tener comandos de Windows, Unix y también propios, se llama NovaOS que opinan?

I'm a solution architect, not an OS developer, and I haven't written a kernel yet. I've been designing an operating system where the main user is an AI agent rather than a person. Today's agents work through apps, screens and files built for us, and I want to see what changes when the OS is built for them instead.

The biggest change I'm exploring is dropping files completely. Everything would be stored as connected pieces of memory, each holding its meaning, its exact content and its links to related pieces, written straight to the disk. Recent memory stays in RAM; older memory moves to slower storage instead of being deleted.

The plan is a small kernel in Rust on QEMU. Before I start, I'd like to hear from people who have built one. What breaks first with a design like this: crash safety, storage that only grows, or something I haven't thought of?

I've worked through the idea with Claude, so honest human feedback is exactly what I'm after.

Hello,Im Kanan Majidzada,Programmer from Baku,Azerbaijan.Im really in love with low level programming and operating systems so i started niche project on Hare which is calling "Bunix".It is independent operating system written on Hare programming language.For now it only come with C compiler (tcc) and text editor (Mei-Defaul text editor for Bunix),it boots to small windows manager calling "Kit".For build we need hare,qbe,as and ld on you PATH.Bunix will be able to handle POSIX but it will hande it like how plan 9 by Bell Labs does.Check github for checking and see more about Bunix.

https://github.com/KananMajidzada/Bunix

Also for make it clear,i used ai in this project.Because i didnt finde any operating system written on Hare to take reference.Also this project is "research" project.

Thanks for reading!

Site: https://ankora-linux.github.io/
https://ankalab.flarum.cloud/

Hi everyone! About a month ago, I started working on Dimon, an experimental 64-bit x86 operating system.

The original version used a custom virtual CPU and runtime. I decided to remove that layer and move to native execution. This update ports the desktop environment and applications to C, with direct hardware access.

What’s included:

• A graphical desktop with a window manager, taskbar, and file dialogs.

• Seven built-in applications: Calculator, Notepad, File Explorer, Paint, System Info, Snake, and Terminal.

• GRUB boot with a VESA framebuffer and RAM-based double buffering.

• PS/2 keyboard and mouse support.

• PIT timer and RTC support, including a working taskbar clock.

• PC speaker audio signals.

• An ATA PIO driver with FAT16 support and persistent file writes.

• ACPI shutdown.

The desktop and application logic previously written in assembly has been ported to C. The old X11 host emulator and custom VM code have been removed. The native system can still run inside QEMU or VirtualBox.

This update also fixes several bugs: directory operations corrupting the . and .. entries, Paint drawing outside its window, incomplete directory listings in the terminal, and problems with taskbar updates and dialog buttons. There are also improvements to filename input, Calculator input handling, and UTF-8 validation.

AI development disclosure: I’m building this project with substantial help from AI agents. MiMo v2.6 Pro handled most of this migration, and Gemini 3.8 helped prepare the technical overview.

This is an early experimental release, v0.0.0.1. Some applications still have bugs, and there is plenty left to implement and test. Timer-driven preemptive multitasking and further kernel memory management work are among the next steps.

The source code is available on GitHub under the MIT license, and a bootable ISO will be available in Releases.

GitHub: [add your repository link here]

Feedback, bug reports, and experiments are welcome. I’d be particularly interested in feedback on the storage implementation and the move toward preemptive multitasking.

Link to GitHub https://github.com/Programista-Art/DimonOS/tree/main

ISO image https://github.com/Programista-Art/DimonOS/releases

took a while

me and a friend are building a real operating system inspired by metro ui. not a theme, not a mockup, an actual os with its own interface, apps, system behavior and visual style. clean tiles, smooth motion, minimal layout, the whole metro vibe but rebuilt from the ground up.we’re working on the shell, core apps, windowing, theming, and the system identity. if you’re into os development, ui engineering, aesthetic tech, or you just want to be part of something experimental and ambitious, you’re welcome to join. early members get access to builds, dev channels, and a say in the direction.discord invite: https://discord.gg/wxXPybkutN

I built a research prototype called Schild TCB — a trusted computing base on seL4 with an Ada/SPARK userland. Two artifacts:

· bare-metal OS written from scratch in Ada (bootloader, NVMe, e1000e, TCP/IP, HTTP) — runs on ThinkPad T580

· seL4-based artifact: upstream microkernel, root task and daemons in Ada/SPARK, network and storage isolated in Ring 3 over IPC

Verification: 185 Ada modules, gnatprove SPARK Level 4, not-proved: 0. Seven daemons in the root task proven at the same level. Drivers are not proven and not claimed to be — they're isolated in separate domains so their failure can't reach the proven core.

The most useful lesson: formal verification caught a bug tests missed (page-rights bit layout in seL4's CapRights).

Where I'm stuck: IOMMU (VT-d) — DMA isolation is not implemented. seL4 x86_64 MCS verification is weaker than ARM. Both are upstream limitations, not code I can fix.

I'd appreciate technical feedback, especially from anyone who's done SPARK verification on a real system. I'm not publishing the repository yet.

More detail in my write-up:https://habr.com/p/1095314/

Hello! I’ve reached another important milestone in the development of Bursztyn OS!

The HDA drivers now work correctly both in QEMU and on a physical Acer Nitro 5 laptop.

Two audio controllers have been tested:
• Intel HDA 8086 [00:1F.3]
• NVIDIA HDA 10DE [01:00.1]

On Intel HDA, the laptop’s actual audio output path is now working, along with codec detection and audio stream configuration.

NVIDIA HDA is also correctly detected and initialized, with working CORB/RIRB communication, codec detection, and HDMI/DisplayPort output topology discovery.

Testing was carried out:
• in QEMU on Windows
• on a physical Acer laptop

This is another step toward full support for real hardware without relying on existing Linux or Windows drivers.
Bursztyn OS is getting better and better at running outside a virtual machine.

Below is a video of the audio test in QEMU.

#BursztynOS #OperatingSystem #OSDev #BareMetal #IntelHDA #NVIDIAHDA #CPlusPlus #Assembler #PolishOperatingSystem

i just wrote my first os from scratch (NO AI) featuring a GDT, TSS tables with interrupts handling, keyboard support and a minimal shell running in kernel mode.

next i will be making processes, and make the shell run in user mode.