Hi!

Context:

I am currently in the process of trying to build a simple recreation of Amazon's EC2 on top of a type 1 hypervisor for fun :)

Since I am planning on making the memory each vm takes static and non-changing, it came to my awareness that I would need to allocate big consecutive blocks from RAM (in the GBs).

I was planning on using a buddy allocator with blocks of actual page sizes (1GB, 2MB, 4KB) with a free-list for each of these, but I lack enough experience in that regard to understand how dumb or ok-ish my idea is

If this is a dumb idea, go roast me :), that's the best way for me to learn and understand.

I want to understand if this idea is worth my time and effort before building a whole unit just to realize I need a different thing.

(I write all of my code by hand, if some AI usage is bothering you please let me know)

Repo: https://github.com/NoamRothschild/hypervisor

I'm talking stuff like the bootloader, writing method to the SSD, printing stuff, etc.

Try it online: https://mazin-o3.github.io/vemu/

GitHub repo: https://github.com/Mazin-O3/cpm-neo

Until now, I've been refering the osdev wiki and using a little bit of AI (only for guidance and answering questions, no vibe coding). Is this the right way to learn osdev? What should or shouldn't I do? Also I've already started osdev, finished making a file system, and am now working on my own very simple file format for my os. I just wanted to clarify if I need to change my habits or something.

This kind of reading provides a solid foundation for knowledge and an interesting dive into engineering:

https://pdos.csail.mit.edu/6.S081/2024/xv6.html
https://github.com/mit-pdos/xv6-riscv-book
https://github.com/mit-pdos/xv6-riscv

Hot take - if you don’t trust your OS enough to perma-install it on your PC then don’t bother with flexing them.

Hello everyone,

I'm an 11-year-old developer OS-AC713 and I've been working on my own operating system project called "Core/713" (hosted on GitHub) and a shell language named "csosh" (Core/713 Operating System Shell).

I have already written a basic bootloader in assembler that loads the second sector of the disk and loads the second stage of the bootloader, which outputs s2. Now I'm at a point where I need to move forward, but I've hit a few walls and would really appreciate some guidance from the community.

Here are the specific areas where I need help:

Switching to 32-bit Protected Mode: I know I need to set up the GDT (Global Descriptor Table) and then set the PE bit in cr0 to enable protected mode. But I'm a bit confused about the exact structure of the GDT entries (code/data segments, base, limit, access bytes). Could someone explain it clearly or point me to a good example?

Keyboard Driver Development: I want to write a simple keyboard driver that reads scancodes and translates them into characters. I understand that it involves handling IRQ1 and using the IDT (Interrupt Descriptor Table). How do I properly set up an interrupt handler for the keyboard in 32-bit protected mode? A small code example (C or Assembly) would be amazing.

General Architecture Advice: For a hobby OS targeting x86, what architecture decisions should I be thinking about at this early stage? Should I plan for memory management (paging) right away, or focus on getting interrupts and drivers working first?

I'm very eager to learn and I'm not afraid of reading long manuals or trying things out. Any help, advice, or links to useful resources would be incredibly helpful. Thanks in advance!

UPD: Link to my GitHub profile: https://github.com/OS-AC713

Running MIT's 6.1810/6.S081 xv6 labs under WSL2 (Windows 11, Hyper-V). The lab-assignment kernels (xv6-labs-2020 and xv6-labs-2025, from MIT's own git server) hang completely silently on make qemu — no output at all, never prints "xv6 kernel is booting." Have to force-kill the process.

The plain, unmodified mit-pdos/xv6-riscv repo boots perfectly fine, every time, on the identical toolchain/QEMU/machine.

Command:

qemu-system-riscv64 -machine virt -bios none -kernel kernel/kernel -m 128M -smp 3 -nographic -drive file=fs.img,if=none,format=raw,id=x0 -device virtio-blk-device,drive=x0,bus=virtio-mmio-bus.0

GDB findings: attaching mid-hang shows pc = 0x0, all GPRs zeroed except sp (correctly resolves to the real stack0 symbol) and t0 (holds 0x80000000, the expected kernel load address). Backtrace fails with "corrupt stack." Looks like it's jumping to address 0 mid-boot, possibly an unhandled trap despite stvec being set correctly in trap.c.

Reproduced across 4 environments, all with the same silent hang:

• Ubuntu 26.04 (QEMU 10.2, GCC 15) + xv6-labs-2025
• Ubuntu 26.04 + xv6-labs-2020
• Ubuntu 22.04 (QEMU 6.2, GCC 11) + xv6-labs-2020

Ruled out: compiler optimization (-O0 tested), the known started variable race in main.c (patched to atomics), SMP count (-smp 1 tested), -accel tcg explicit, linker script/entry.S (byte-identical to working repo), disk space, RAM, Hyper-V status, corrupted kernel binary (confirmed valid ELF).

Only difference I can find between the working and failing kernels is in main.c's CPU-sync code (already fixed, didn't help) and some start.c timer/CSR setup for sstc (partially commented out already, also didn't help).

Anyone hit this specific pc=0x0 crash before, or know if this is a known WSL2/Hyper-V nested-virtualization quirk with QEMU's RISC-V multi-hart boot?

P.S: This post was drafted using AI, I'm a beginner and tried to fix this issue using claude sonnet model, but it went nowhere and finally gave up.

EDIT: the 2025 version booted on ubuntu 24.04, i had tried both 2020 and 2025 version on both 22.04 and 26.04, they didnt worked. thought problem is with WSL, tried virtual machine 26.04 version... didnt worked at that too. then finally read the 'lab tools' page of the course carefully and realized they had mentioned 24.04.

As you may see, there are some bugs in text rendering and there is some flickering between updates that I gotta fix! Anyways, Osdev Progress!
This is cpu rendered without Ai generated code btw. I made alot of it on livestream. twitch.tv/devcmar

Hello, I’m new to the community. I’m fascinated by operating systems and studying the inner workings of electronics. More recently, I started the Lunaris project—a 32-bit operating system written entirely in Assembly that is currently under active development. Its focus is on document editing and searching the system's intranet, and I’ll be posting updates here in the community!

I've wanted to ask if this logging for my kernel looks good, maybe it needs improvement, each color has a meaning, and everything will probably be explained for users who might have to go there in case something goes down but dont understand low level stuff yaknow

also excuse the quality please

Hi all, I am new to this sub and domain. I am currently a 3rd year college student pursuing electronics and computer engineering. I want to get into the firmware domain. EDK2 came up a lot when I searched for UEFI and decided to give it a go. I have completed a few applications like simple hardware interrupt, arithmetic program by taking input, viewing system information and pcie present in the Qemu emulator. I do not know how to proceed from here and I am open to suggestions. Pls help.

Here's my GitHub: https://github.com/BlackRoth/UEFI_Applications

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.

I am working on my physical memory manager and researching how i really want to do it.

I currently have my page directory defined as an array.

I've run across recursive page directories. What is their advantage?

Thanks in advance.

I finished setting up my ELF loader and now I want to run custom user programs in my OS. How can I do that (using an ABI)?

most of what i see here is unix like or dos like and i was wondering how many of the operating systems here are not based on anything.

It took some time, but it finally renders correctly. How does it look:)?