I've recently learned about those projects that attempt to run a userland of one OS on another kernel or vice versa, such as Debian/kFreeBSD, which iirc attempted to run the GNU userland on a FreeBSD kernel, and I'm wondering, what use does this have?

Hi everyone! I've been working on Silver Microkernel (WerewolfOS), a microkernel written in Rust from scratch for AArch64 (QEMU virt).

**What works:**
- Microkernel architecture: High-Half MMU, W^X, PAN, Capability-based IPC.
- Ring 3 everything: UART, VirtIO-blk (disk), VirtIO-net (network) are userspace servers.
- SFS: A custom file system. `ls` reads actual files from the disk.
- Networking: Integrated `smoltcp`. You can run `ping 8.8.8.8` and get `PING 8.8.8.8: OK`.
- Graphics: Just got `ramfb` working. The screenshot shows a custom "Engineering Menu" (like the old iPhone Field Test mode) rendered by my Ring 3 graphics driver with double buffering.

Everything is written from scratch (no Linux, no POSIX, no std). It's been exactly 6 days since the first `_start`.

**Repo:** https://github.com/vvirei333/Silver-microkernel

Next steps: VirtIO-tablet driver for mouse input, then porting Doom.

Any feedback on the architecture or memory management is highly appreciated!Hi everyone! I've been working on Silver Microkernel (WerewolfOS), a microkernel written in Rust from scratch for AArch64 (QEMU virt).

Finally got FreeBSD running on ATOMS OS

This took me almost 3 weeks. Not even kidding.

I'm testing on my ASUS PRIME B760M-K with an i3-14100F, and getting FreeBSD 14.1 to boot inside my own VMX hypervisor has been one hell of a ride.

I had Claude, Gemini and ChatGPT helping me, and even then, we kept hitting new problems. First CR0, then RSP, VM exits, virtual PCI, ACPI, VirtIO disk reads, root mounting… and sometimes PXE decided to stop cooperating too 💀

Fix one thing, reboot, hit another problem. Repeat. A LOT.

The hardest part wasn't just getting FreeBSD to start. It was figuring out why it failed at each stage on actual hardware. QEMU helps, but the physical machine always has the final say.

Today I finally got the FreeBSD "#" root prompt running under ATOMS OS on the actual machine.

Still a lot left to do, but man, after 3 weeks of this, seeing that prompt felt amazing.

VMX is no joke.

Small progress update: managed to get actual GNOME running on top of Chimera with Wayland and Mutter.

; UEFI Bootloader using FASM Assembly
format pe64 efi

entry start

; EFI Constants
EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL = 0x00000001

EFIERR = 0x8000000000000000
EFI_INVALID_PARAMETER = EFIERR or 0x2


section '.text' code executable readable
start:
  push rbp
  mov [image_handle], rcx
  mov [system_table], rdx

  ...

  ; Get our loaded image protocol interface structure.
  ; Invoke ST->BootServices->OpenProtocol() function.
  mov rax, [system_table]
  mov rcx, [rax + 96]
  mov r10, [rcx + 280]

  mov rcx, [image_handle]
  lea rdx, [EFI_LOADED_IMAGE_PROTOCOL_GUID]
  lea r8, [boot_img]
  mov r9, rcx
  sub rsp, 32
  mov eax, EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL
  push rax
  xor eax, eax
  push rax
  call r10
  pop rcx
  pop rcx
  add rsp, 32
  mov rcx, EFI_INVALID_PARAMETER
  cmp rax, rcx
  je .hang

  ...

.hang:
  jmp $

  ...



section '.data' data readable writable

image_handle dq 0
system_table dq 0

; Image that we booted from.
boot_img dq 0

EFI_LOADED_IMAGE_PROTOCOL_GUID:
  dd 0x5b1b31a1
  dw 0x9562
  dw 0x11d2
  db 0x8e, 0x3f, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b

Hi in my UEFI bootloader using FASM Assembly, I am trying to get my loaded image protocol interface structure using BS->OpenProtocol() function call. I am getting `EFI_INVALID_PARAMETER` as the result. As per my checks, the handle, the protocol and the interface are not NULL and I am passing the 5th and 6th arguments in stack from right-to-left and they are 8-byte aligned too. What am I missing? Any idea? 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

Hey everyone,

I'm working on Silver Microkernel — a bare-metal microkernel in Rust (no_std) for aarch64 (QEMU virt, Cortex-A72).

My goal is to build a secure foundation for an OS that can eventually run Android apps (via Waydroid) without legacy bloat. I'm deliberately avoiding POSIX in the kernel and x86 legacy.

Architecture: * True microkernel: Kernel only handles scheduling, MMU, and IPC. * Init Server (silverd): PID 1 spawns the nameserver (scout), shell (howl), and drivers. * Ring 3 Drivers: The UART driver (howler) runs in EL0. It maps MMIO, binds IRQs (GIC INTID 33), and communicates via IPC. The kernel does not touch the UART hardware. * Security: Capabilities (CAP_MMIO, CAP_IRQ), W^X, PAN, High-Half MMU (TTBR1/TTBR0 split). * Infrastructure: Contiguous DMA (Normal Non-Cacheable) and PCI ECAM mapping are ready. I'm currently implementing the Virtio-blk driver for persistent storage.

The screenshot shows the shell running in QEMU (I can't post images in this sub directly, but the README has one).

Repo (MIT): https://github.com/vvirei333/Silver-microkernel

I'd love feedback on the IPC design and handling async events (IRQ + IPC) in Ring 3 drivers. Thanks!

les go 🥹️

I've been building FaceID@NIM (Neural Identity Matching), an experimental facial authentication system for Ubuntu/GNOME using Rust, C, and Python.

Features so far:

\-Custom PAM module for Linux authentication

\-Rust daemon for authentication policies and secure template management

\-Face recognition and liveness detection

\-GNOME integration and a settings application

\-Audit logging and password fallback

It's still in pre-alpha, and I'm actively testing its security, reliability, and camera compatibility. It's not intended for production use yet.

I'd appreciate honest feedback from the Linux community, especially on the architecture, potential security issues, and features worth adding.

🔗 GitHub:

https://github.com/Gaurav-x111/faceid-nim

If you're interested in Linux internals, Rust, or computer vision, I'd love to hear your thoughts. Thanks! 🚀

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](mailto:contact@vedaos.org).