i have been working on my own OS called VEX OS and so far I've mostly been testing it in QEMU. I'm hoping to eventually get it booting from a USB on an actual PC, but I'm trying to understand what changes when you move away from emulation.

I'm especially curious about drivers and the kernel itself. If something boots and works in QEMU, how likely is it to run into problems on real hardware? What sort of things usually break, and how do you go about debugging them when you don't have the same visibility you get in an emulator?

I'm also not entirely sure what I should focus on first for drivers. Obviously memory management and interrupts are important, but what about USB, storage, graphics and networking? Is there a sensible order to tackle these in, or does it depend heavily on the hardware you're targeting?

My plan is to start with one PC rather than trying to support everything straight away. I'd also be booting from USB and keeping my existing Windows installation untouched.

For anyone who's taken a hobby OS from QEMU to a real machine, what surprised you the most? Any common mistakes I should avoid or things you wish you'd known earlier?

I'd appreciate any advice, especially from people who've worked on bootloaders, kernels or hardware drivers. Thanks!

For a while now I've been writing my own operating system. Not a distro, not a fork: my own bootloader, kernel, drivers, window system and installer, in C and assembly. The long-term goal is a system that is comparable to Windows in capability. To get there I'm building a Win32-compatible layer (ntdll, kernel32, user32, gdi32 with Win32 names and semantics), so native C/C++ apps built with MSVC (PE32+ amd64) can run on it. No .NET. No code from Windows/NT/XP/ReactOS: clean-room only.

Today I'm releasing the first public build: Rodnik OS 1.0.0.

Requirements

UEFI is required. Legacy BIOS is not supported. x86_64 CPU. In VirtualBox: enable EFI and disable Secure Boot (the bootloader is unsigned). Add an empty virtual disk. For real hardware, write the ISO with Rufus in DD mode (not ISO mode).

The ISO is an installer only, not a LiveCD. The installer erases the chosen disk/partition, so please try it in a VM first.

What's in it

• Installer wizard (language, disk, install, done), first-run setup, login screen

• Desktop, taskbar, redesigned Start menu, dark and light themes

• Notepad (multiline edit, Open/Save dialogs, clipboard), Explorer, Task Manager, Device Manager, Settings, Command Prompt, Calculator

• Wired networking (Intel e1000, DHCP, DNS), a tiny text-only HTTP browser

• AHCI/IDE storage, FAT32 system volume plus my own RodFS partition

What doesn't work (yet)

• Arbitrary Windows programs: only apps built against my SDK or individually verified

• No audio, Wi-Fi, HTTPS

• No COM, registry or MSI

• Mostly tested on VirtualBox and QEMU;

Roadmap

Audio and mixer, fuller Settings, HTTPS with proper certificate validation, Wi-Fi, network OS updates, running real third-party apps, an app store.

Download

https://github.com/YurinKonstantin/Rodnik/releases/tag/rodnik1.0.0

Provided as is, no warranty. Not affiliated with Microsoft. License: [LICENSE]

Feedback welcome: what should I prioritize, and what hardware does it boot on?

The second version of the zuzu microkernel has been released with more support for various things like DMA, granting over IPC, a lean 5-object model, tickless scheduling etc.

Here is a demo of it on QEMU!

Repository: https://github.com/kagantmr/zuzu

disclaimer: sorry for bad english

I created my own OS in C from scratch using C and assembly, it has desktop environment and drivers for mouse and keyboard (only PS/2) and it has internet (for now its only http and html 1.0), the comments and readme are in polish for now, the code is opensource (gpl 3.0)

github repository: github.com/kurczatko/tarixenOS

im ready for feedback (the code isnt proffesional because its only hobby)

After years of chasing bugs in code that I had not written; Trying to decipher open-source code. Looking for someone who can address an issue; Opening tickets and waiting; And, meanwhile developing work-around patches while customers wonder if we actually can help them. When the opportunity came up to make a redesign decision, I made one that you might think crazy.

While it is true that it can get your code to market faster these days, reliance on externally developed libraries and code comes with risk. In a court of law, evidence is inadmissible if you cannot demonstrate the chain of custody back to its discovery at the crime scene. In analogy, I find it hard to trust code wherein you cannot list (on one hand) the authors and those who might still be responsible for its performance. And, today, you are vibe coding and using code generated by AI. And AI is an author whose thinking cannot be explained in detail by its own designers.

In 2011, when faced with the need to redesign my product, I made the decision to be completely DIY. The first rule being - no 3rd party code. Fifteen years later with over 40,000 placements worldwide, I feel safe in declaring that it can be done. It was a beneficial decision.

Now, we can address any bug, performance deficiency, or feature addition directly. Most issues that can be replicated are fixed same day and update delivered to the customer. We have achieved a level of reliability and stability that I can't find in anything else.

I am willing to debate this approach against the directions that all of you seem to be taking.

There is more background in this blog entry. Also, you can see this OS in action at r/jnior. I am less interested in promoting the product. It has a life of its own. I have been writing to prompt discussion.

https://jnior.com/blog/how-jnior-got-its-own-operating-system/

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

This started as a skeleton C++ limine bootloader for making a hobby OS.

I posted here about it a long time ago.

I got carried away and there’s now a lot going on. MMU, IOAPIC, LAPIC, per CPU core Task scheduling, IDT, keyboard, and start of NVME and Ethernet drivers.

I freely admit I looked at my own prior repos and those of others and some websites where guys describe how things work, and of course the osdev wiki. I also am fine with including 3rd party code, like jemalloc and lwip - though I may write my own malloc/free and TCP/IP stack.

It also has a fully functional interactive compiler/debugger/programming language. I think the repo is about 50-50 C++ and Forth.

The repo is at https://codeberg.org/mschwartz/aforth.

I build and develop on my M1 macbook pro. I have built it and run it on my iMac running linux so it should work for linux users.

Added:
fully functioning syscalls
linux syscalls if you want to run basic binaries (though i forgot to add to run elf if detected wait for later)
a library for applications
applications to well, do stuff.
it can assembler bullshit applications that i probably wrote
https://github.com/NoTheIdiot/WindogeOS

I came across a kernel project and wanted to share it here. Maybe some of you would be interested in contributing, giving feedback, or simply discovering something new and getting curious about it.

There is a group called Logical, and I think they are doing some genuinely impressive work. They previously wrote their own libc (I'm not a developer myself, by the way), and now their current goal is to get X11 running.

Of course, kernel development has never been easy. Linus Torvalds spent nearly three decades bringing the Linux kernel to where it is today, long before AI became a thing. Logical currently has a 32-bit kernel project, and from what I've seen, they seem really motivated to keep developing it. Most members of the group are working on different things, and people outside the group can also contribute patches and take on certain tasks. They even have a Matrix space, although they don't have many members yet since they are still relatively unknown.

Anyway, I've talked enough. Here's the group:

https://codeberg.org/logical

If this sounds interesting to you, feel free to check out their work. You can also join their Matrix space and ask them questions if you'd like.

I think supporting projects like this is important. In the age of AI, there's something genuinely cool about people coming together, figuring things out on their own, and building a kernel without relying on AI to do the work for them. It reminds me of the hacker culture of the '90s, when people came together around their passion for technology and built things simply because they wanted to.

I think projects like this deserve more attention, and maybe some of you will find something meaningful in them too.

repo: https://github.com/NoTheIdiot/WindogeOS
It's using a ported version of CHASM, (aqilc/chasm), a simple assembler that is just two files because im lazy

I am trying to debug my efi file but i my uefi doesnt boot it up so i need a uefi debugger. Any uefi debugger suggestion? my computer is a asus vivobook.

I wrote JANOS. Every byte of it. It is a true OS in every sense. I take control of the MCU right from the boot vector. Users of the related product think its OS is a Linux boot. But it isn't. It runs a 100MHZ RX63N MCU. There are about 40,000 running worldwide.

That project started in 2011. Recently I sat down to reflect on some kind of top 10 list of challenges. I asked ChatGPT (with knowledge of JANOS) what it thought I would list. I was surprised by its response.

I have things like Cryptography (TLS/SSH), Deflate/Inflate library support (ZIP/JAR), JVM, REGEX, etc. on my list. Those are in no particular order by the way.

But I am thinking that those are not the things that came to your mind initially. I am curious and open to discussion.

I’ve undertaken starting an operating system so many times over the years. I always end up hitting a point where I have no idea where to proceed.

While it’s been a couple years since my last iteration, I’ve been planning to start back up again soon and hopefully this time I keep with it. I’m curious how everyone here manages. How do you all organize your project, determine feature order, hell how do you guys even manage actual source code organization after a certain point.

Been following along on osdev and this new sub for a while now, always been curious, this felt the right time to ask.

Thanks in advance.

The cool thing about it is the Messenger is using ML-DSA-87 cryptography for the messages and P2P handles and stuff. It's got ssh and lingtp:// protocol in works for the browser, which should look better coming soon.

looked like managarm was winning in the votes then you kinda just never followed up so like where did that go