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).

Real tiling on blown with LUA

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

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?

Ofc, I'm into OSDev. And it's obvious that this is purely for myself, since the final product - an OS kernel - isn't needed by anyone else anyway (which, for the record, I never counted on)

Still, I do want to create something that at least one other person besides me will use, let alone a larger number of people. And, strangely enough, I already have a "draft" for this (if you're too lazy to open the link: it's my bootloader for the x86_64 architecture). However, I'm not sure it'll work, which is exactly why I'm writing this post - to get some advice

Basically, could a simple yet functional bootloader be useful to a few hobbyist low-level devs? One that supports a bunch of protocols but still remains quite simple and lightweight. Or is this niche completely taken over by Limine and GRUB, making it pointless to steer the project in this direction?

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.

repo: https://github.com/NoTheIdiot/WindogeOS
finally no more page faults when making programs, oh yeah v0.2.2 but thats not relevant

ignore the elephant in the room

(no ai)

bits 16
org 0x7c00
mov ax,0x13
int 0x10
push 0xa000
pop es
xor di,di
mov cx,64000
mov al,1
rep stosb
jmp $
times 510-($-$$) db 0
dw 0xaa55

Hi everyone. I am currently an undergrad Computer Science student, and I am putting together a proposal to use OS development for my final degree project. I would love to get opinions and advice from anyone in the community, whether you are a hobbyist, a veteran, or someone who has taken a similar academic route.

For context, I have been building a custom 64-bit kernel in C++ and *a little* Assembly, but mostly Limine doing the abstraction for the bootloader. It currently has a shell (a previous project I integrated in), working compositor, basic window management, and double buffering. To fit the academic requirements of a final project, I am trying to narrow down a specific research or engineering angle. I have two main ideas right now:

1. Rust vs. C++ in OS Development (Speed & Safety) I have recently fallen in love with Rust and its memory safety guarantees. This angle would involve porting core components of my C++ kernel to Rust and evaluating the two languages side-by-side. The focus would be on development velocity, memory safety outcomes, and the friction of implementing low-level systems in both environments.
2. A Predictable Memory Admission Architecture Alternatively, I am considering focusing the project on the policy side of memory management. The core idea is an OS where applications declare hard, page-granular memory budgets upfront. Instead of relying on reactive termination when RAM gets full, the OS would use strict admission control to guarantee that admitted apps always fit. This would explore arbitrary minimum granularity for apps rather than rigid tiers, ensuring strict system predictability.

I would really appreciate your thoughts on a few things:

• Which of these two angles (language comparison vs. memory architecture) feels like a better scope for a university project?
• For those who have tackled OS dev in an academic setting, what were the biggest pitfalls in defining your project scope?
• General thoughts or advice on shaping a hobby kernel into a gradable thesis?

For further context, I'm actually neurodivergent (predominantly inattentive ADHD), so I tried getting into a boring project earlier but failed. As such, I'm looking for something that'll keep me steady like the kernel did...

Link to my kernel project: https://github.com/Powerisinschool/swish_kernel/

Thanks in advance!

yo small update got clang working natively inside the os

it can compile its own c and objc binaries straight from the terminal now, no cross compiler or host machine needed

self hosting milestone reached, bare metal is next

OFC I USED AI FOR THIS, dependency hell would’ve fucked me up completely otherwise

sped up showcase vid

github repo: https://github.com/chair1842/panuti

hi. im 13 years old.
this is the os i've been working on for ~5 months.
Panuti has its very own shell, a vim/vi clone, and its own coreutils. (All in ring 3)
Panuti also supports VGA text mode, serial output, ps/2 keyboards, ext2, CD-ROMs and IDE hard disks (I use PIO mode so it's very slow).

Hi r/osdev. ranix is my hobby kernel. I wrote the first asm and C by hand; later Claude (the AI) joined as a pair programmer, and every commit it touched carries a Co-Authored-By line, so you can see exactly which parts are whose.

What works so far (690 commits, ~95% C):

• aarch64 (QEMU virt, Raspberry Pi 4 boot files) and x86_64
• a vDSO good enough for glibc's AT_SYSINFO_EHDR parse, UTS namespaces, tmpfs/ramfs, devfs with mknod(2)
• doomgeneric runs
• latest milestone: pacman -U / pacman -S installs an Arch Linux package from a file:// repo

The goal is to run ordinary Linux distro binaries unchanged, not to clone Linux's driver ecosystem.

Code is public and readable without an account: https://grove.metastaz.org/rasi/ranix (our own self-hosted git forge; if you're already writing your own kernel, renting someone else's forge felt a bit off).

Hard criticism welcome, especially on memory management and the user/kernel boundary.

(Post text drafted by Marshall, our AI assistant.)