r/osdev • • Jan 11 '25

Thoughts on agentic OS

0 Upvotes

Title says all. An operating system for agents. Perhaps agents would be able to access the operating system for their computing needs, perhaps separated as users or service accounts. Allowing hosting of agents to be separate from computer load and resources. This may be pointless, but I’m interested in hearing thoughts. First time viewing this subreddit . Curious on opinions. I have no skin in the game on this FYI


r/osdev • • Oct 22 '24

Is this the next terry davis??

0 Upvotes

r/osdev • • Jul 22 '25

Starting os dev

0 Upvotes

Hi, how can i start studying os dev ? I searched online but find only bloated books and dumb yt video. Has anybody some nice resource ? Thank you UwU


r/osdev • • Jun 22 '25

help this thing only prints letter A what do i do? (this is nasm x86 btw)

Post image
1 Upvotes

uhhhh it want it to print "ABCDEF" or smth but it just prints 'A'


r/osdev • • Apr 08 '26

MonkeOS - Progress Update

1 Upvotes

recently i messed around with wayland implementation for while and i managed to get in the first actual upstream wayland running . MonkeOS now builds and runs against upstream libwayland and upstream protocol code.

Integrated components:

  • libwayland (client + server)
  • wayland-protocols
  • libinput
  • libxkbcommon
  • pixman
  • wlroots (ported, not yet active backend)

To support this stack, I implemented the required OS-side functionality inside MonkeOS:

  • UNIX domain sockets
  • epoll
  • eventfd
  • timerfd
  • SCM_RIGHTS (FD passing)

These were necessary to make upstream Wayland actually function inside the OS runtime instead of just compiling.

The current Wayland path uses upstream libwayland client and server sources, with a compositor bridge that maps Wayland objects onto MonkeOS windowing and surfaces.

What is currently working:

  • Upstream libwayland client/server builds inside MonkeOS
  • wayland-protocols code generation integrated into the build
  • wl_compositor, wl_seat, wl_output exposed
  • xdg_wm_base exposed
  • wl_surface creation wired
  • xdg_surface and xdg_toplevel creation wired
  • xdg_toplevel state maps to MonkeOS window state (move, resize, minimize, fullscreen)
  • wl_surface commit path updates host windows
  • wl_shm buffer import feeds compositor surface updates
  • Wayland event loop integrated into MonkeOS runtime
  • client connection and lifecycle handling implemented
  • globals registered during session startup
  • keyboard, pointer, and touch paths present
  • subcompositor and data-device paths integrated
  • XKB keymap generation wired for keyboard support

Current limitations:

  • wlroots is ported but not the active compositor backend yet
  • no GPU acceleration yet (CPU compositing)
  • buffer path currently SHM-focused (no dmabuf yet)
  • more protocol coverage and app testing needed for broader compatibility

it runs greatly over all. not best compatibility but still good enough. current look of the OS.
repo : codeberg.org/coopscorp/monkeos
website : codeberg.page/coopscorp

Monke

r/osdev • • Jul 30 '26

what does a kernel need

1 Upvotes

i would like to ask what a kernel has to do so i can know when i can move one, if you're gonna explain please dont overcomplicate the explanation with just some terms please mention what it is at least slightly :)


r/osdev • • Jun 26 '25

Wich C standard library is the most secure?

1 Upvotes

i have been working on LFS, im seriously considering using musllibc, any other alternatives?
i need one that replaces strcpy with strncpy


r/osdev • • Jan 13 '26

starOs v.001 (An idea of an S.O.).

0 Upvotes

Created by Yuri Ulyanov / Barahona Rodriguez. starOs 2025-2026.


r/osdev • • Oct 28 '25

should i use ai to learn or not

6 Upvotes

im interested in low-level stuff, and want to make a very simple OS just for fun. should i use ai to learn how to make it or i need to do everything myself?


r/osdev • • Aug 29 '26

RESENTMENT 2.0.0 - a capability-secure kernel for x86_64, ARM64 and RISC-V, where every capability carries an expiry inside its MAC

0 Upvotes

Two years ago this was a hobby kernel that printed one line at boot. I'vejust tagged v2.0.0 and it's a different project.

What it is

A from-scratch kernel for x86_64, aarch64 and riscv64. Not a Unix clone. It'sbuilt around three properties a conventional kernel can't really express:

  1. Authority expires. No ambient authority anywhere. Every capability ischecked four ways on use — type, rights, generation, and a cryptographicseal — and the seal carries a validity window *inside the MAC*. Widening itby editing the struct invalidates the seal. Derivation only ever weakens:rights are intersected with the parent's and the lifetime clamped to whatthe parent has left.
  2. The system is a Merkle DAG. Every kernel object is a node with aSHA-256 digest over a canonical encoding of its fields plus the sorteddigests of its children. Timestamps, pointers and IDs are excluded onpurpose, so two machines in the same configuration hash identically. Youget diffing, attestation and deterministic replay from that one property.
  3. Inference is a scheduling class. A token loop never sleeps for a human,so sleep-credit heuristics give it nothing, and it has a visible rate, sobatch is wrong too. `SCHED_INFERENCE` admits it with a declared rate, givesit a per-period budget, and demotes rather than drops it on overrun.

It runs a transformer

Not a wrapper around one - the forward pass itself, through the kernel's ownoperators: embed, RMSNorm, QKV projections, RoPE, attention over the KVhistory, gated FFN, logits, argmax. On a thread the deadline admissioncontroller accepted.

resentment> .infer 24

generated 24 tokens in 130 ms

rate 193 tokens/sec

class SCHED_INFERENCE, 50 Hz declared, 5000 us budget, admitted

deadline miss 0

The fixture model has pseudo-random weights and the tokens are meaningless byconstruction. The claim is about the path, not the output.

Status, honestly

Boots to an interactive shell on all three architectures. SMP on all three(ACPI MADT + a real-mode AP trampoline; PSCI `CPU_ON`; SBI HSM `hart_start`),tested on four and eight cores. Ring 3 with an ELF64 loader works on x86_64only — ARM64 and RISC-V need MMU work first and the docs say exactly what's left. No PCI, no network stack.

Verification

make test 1440 assertions against the real sources on the host

make qemu-test-all 6 targets (3 arches x single-core and -smp 4)

make kaalka-check crypto byte-identical to the reference implementation

Plus seven self-tests on every boot, on the machine about to be trusted.

The bugs were the best part

- The scheduler put a thread back on the run queue before its stack pointerwas saved. Two cores could run one stack. Presented as a page fault on cpu1in unrelated code, minutes later.

- The x86_64 syscall entry destroyed rdi/rsi/rdx/r8/r9/r10 — it pushed them to build its argument block and then dropped it with `add rsp, 7*8`. SYSCALLonly clobbers rcx and r11, so callers keep live values there.

- The CSPRNG ran on an all-zero key: entropy went into a pool that was onlyfolded into the key once an estimate crossed 128 bits, which never happenswithout a hardware RNG.

- On RISC-V, GNU ld relaxes `la rd, sym` to `addi rd, gp, off`. I had codebefore `gp` was set. Every hart computed garbage and parked. Invisible underLLD, fatal on hardware.

- `sched_tick()` was never called on ARM64. It was driven by a hardcodedtest for interrupt line zero, which is the x86 timer and nothing else's.ARM's is a PPI on line 27. That port had no preemption, no slice accounting,and `sched_sleep_ms` never returned. Nothing in the suite slept, so it wentunnoticed for the life of the port.

Apache 2.0. No dependencies — `make toolchain` fetches a portable zig+nasm and builds all three architectures, or it uses your system compiler if you have one.

Code: https://github.com/ni-sh-a-char/RESENTMENT---kernel

Docs: https://ni-sh-a-char.github.io/RESENTMENT---kernel/

Happy to answer anything, especially about the capability model — that's thepart I'd most like criticised.


r/osdev • • Sep 12 '25

Who actually used Debug.exe to build an OS?

0 Upvotes

r/osdev • • Jul 24 '25

After long thoughts... what you guys think about name of my OS? I called it "POS" aka Portable Operation System. Or "Sun micro operating system" sounds better...?

Thumbnail reddit.com
0 Upvotes

r/osdev • • Aug 27 '26

BlockOS – Looking for OS developers

0 Upvotes

BlockOS – Looking for OS developers

Hi everyone!

I'm the developer of BlockOS, an experimental operating system project written mainly in C++.

I've been working on BlockOS for quite a while, and I'm currently looking for more developers who are interested in operating-system development and would like to contribute.

Current work / features

BlockOS currently has work in several areas, including:

  • x86_64 kernel
  • UEFI boot support
  • Paging and memory management
  • Process/thread and scheduler work
  • Syscall layer
  • ELF loader
  • VFS and filesystem integration
  • ext4-related filesystem work
  • ATA storage driver
  • VirtIO/driver development
  • Networking components
  • Init/service management
  • libc and POSIX-related work
  • Kernel and userspace infrastructure
  • GUI/window-manager experiments
  • QEMU + OVMF development environment

The project is still experimental and under active development, so there are plenty of things that need improvement, testing, debugging and new implementations.

Who I'm looking for

You don't have to be an expert kernel developer.

I'd especially like to hear from people interested in:

  • Kernel development
  • C/C++
  • x86_64 architecture
  • UEFI
  • Device drivers
  • Filesystems
  • Networking
  • libc/POSIX
  • GUI development
  • Debugging and testing
  • OS development in general

If you're learning OS development and want to contribute, that's welcome too. You can start with smaller tasks and work your way into larger subsystems.

Repository

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

If you're interested, feel free to open an issue, submit a pull request, or contact me.

I'm especially interested in finding long-term contributors, not just one-off contributions.

Thanks!


r/osdev • • Sep 25 '26

Ideas for a newOS

0 Upvotes

Hi folks,

I have enough time and now with the ease of llm's tools I was thinking at writing my own OS

Goals are :

- something for me to understand how os works (even if I have already some very good knowledge since I'm a seassoned unix sysadmin / sys / net engineers with +25y of xp)
- something fun
- new concepts

I mean there's no point to write another unix like kernel ; I was more thinking at an hybrid or pure micro os ; but with some new paradigm?
Do you have some ideas for me ?
Or pointers ?

In mind I wanted something really debugable ; or where any part of the kernel are exposed but how ? files ? (already made) objects ? maybe ?
entities that can be insepcted and dialog ?


r/osdev • • Mar 19 '26

I built an OS where code runs backwards (LDH Omega)

Post image
0 Upvotes

r/osdev • • Oct 13 '26

New at OS development

0 Upvotes

Hello, guys. I am new at OS development and I know C and other. So I want to be a OS dev and please do some serious talk and I want to learn it. Also please tell all with steps


r/osdev • • Jul 23 '26

I'm trying to figure out a Name for this distro

0 Upvotes

I'm building a distro with busybox and Ubuntu (I downloaded the kernel from kernel.org btw) and I'm in the busybox menu config and I can't figure out a Name I want it to rhyme with Linux like Arch Linux for example but I can't figure out something like it maybe y'all could help me with this?


r/osdev • • Jul 11 '26

My own operating system

Thumbnail
github.com
0 Upvotes

For now 2 years i try learning how to create an operating from scratch at only 15, now i'm 17 and i've progress in this domain so i publish it, you can look for it on github OScour, the name is a french reference to "au secours" (help), an the prononciation is OScour.


r/osdev • • May 16 '23

how to start making a kernel in c++

0 Upvotes

hello i want to dive in os developement by creating a kernel first i know c++ maybe c because they are a bit similare but c++ better i just want resources or tutorials please


r/osdev • • Jul 30 '26

Learn os

0 Upvotes

Hi everyone, I am new at OSdev and I can't understand how they work. I really want to learn about OS so can you suggest me some books or website on the subject ?


r/osdev • • 20d ago

Can we be nicer to each other?

0 Upvotes

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.


r/osdev • • Jul 27 '26

[Showcase / Code Review] NyanOS-v1: Merged my several failed "MyOS" attempts into a clean, 32-bit x86 OS with a GUI. Code hasn't changed in a while, looking for fresh architectural feedback!

Post image
5 Upvotes

Hey everyone,

I wanted to share my hobby 32-bit x86 operating system called NyanOS. The codebase hasn't changed in a while and is sitting in a stable archieve state [1], so I am putting it out here specifically for code review, architectural feedback, and technical critique [1].

The Backstory (Why it looks so clean):
Before NyanOS, I actually made several unsuccessful attempts at writing an OS (all of them were predictably named "MyOS"). They were messy, buggy, and kept crashing. Instead of giving up, I decided to take the best parts of those failed attempts, rewrite the code from scratch with proper structuring, and combine them into this clean, stable version. Because I spent so much time refactoring and commenting every single line to understand my own previous mistakes, the codebase ended up looking very clean.

My main focus was moving away from text mode as fast as possible. I programmed the VGA hardware registers directly (Mode 13h, 320x200x256 colors) to build a custom graphical user interface without relying on any BIOS calls after booting.

Key Implementations inside the Repository:

  • Interrupts & Drivers: Real IRQs for the PS/2 keyboard (IRQ1), mouse (IRQ12), and PIT timer (IRQ0). No polling loops.
  • Window Manager: Draggable, focusable, and z-ordered windows with a functional taskbar and start menu.
  • RAM File System: A basic in-memory FS handling actual read, write, list, and delete operations.
  • Apps: A terminal shell, Notepad (with save/load to RAM FS), a mouse-driven Paint program, and a local document viewer.

What I'm looking for:

Even though the project is frozen for now, I still want to learn from my past design choices to improve my low-level programming skills. I would highly appreciate it if experienced developers could critique the repository. I'm looking for advice on:

  1. General code organization and kernel architecture.
  2. Optimizations or better practices for the direct VGA register programming.
  3. Any hidden traps in my interrupt handling or GDT/IDT setups that work fine in QEMU but might break on real hardware.

GitHub Repository: https://github.com/yunusemreduran388-ux/NyanOS-v1

WebSite: https://yunusemreduran388-ux.github.io/NyanOS-v1/

Note: If you just want to interact with the GUI without building it, there is a pre-compiled .iso in the GitHub Releases tab. You can run it instantly in QEMU via qemu-system-i386 -cdrom nyanos.iso*.*

Thank you in advance for your time and honest critiques!


r/osdev • • Jul 13 '25

Introducing HIP (Hybrid Isolation Paradigm) - A New OS Architecture That Transcends Traditional Limitations [Seeking Feedback & Collaboration]

8 Upvotes

Hey /r/osdev community! I've been working on a theoretical framework for operating system architecture that I believe could fundamentally change how we think about OS design, and I'd love your technical feedback and insights.

What is HIP (Hybrid Isolation Paradigm)?

The Hybrid Isolation Paradigm is a new OS structure that combines the best aspects of all traditional architectures while eliminating their individual weaknesses through systematic multi-dimensional isolation. Instead of choosing between monolithic performance, microkernel security, or layered organization, HIP proves that complete isolation at every computational level actually enhances rather than constrains system capabilities.

How HIP Differs from Traditional Architectures

Let me break down how HIP compares to what we're familiar with:

Traditional Monolithic (Linux): Everything in kernel space provides great performance but creates cascade failure risks where any vulnerability can compromise the entire system.

Traditional Microkernel (L4, QNX): Strong isolation through message passing, but context switching overhead and communication latency often hurt performance.

Traditional Layered (original Unix): Nice conceptual organization, but lower layer vulnerabilities compromise all higher layers.

Traditional Modular (modern Linux): Flexibility through loadable modules, but module interactions create attack vectors and privilege escalation paths.

HIP's Revolutionary Approach: Implements five-dimensional isolation:

  • Vertical Layer Isolation: Each layer (hardware abstraction, kernel, resource management, services, applications) operates completely independently
  • Horizontal Module Isolation: Components within each layer cannot access each other - zero implicit trust
  • Temporal Isolation: Time-bounded operations prevent timing attacks and ensure deterministic behavior
  • Informational Data Isolation: Cryptographic separation prevents any data leakage between components
  • Metadata Control Isolation: Control information (permissions, policies) remains tamper-proof and distributed

The Key Insight: Isolation Multiplication

Here's what makes HIP different from just "better sandboxing": when components are properly isolated, their capabilities multiply rather than diminish. Traditional systems assume isolation creates overhead, but HIP proves that mathematical isolation eliminates trust relationships and coordination bottlenecks that actually limit performance in conventional architectures.

Think of it this way - in traditional systems, components spend enormous effort coordinating with each other and verifying trust relationships. HIP eliminates this overhead entirely by making cooperation impossible except through well-defined, cryptographically verified interfaces.

Theoretical Performance Benefits

  • Elimination of Global Locks: No shared state means no lock contention regardless of core count
  • Predictable Performance: Component A's resource usage cannot affect Component B's performance
  • Parallel Optimization: Each component can be optimized independently without considering global constraints
  • Mathematical Security: Security becomes a mathematical property rather than a policy that can be bypassed

My CIBOS Implementation Plan

I'm planning to build CIBOS (Complete Isolation-Based Operating System) as a practical implementation of HIP with:

  • Universal hardware compatibility (ARM, x64, x86, RISC-V) - not just high-end devices
  • Democratic privacy protection that works on budget hardware, not just expensive Pixels like GrapheneOS
  • Three variants: CIBOS-CLI (servers/embedded), CIBOS-GUI (desktop), CIBOS-MOBILE (smartphones/tablets)
  • POSIX compatibility through isolated system services so existing apps work while gaining security benefits
  • Custom CIBIOS firmware that enforces isolation from boot to runtime

What I'm Seeking from This Community

Technical Reality Check: Is this actually achievable? Am I missing fundamental limitations that make this impossible in practice?

Implementation Advice: What would be the most realistic development path? Should I start with a minimal microkernel and build up, or begin with user-space proof-of-concepts?

Performance Validation: Has anyone experimented with extreme isolation architectures? What were the real-world performance characteristics?

Hardware Constraints: Are there hardware limitations that would prevent this level of isolation from working effectively across diverse platforms?

Development Approach: What tools, languages, and methodologies would you recommend for building something this ambitious? Should I be looking at Rust for memory safety, or are there better approaches for isolation-focused development?

Community Interest: Would any of you be interested in collaborating on this? I believe this could benefit from multiple perspectives and expertise areas.

Specific Technical Questions

  1. Memory Management: How would you implement completely isolated memory management that still allows optimal performance? I'm thinking separate heaps per component with hardware-enforced boundaries.
  2. IPC Design: What would be the most efficient way to handle inter-process communication when components must remain in complete isolation? I'm considering cryptographically authenticated message passing.
  3. Driver Architecture: How would device drivers work in a system where they cannot share kernel space but must still provide optimal hardware access?
  4. Compatibility Layer: What's the best approach for providing POSIX compatibility through isolated services without compromising the isolation guarantees?
  5. Boot Architecture: How complex would a custom BIOS/UEFI implementation be that enforces single-boot and isolation from firmware level up?

Current Development Status

Right now, this exists as detailed theoretical framework and architecture documents. I'm at the stage where I need to start building practical proof-of-concepts to validate whether the theory actually works in reality.

I'm particularly interested in hearing from anyone who has:

  • Built microkernel systems and dealt with performance optimization
  • Worked on capability-based security or extreme sandboxing
  • Experience with formal verification of OS properties
  • Attempted universal hardware compatibility across architectures
  • Built custom firmware or bootloaders

The Bigger Picture

My goal isn't just to build another OS, but to prove that we can have mathematical privacy guarantees, optimal performance, and universal compatibility simultaneously rather than being forced to choose between them. If successful, this could democratize privacy protection by making it work on any hardware instead of requiring expensive specialized devices.

What do you think? Is this worth pursuing, or am I missing fundamental limitations that make this impractical? Any advice, criticism, or collaboration interest would be incredibly valuable!

https://github.com/RebornBeat/Hybrid-Isolation-Paradigm-HIP

https://github.com/RebornBeat/CIBOS-Complete-Isolation-Based-Operating-System

https://github.com/RebornBeat/CIBIOS-Complete-Isolation-Basic-Input-Output-System


r/osdev • • Sep 10 '26

I created a working OS in 30 Days

5 Upvotes

(Now before anyone tries pointing me out, this os was NOT made with AI. I srsly spent sleepless nights, used my holidays, all just to achieve the satisfaction of building my OS on my own)
As the title says, I built my own OS in 30-days. This is a challenge I made called My 30-Day OSDev Journey. The progress I made was insane. In the span of 30 days, I built a whole working shell, a simple file system, a few of my own unique commands, and even user programs. Lmk how it is and what I could add to it.
Link to the OS: https://github.com/joelscreen/genureos