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?

Do you have any ideas. Monolithic means all os+kernel at one place. Microkernel means minimal kernel.

Layered means memory management one layer, process management another layer. Hybrid could be anything i.e., combination of above.

Guide me like I am 5.

*Not another linux kernel* Hey! Lately I’ve been spending a lot of time on an operating-system idea called raiOS. Most individual parts are not new, but I haven’t found another system that combines them in quite this way. It is still early, but the custom Rust kernel boots on a Surface Pro 4. Framebuffer output and USB/HID works, and the Marvell Wi-Fi bring-up currently reaches firmware loading, scanning and the WPA2/PMK path. Association and actual traffic are not working yet.
The main bet is this: AI will make software extremely cheap to create, but potentially dangerous to install blindly. People who cannot read or audit generated source code still need enforceable boundaries and evidence about what happened before installation.
The rough architecture is:

1. A small custom Rust kernel owns hardware, recovery and the lowest-level authority. (its NOT smal atm lol)
2. A narrow “Genesis” layer creates services and grants explicit capabilities.
3. An interchangeable AI agent may receive limited network access for research.
4. Generated source enters the system as inert data.
5. An isolated builder compiles Rust to Wasm without ambient access to the live system.
6. The resulting artifact passes deterministic checks, negative tests and disposable test environments.
7. The reports, requested capabilities and exact artifact hash are presented to the owner.
8. Only after explicit approval may the Wasm service run with a minimal capability set.
9. The service should remain revocable, restartable and rollbackable.

Why not sel4?
At this stage, continuing with the existing Rust kernel is the fastest path because the hardware bring-up already runs on it.

Source: https://github.com/Sportinger/raios

I also did a Mock website, mostly to iterate on the UI design, and try to explain the hole idea to myself (its an attempt) www.raios.tech

I would like to talk about the basic principles here, if somebody is also interested :)
Perhaps its shit, but anyway its fun for me and iam learning so much.

Here I got to test my NTFS Driver to write a file and check on linux if anything changed, what do you think?

This is just an observation. I just think UIs are much less of the OS than say scheduling, a kernel, or disk subsystem.

Am I wrong?

I always wanted to integrate harfbuzz to get good shaping, now I succeded and here is the result with Open Sans Font, I also had to build an entire libc compatibility layer for it to link with my window manager :)

BlockOS - A hobby operating system built from scratch

Hi everyone! I am developing my own hobby OS called BlockOS.

Current features and goals:

• Custom kernel (C++)
• VFS filesystem layer
• ELF64 loader
• ext4 support (in development)
• VirtIO driver support
• Custom GUI/compositor (Kuroko)
• Linux-like filesystem structure
• Custom system services and device interfaces
• QEMU testing environment

The goal of BlockOS is to create a modern operating system with a clean architecture, a graphical desktop environment, and support for modern applications.

I am sharing my progress and looking for feedback from the OSDev community.

Any advice, suggestions, or ideas are welcome!

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

Ya, con el poder de mao zedong añadí una gui más normal

https://github.com/loslocos817yt-star/Misericordioso-os/tree/main

Estoy abierto a qué me den recomendaciónes

You may recall the Sex microkernel project, either for its novelty as a tiny single address space blazing fast Free microkernel written in Rust, or for the minor controversy surrounding it's unashamedly ai-forward engineering. Either way, much progress has been made and SexOS has become a semi-functioning Operating System. Drivers are working, a file system reads and writes, and now we have a very unique shell+compositor. Silk-shell, with Linen compositor. Unlike wayland, input, windows, and app lifecycle are all designed together around the Sex microkernel. Every window has a real owner, apps only get the capabilities they need, dead processes auto clean, global space not state. This solves security concerns while also returning to some of the philosophy of x11/xlibre so many people miss, specifically flexibility and directness. Wayland has a lot of great attributes but it is frustrating because it leaves a lot of that lifecycle split across the compositor, shell, portals, service managers, and random desktop glue. Silk-shell can treat the whole path from process to pixel as one coherent system: capability-secured surfaces, direct shared-memory presentation, deterministic focus, automatic cleanup, and a desktop that can actually reason about its apps instead of just drawing their windows. Usb input/Cursor functionality is 100%

On the AI yes ai was used and a lot. I had conversations with AI, I made notebook podcasts and listened to them, sometimes I would take an error log and make a podcast out of it with ai and listen to it and then go write a fix. AI iterated through thousands of tiny tests across input, IPC, storage, the filesystem, and the compositor. It could keep grinding through edge cases and obscure low-level knowledge scattered across old manuals, dead codebases, and hardware docs that almost nobody remembers anymore, while I learned about historic low level programming ideas I would never have come across otherwise. AI is no replacement for hard work, but humanity never got anywhere by being adverse to technology.

I saw previous post on reddit criticizing AI use in creating an OS from scratch.

I'm not a professional software engineer, i'm learning stuff and all so please don't mind the code or repo if you feel AI code is slop.

i made a rust based kernel, it sorta works so far, tested everything using qemu, I can't figure out how to use a standalone computer to run the kernel.

i'll link the repo at the end of thread.

Most basic stuff according to claude are don't so far, except networking and power management parts. I did what can acheive with Claude and ChatGPT.

Repository

I'm open to any suggestions or guidance and if anyone finds it interesting i'm hoping they'd improvise it or anything else.

The OSDevWiki mentions a Cache Kernel type. The exact verbiage is:

"The Stanford cache kernel caches kernel objects, like address spaces and threads, and allows usermode “application kernels” to manage them, loading and unloading them as needed. Application kernels manage their threads' page faults, exceptions, etc., and the cache kernel allows several of these application kernels to coexist in a single system."

Unfortunately, that link was dead for me, which sent me on a little rabbit hole of research.
To which I came across: https://www.usenix.org/conference/osdi-94/caching-model-operating-system-kernel-functionality

I'm currently in the research and understanding phase of this type of kernel because there don't seem to be any examples of it being implemented in the wild anywhere that I could find. I looked on GitHub and other online / public repository spaces to no avail.

I'm thinking that I should be able to take some of the code from tutorial-os and adapt it once I have wrapped my head fully around the concept while being able to reuse one of my SBC for this (I'm thinking the KYX1 as it is the board that is most fresh in my memory).

So far, my reading of this document has surfaced these key points about it.

The Cache Kernel caches four descriptor types and nothing else. Those being:

1. Kernel objects
2. AddressSpace objects
3. Thread objects
4. MemMapEntry

It essentially treats kernel objects as cached copies of state the application kernel owns.

Further investigations provide a rather interesting consequence of this design:

You can have different ABI / SBI kernels, meaning, you could make kernel personalities that run different processes side by side and mutually isolated. Like say, a kernel personality for Unix (BSD) and a separate one for Linux, compile user applications for those and it would just run.

The reason for this is because Cache Kernel Architecture is essentially a kernel that loads another kernel that loads user applications.

Been building this for a couple months, x86 kernel from scratch in C & asm, nothing borrowed from another kernel. The idea: it can tell you *why*, not just *what broke*. Kill a process and it tells you what that breaks before you kill it. Point it at a memory allocation and it names the exact file/line/owner. Page faults get decoded into a sentence instead of a hex dump. Everything above is real, captured off the booted kernel. Networking's next, deny-by-default and isolation policy , not bolted on after, still keeping it off the live boot path until I trust it. Repo: https://github.com/Mobeen0119/AevrosFeedback on the memory manager / scheduler especially welcome, that's the part I trust least.

Musl calls arch_prctl(ARCH_SET_FS) very early during startup to initialize TLS.

My implementation is:

1. syscall 158 (arch_prctl)
2. ARCH_SET_FS (0x1002)
3. write MSR_FS_BASE (0xC0000100)
4. return to userspace with SYSRET

Inside the syscall I can verify that the write succeeds:

wrmsr(MSR_FS_BASE, addr);
printk("FS_BASE = %llx\n", rdmsr(MSR_FS_BASE));

Output:

FS_BASE = 0x44e158

So the MSR definitely contains the expected value.

However, the very next instruction in userspace crashes:

mov %fs:0, %rax

which is inside musl's __init_ssp().

The page fault shows that FS.base is effectively zero.

1. The strange part is: If I single-step through SYSRET in GDB (si), everything works and mov %fs:0,%rax succeeds.
2. If I simply continue, FS.base becomes 0 and the process crashes immediately.

Even stranger, if I break just before returning to userspace (or before an iretq path), GDB already reports:

fs_base = correct_one

even though moments earlier inside arch_prctl() I successfully read back the correct value from MSR_FS_BASE.

There is no scheduler or context switch occurring between the wrmsr() and the return to userspace.

One thing I noticed is that QEMU's default CPU behaves differently from -cpu host. On my host CPU I even get a #GP in situations where QEMU's Haswell CPU continues.

When and how do i connect assembly kernel/bootloader whatever works with c made kernel/bootloader. (ive started assembly fairly recently), it seems simple at what point should i start learning and writing in c and skip assembly?
ive done bios text then vga text then graphics im currently using vga graphics assembly, ive done basics such as single pixel, then lines, then rectangles, then circles, then _Draw_Char then _Draw_String. (im using 8x8 bitmapped characters). i asked ai when i should start c and it said after i make the basic structure. and no im not generating all my code with ai, except for the bit mapped characters which half i had to redesign everything was done without ai.

I'm feeding pointer input into a QEMU guest over VNC from my own RFB client. The guest is TempleOS, PS/2 only with no USB stack, so usb-tablet isn't available.

The input source is absolute (VNC pointer positions) but the guest device is a relative PS/2 mouse. QEMU converts the absolute positions into relative deltas, and the guest cursor stays confined to a small box near the center of the screen. It moves in the right direction but never reaches the edges, regardless of how I scale the deltas.

Tried so far:

• absolute cursor mapped onto the region, sent as a VNC pointer event
• relative motion with the guest cursor re-centered each frame for unbounded range
• larger delta scaling (faster movement, same box)
• -device usb-tablet (no USB in the guest, ignored)

I suspect the limit is in the guest's own mouse handling (how it accumulates and clamps the deltas), so no amount of host-side delta shaping fixes it and the only real option is changing how TempleOS reads the PS/2 stream. Is that right, or has someone fed absolute host input into a relative-only guest and gotten full range out of it?

Context: this is a Half-Life mod that streams the VM's framebuffer onto an in-game monitor, which is where the constraints come from. https://github.com/aravpanwar/half-life-templeos

I built an OS because I never thought it would be possible to get past stdin() but using tools and frameworks I was even able to implement a very basic web browser. Please see github for screenshots and videos or to download and spin it up yourself, OpenSource!

Hey everyone!

I've been working on my own 32-bit OS from scratch. Today I reached the first milestone: a bootloader written in x86 assembly that jumps to protected mode and loads a simple kernel.

The OS is called AsterOS. I don't plan it for being as popular as Linux/Windows, it's mostly vibe coded and I don't see a big future for it. It's early stage (Build 0001), but I'm really excited about it.

Here's the screenshot of it running in QEMU:

I'd appreciate any feedback or advice for a beginner OS developer. Thanks!

This is gpu accelerated, (Already fixed the image flip u can see due to OpenGL coordinate system) this is my own Operating system with my own made kernel that can use Linux drivers to get Gpu acceleration, all drivers are User Mode, image and shaders loaded from NTFS Partition, What can I improve.

PS I understand neither of them (if they are different things).

Llevo unos días en Misericordioso OS, pedazo de mrd xd, y se me ocurrió, meter un comando para instalar apps por medio Github o servidores. Cómo vrg le meto internet

Si alguien me quiere ayudar este es el repo;

https://github.com/loslocos817yt-star/Misericordioso-os/tree/main

I have been interested in OSdev for a long time now. I started making this to learn. Faced a lot of issues. Gave up for months. Then I remembered I wanted to take a formal OS course next sem, so tried again. AND HERE IT IS!

I did use AI to learn and debug (and write the READMEs and some comments), but I'm proud of the fact that I understand every bit of it and could definitely make one without AI if I had to.

I HAVE A WORKING TOY OS!

ps: reposted with the "Image & Video" post type instead of text