differrari /RedactedOS

The [REDACTED] Operating System

★ 299⑂ 27👁 14⑃ 63● 8▤ 0
CNOASSERTIONCreated 2025-04-26
+0
Daily
299
stars
27
forks
14
watchers
63
prs
8
issues
0
releases

README

\[REDACTED\] Operating System

 Summary

The \[REDACTED\] Operating System is a 64 bit operating system meant to run on ARM processors. 
It can run entirely in QEMU, either in an entirely virtual machine using QEMU's virt board, or emulating a Raspberry Pi 4B, it can also be installed on a Raspberry Pi (with limited support).
It also has preliminary support for the Raspberry Pi 5, and possibly 4B and 3B, though these last two are largely untested.
Its GUI is heavily inspired by video game consoles, and the OS is entirely controllable via keyboard (with future mouse and possibly gamepad support)
It has limited support for third party processes, currently limited to entirely self-contained programs. The shared library is provided for syscalls and common functions but it should be used as a static library embedded into the final executable .elf file.

The OS is a hobby project, and my first attempt at writing an OS, so it's subject to improvement, and most likely isn't the most reliable and certainly not the cleanest code.

 Project organization

The project is divided into 3 main sections, each represented by a folder in its main directory.

 Kernel

Contains the kernel code, this code is the entry point to the system and responsible for its initialization.
The system's entry point is the boot.s file (see aboutboot.txt in the kernel folder if there's issues with the boot file). The boot file loads a stack pointer defined in the linker.ld file, which also defines where the kernel is loaded. It then jumps to the kernel_main function located in kernel.c.
The actual system initialization happens in kernel.c's kernel_main function, which is responsible for initializing the system until the point where it's handed off to processes.

Once the system is initialized, most of the system's functionality is provided by processes, which includes kernel processes and user processes. User processes are defined in their own section of the readme file, but kernel processes are included directly into the kernel. While they're placed in their own section defined in the linker, there's no real distinction between their code and any other kernel code. 
Certain parts of the system initialization, such as GPU initialization and XHCI input code initialization rely on some syscalls that expect a process to be running, so an initial kernel.c process is created to hold their data. In the future they'll each have their own process.
Everything about kernel processes and the pseudo-processes mentioned for GPU/XHCI will most likely be improved in the future, to make the system more modular, and kernel processes might get loaded from filesystem, in a similar way to how user processes are loaded. In order to do this, they either need to not rely on any kernel-only code (as several of them currently do) and rely on syscalls entirely, or (less ideal) dynamically link to the kernel. Doing this will increase the kernel's modularity.

The system can run from both the kernel.elf and ker

Snapshot: 2026-11-16T09:23:14Z · Data license Apache-2.0 · JSON