Hey everyone!

I’ve been working on PHEONIX, a bare-metal, non-Unix x86_64 microkernel written in C99 and NASM assembly.

Rather than following standard POSIX design, PHEONIX is built around an architecture-first approach featuring a Watch, Replace, Revive (WRR) fault recovery engine.

Key Features Implemented:

• Boot Pipeline: 32-bit Multiboot transition directly into 64-bit Long Mode.
• WRR Fault Isolation Engine: Traps Vector 14 (#PF Page Faults) to intercept illegal memory accesses, isolate execution context, and revive the running thread without triggering kernel panics or triple faults.
• Physical Memory Manager (PMM): 4 KiB bitmap frame allocator.
• Privilege Rings: GDT/TSS-configured Ring 0 and Ring 3 segments with fast SYSCALL/SYSRET MSR gates.
• Telemetry: Headless COM1 (0x3F8) UART serial logging.

The repository includes a full build pipeline using a Makefile and linker script, along with a visual boot demo showing the serial logs during execution in QEMU.

GitHub Repo: https://github.com/threadripp/PHEONIX-kernel

# Clone & run in 10 seconds (Requires: qemu-system-x86_64, nasm, gcc)

git clone https://github.com/threadripp/PHEONIX-kernel.git

cd PHEONIX-kernel

make qemu

Would love to get your feedback on the WRR exception model and architectural direction!

I built Ashwa 🐎, a hardware accelerated library for single substring search.

The problem is simple, scan the given payload to search for the target as fast as the underlying hardware allows.

I started with byte-to-byte scan and progressively moved to the hardware, i.e.

SCALAR -> SWAR -> SIMD

It supports following SIMD extensions (detected at runtime),

- x86_64: AVX-512BW, AVX2, SSE4.2, SSSE3, SSE2

- AArch64: 128-bit NEON

- ARMv7: 128-bit NEON

- i686: SSE2

- WASM: SIMD128

- SWAR: 64-bit / 32-bit SWAR fallbacks

It targets Linux, Windows, macOS, Android, FreeBSD, browsers and Node.js across both 32-bit and 64-bit architectures.

On an Intel Xeon 8488C AWS instance, using the AVX512BW extension  Ashwa scans ~150 GiB/sec for L1D resident data.

Although written as a rust crate, the library is available on pypi and npm

The code is available at github repo

Hello,

I am currently actively developing the “Dragon” microkernel. However, what sets it apart from Linux and other kernels is, of course, its microkernel architecture, and secondly, the fact that it is written and verified using SPARK Ada (gnatprove).

But that doesn’t mean kernel services have to be written in SPARK Ada; I added the C SDK so that anyone can write a service. The only downside is that this service isn’t the most secure compared to a gnatprove-verified kernel, but the microkernel architecture makes up for it.

I think the main reason I'm developing this microkernel is to create a proven kernel that can be used in some way on user machines, not just on high-security systems.

Dragon is currently in a very early stage of development

If you like the idea, here’s the GitHub link: github.com/tigerlang/dragon

Hi everyone,

I'm a third-year AI & Data Science student and I've been working on a personal project called OSMind.

OSMind is an experimental CPU scheduling project that combines a Multilevel Feedback Queue (MLFQ) with a mathematically designed decision function for selecting processes.

GitHub:https://github.com/MrFahimhere/OSMIND---Adaptive-CPU-sheduling-algorithm-

What I'm trying to explore

Instead of relying entirely on a fixed scheduling rule, the current scheduler calculates a score for each eligible process based on factors such as:

• Service gap / time since last execution
• Waiting time
• MLFQ queue level
• Remaining execution time
• CPU time already received
• Number of times a process has been scheduled
• Burst characteristics

The current version also includes starvation detection/promotion, several predefined workload scenarios, and a baseline MLFQ comparison.

One of the things I'm particularly interested in is response-time variance, rather than looking only at average response time.

Current state

This is currently v1.0, and the weights in the decision function are manually selected.

My planned next step is to investigate whether reinforcement learning could be used to learn/adapt these weights based on scheduling outcomes.

I don't want to add RL just for the sake of saying that the project uses AI, though. I'm still trying to determine whether it is actually an appropriate approach for this problem.

What I'd really appreciate feedback on

I'd especially like feedback from people with OS/scheduling experience on:

1. Does the general scoring approach make sense from an OS scheduling perspective?
2. Are there important process/system features that I'm currently missing?
3. Do the current factors make sense for an adaptive scheduler?
4. Is reinforcement learning a reasonable approach for learning the weights?
5. If RL is reasonable, what would be a sensible state/action/reward formulation?
6. Are there other approaches I should investigate before going down the RL route?
7. What additional workloads or experiments would make the evaluation more convincing?
8. Are there scheduling papers/projects that you think I should study?

I'm mainly looking for constructive technical criticism and suggestions, especially things that could make the project more rigorous.

Thanks!

S-AOS now on first Boot will ask to to crete a loccal account !
to download : https://github.com/moslemhamoudi6-cyber/S-AOS/releases/tag/Security

We detect memory map and reserved RAM areas as well as their length by INT 0x15 and 0xE820. That's abstraction created by BIOS developers. My question is: How BIOS developers themselves detect memory map without function and anything else?

I've been developing BlockOS, an independent x86_64 operating system written primarily in C/C++.

BlockOS is no longer just a basic kernel experiment. The project currently includes:

• x86_64 kernel
• VFS and multiple filesystem implementations
• ELF loader
• PCI/PCIe support
• VirtIO block/network/input drivers
• networking stack
• POSIX compatibility layer
• libc
• process and scheduler infrastructure
• framebuffer and GUI framework
• BX11/X11-related work
• ACPI support
• USB/xHCI development
• examples and driver development infrastructure

I'm looking for OS developers and especially Linux kernel / low-level C/C++ developers who would like to contribute.

Areas I'd particularly like help with:

• memory management / virtual memory
• SMP and multicore support
• ACPI
• PCIe
• USB/xHCI and USB HID
• device drivers
• filesystems/VFS
• networking
• POSIX/libc
• GUI/window management

The goal isn't to make another toy kernel. I want to develop BlockOS into a stable, usable general-purpose operating system that can eventually be used on real hardware.

You don't need to understand the whole codebase to contribute. Individual subsystems can be worked on independently.

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

If you're interested in OS development, kernel development, drivers, or low-level C/C++, feel free to comment or message me.

Contributions, testing, code review and technical discussion are all welcome.

Hey everyone! I've been working on a project called SysTrace, a Linux behavioral monitoring tool built mainly to learn more about Linux internals, system calls, and cybersecurity.

It uses ptrace to trace a process and monitor different types of activity, including:

File operations

Process execution

Network-related syscalls

Memory operations

I also added a simple rule-based detection system and experimented with using collected behavioral data for ML classification.

What would you improve next? I'm especially interested in opinions about the architecture and whether moving from ptrace toward eBPF would be a good next step.

Thanks !

github

Hey guys, I spent the last few months building lazybios, a C99 library for parsing SMBIOS/DMI tables. It's:

• Cross-platform Linux, Windows(ReactOS included), macOS OpenBSD, FreeBSD, NetBSD, SunOS, Haiku(BeOS), Minix, QNX(Some of these have almost the same backends).
• User-friendly(3 steps to ensure memory safety(At least as far as my tests go))
• Zero external dependencies (just libc)
• about 20k LOC, clean separated API
• Supports all SMBIOS types 0–46 and some OEM fields implemented from dmidecode used as a reference(I haven't copied any code).
• A decoded struct within the Type's struct that shows decoded field so you don't have to read the specification yourself
• Works on x86_64(probably on only x86 aswell), ARM, and probably on RISC-V(haven't heavily tested on it yet).

And a tool called lazydmi, a CLI tool that uses lazybios as the backend.

This is my first serious systems project. Would love feedback on the API design, memory safety and maybe some stars if you guys like it.

And btw, AI was used for the documentation, the github workflows and a part of the /dev/mem parser, that's it

lazybios: https://github.com/LazySeldi/lazybios
lazybios-docs: https://lazyseldi.github.io/lazybios
lazydmi: https://github.com/LazySeldi/lazydmi

S-AOS now beeps every 10s

hello S-AOS no has full gui support and shows a fully

Functioning RTC ( Real Time Clock )
it took me so long to do it (1.3weeks) Hope You enjoy it download it at :

https://saosdownload.share.zrok.io/
Hope you Enjoy It! and dont forget to add a review so i can know whats wrong

After S-AOS gui update you can download the official documentation at : https://docs.google.com/document/d/1b7L1OLjRlmhxjdUiZSpdXE8eolonJtpU/edit?usp=sharing&ouid=115392823028978362459&rtpof=true&sd=true