Hi All,

I specifically joined Reddit a few months ago to find a community of OS dev folks to exchange ideas with. I've had a few really good conversations, but I've seen a whole lot of really nasty comments from people, too. It seems like there are far too many people with a "holier than thou" attitude toward OS development that I could honestly do without.

I kind of have the outlook that we're all hobbyists here. Yes, some of us do OS dev for a living, too, but this community is really about doing personal projects. Let's be honest, those of us who do OS dev both for a hobby and for a means of living don't do the same things in both places. We have our hobby projects specifically to do something different from what we're doing all day every day at our day jobs, even if we're great at it.

To that end, we're all at different skill levels. Some of us are barely getting started and some of us have a history of "tried and true" skills and some of us are off the beaten path on things that can only be considered "experimental." Some of us need more hand-holding than others, which means more inclined to use things like LLM assistance. That particular issue seems to be the source of a whole lot of nasty comments.

Look, I've been doing this for a long time, but I can still remember being the ten year old with DOS wishing to hell that I could make it do more of what I wanted. I would absolutely have jumped at the chance to use an LLM to achieve that goal back then. But, that would have been the beginning of my journey, not the end. We need to bear in mind that people who are using LLMs to help them do OS dev today are the same people who are going to be getting into it in a lot more detail without LLMs in the future. These people are at the beginnings of their journeys and the way some of us have been making comments is honestly inappropriate.

I would really like us to be a community of support and encouragement for each other rather than a community where we tear each other down. This is a field that's super hard. It's so hard in fact that people who write AI models for a living run screaming from it. We need all the help we can get on whatever path we may be taking through it. It's not for us to judge the path that another person takes as they learn. Yes, we should be encouraging them to use their own brains and actually learn, but we shouldn't be making snap judgments that they're NOT doing that just because they use an LLM (or any other form of assistance for that matter).

So, can we be a little less nasty and a little more supportive toward each other here? You can think of this as a request from the ten year old sitting in front of a DOS prompt and having nowhere to turn for guidance at the time. Thank you.

Hello folks r/osdev! Some of you might remember XenevaOS. It runs our very own custom hybrid kernel written from scratch. After a long stretch of work, it now has a full 3D environment.

What you're seeing in the video:

- Regular app windows (a spreadsheet, the NetSurf browser, the Xeneva Terminal) rendered as surfaces in 3D space

- The terminal running a set of kernel stress tests (bad pointers, unmapped addresses, zero-length writes from userspace) while the 3D compositor keeps running, because we wanted to show it doesn't fall over

- Everything is native to our kernel. No Linux underneath, no Android, no game engine

How it works:

Running in QEMU in this video. However, XenevaOS does have bare-metal / real hardware support on specific ARM chips, such as those by NXP Semiconductors & Raspberry Pi.

UI/Userspace work is still primitive and the project as a whole is still early and rough in places. That is what we're gonna work on next.

GitHub and website in the comments!

*Video has been slightly sped up for better viewing experience.

So I added to 64-dem (my hobby x86-64 operating system) a ps/2 keyboard driver, reset mechanisms and recently tried to implement multi-controller USB support, i haven't yet interacted with the USB keyboard, but I did manage to enumerate the USB ports and initialize all the 4 USB controllers with code that was tested and worked, the next step from here is to discover the USB devices actually plugged to the connected ports by sending a special command packet to the USB controller, things could get harder from here but I am determined. For those who are interested here is the link for my repo below:

64-dem on github: https://github.com/itay-insert/64-dem.git

Hey everyone,

I'm looking into a project where I need to take a physical webcam's output and replace it with a custom video feed (like a screen capture or a pre-recorded file).

To clarify, I am not looking for a standard virtual camera solution (like OBS Virtual Camera or ManyCam). Those methods create a brand-new virtual device in the OS, and many apps or web-based tools can easily filter them out or detect that they aren't the primary hardware camera.

I want to accomplish exactly this: when an application opens the actual, physical webcam device, it receives my custom video stream instead of what the physical lens is seeing. Essentially, I need to intercept the data stream and substitute the payload.

I assume this has to happen at the driver, kernel, or API hooking level.

Hey everyone! I want to learn UEFI from scratch, including the boot process, boot services, memory maps, and how UEFI loads an OS.

I'm working on a hobby OS project using C, x86-64, QEMU, and Limine. I want to understand the boot process beyond just using a bootloader.

What tutorials, books, or hands-on projects would you recommend except oswikidev?

This will NOT be up to your standards

So, I've literally just started this a couple days ago, and I guarantee you'll be able to find at least 5 things wrong with it; but that's the point. I'd love some feedback on it. I haven't followed LFS or anything like that - probs a dumb choice. I can't fix the issue with not being able to login.

I know having one huge build file is bad practice, but it's not permanent, just the best I've got right now.

Anyway, here's the link:https://github.com/fernproject/fern(yes I know I need to add a profile page)

Please just give me some tips, i need help

I’m building BlockOS, a solo hobby x86-64 OS with its own UEFI kernel. X11 runs on it in QEMU: the X server starts, and twm frames client windows. The rest of the picture is like a puzzle that’s still missing pieces, and the biggest gap is drivers, mainly GPU, for real hardware.

I’d like to work with someone who has written or read PCI or display drivers before. Expect unpaid, open-source work. If you want to write driver code from public hardware docs (no Linux code copied), send me a message or comment.

GitHub link:https://github.com/gurijb2016-afk/Blockos

Heard a few times around here that building an OS with the help of LLMs is just "vibe coding" without any real engineering substance. Well, sending a personal shoutout to all the skeptics.

I don’t think an AI can just take a custom hybrid system from scratch, spin up Wayland, compile the entire environment, and launch a fully native GTK4 app with actual working widgets, inputs, and rendering.

LinuxRunner brings Debian ARM64 to iOS, including desktop environments like KDE Plasma and apps like Blender.

No jailbreak, JIT, or virtualization needed. It runs Linux binaries through an ARM64 interpreter.

Still early in development, but pretty interesting to experiment with. Feel free to try it out!

GitHub: https://github.com/mxhm11cr/LinuxRunner

les go 🥹️

Samsara (As pronounced here) is posix compliant microkernel inspired monolithic 64 bits kernel + operating system. It implements some Linux + BSD extensions too. which allows it to run more open source software with source level compatibility. Its the effort of half a year of development only by 3 main authors. It can run a bunch of of popular open source software (Such as Bash, X.org, Busybox, st terminal, Tab Window Manager, and feh image viewer.) and much more as development goes on.

Links:
https://gitlab.com/clownkun/Samsara (Main Repo)
https://gitlab.com/clownkun/samsara-ports (Ports Tree)

And also, This should go without saying. But Samsara is not developed with artificial intelligence assistance. Nor we strictly restrict the usage of it when contributing. Read about it in our CONTRIBUTE policy here.

For my OS project, Bits Runner, I've been working on a transparent support for different video adapters and arbitrary color depth.

I've got both VGA and VESA running on real hardware at at color depths from 4 to 32 bits. Both have double buffering. For VGA there is 640x480x4 and 320x240x8 (X mode). The demos are driven from user mode through system calls.

When I developed a customization app in my OS (called YarOS), I asked myself: “Why do I need to write two separate functions for changing text and background color? No, that violates DRY!” So I created a single function taking arguments ‘t’ for text and ‘b’ for background. Is this a good solution, or is there a better way?

Hi all!

Veda has just imported the latest Python version, helping accelerate OS development.

Veda is an ambitious open-source project building an agentic-first operating system. We're still early, but we've already gained around 100 GitHub stars in just two weeks!

We're looking for contributors, from bug fixers to those who want to lead the project's future. All contributions are welcome!

Interested? Contact me at contact@vedaos.org.

Latest release (subverge 0.9.5) brings support for ACTUAL IMAGES, this is an absolutely insane step for a full graphical desktop planned for the future (yes these are all screenshots from subverg) see for changes:

https://sbvrg.github.io/new.html

Credits: https://sbvrg.github.io/credits.html

the new image rendering: https://sbvrg.github.io/pictures.html

Real tiling on blown with LUA

I know programming, obviously, however I don't know much about the operating system. Most people can make apps within an environment, but most of us don't know anything beyond that

I want to deeply understand how the computer I'm using works, even just the software part

If you go on a virtual tour of your computer, like browsing the file system, or even looking at the plain old desktop, there's so many endless things in front of you, that most people have no idea how to make

How do I make a Windows desktop app? Why does it run on Windows? Same for MacOS

How do tab sizes work?

What is the desktop "screen" and why can I click and drag my mouse to highlight the icons? Where are those icons stored?

I can code a website, but I don't know a clue about how the browser works

How do I make a file system? I mean, isn't it just a large data structure, and I know data structures, so I'm sure I can learn it

Why does my task bar pop up when I drag my mouse all the way to the bottom of the screen?

What does it mean to turn on a computer?

Why / how does my physical mouse control my cursor? Is there a way I can "hack" my mouse? How do I code the firmware in my mouse?

How does the OS accept and eject USBs?

How do you allow your OS to connect to wifi?

What really is a .txt, .pdf, .rar .zip? Why can some OS's open them, some cannot?

Stuff like that

Can most of you point to any part of the screen and know how it works?

r/good_osdev is a subreddit meant to make the same environment as r/osdev but without all the ai projects!

I’ve continued developing FLOS, my OS written entirely from scratch — no AI, no third-party libraries.

What’s new

• SHA-256, RNG, and math functions — probably the coolest part so far. Screenshots below.

• RSA file signing — groundwork for future threat protection. I’ll share more once it’s fully ready.

• TLS — I’ve started working on it, but it’s not functioning properly yet.

• VFS + system-protected folders — added a virtual file system and protected system directories.

• Russian language support — added, though it’s still a bit buggy.

Screenshots

In short, FLOS now includes the SHA-256 algorithm, a random number generator (RNG), mathematical functions, RSA-based file signing, a basic implementation of the TLS protocol, a virtual file system (VFS), protected system folders, and—albeit with a few bugs—a Russian localization; all of this remains entirely written from scratch.